mlp: improve request_channel_layout behavior.
[ffmpeg.git] / libavcodec / mlpdec.c
1 /*
2  * MLP decoder
3  * Copyright (c) 2007-2008 Ian Caulfield
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * MLP decoder
25  */
26
27 #include <stdint.h>
28
29 #include "avcodec.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/channel_layout.h"
33 #include "get_bits.h"
34 #include "internal.h"
35 #include "libavutil/crc.h"
36 #include "parser.h"
37 #include "mlp_parser.h"
38 #include "mlpdsp.h"
39 #include "mlp.h"
40
41 /** number of bits used for VLC lookup - longest Huffman code is 9 */
42 #define VLC_BITS            9
43
44 typedef struct SubStream {
45     /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
46     uint8_t     restart_seen;
47
48     //@{
49     /** restart header data */
50     /// The type of noise to be used in the rematrix stage.
51     uint16_t    noise_type;
52
53     /// The index of the first channel coded in this substream.
54     uint8_t     min_channel;
55     /// The index of the last channel coded in this substream.
56     uint8_t     max_channel;
57     /// The number of channels input into the rematrix stage.
58     uint8_t     max_matrix_channel;
59     /// For each channel output by the matrix, the output channel to map it to
60     uint8_t     ch_assign[MAX_CHANNELS];
61     /// The channel layout for this substream
62     uint64_t    ch_layout;
63     /// The matrix encoding mode for this substream
64     enum AVMatrixEncoding matrix_encoding;
65
66     /// Channel coding parameters for channels in the substream
67     ChannelParams channel_params[MAX_CHANNELS];
68
69     /// The left shift applied to random noise in 0x31ea substreams.
70     uint8_t     noise_shift;
71     /// The current seed value for the pseudorandom noise generator(s).
72     uint32_t    noisegen_seed;
73
74     /// Set if the substream contains extra info to check the size of VLC blocks.
75     uint8_t     data_check_present;
76
77     /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
78     uint8_t     param_presence_flags;
79 #define PARAM_BLOCKSIZE     (1 << 7)
80 #define PARAM_MATRIX        (1 << 6)
81 #define PARAM_OUTSHIFT      (1 << 5)
82 #define PARAM_QUANTSTEP     (1 << 4)
83 #define PARAM_FIR           (1 << 3)
84 #define PARAM_IIR           (1 << 2)
85 #define PARAM_HUFFOFFSET    (1 << 1)
86 #define PARAM_PRESENCE      (1 << 0)
87     //@}
88
89     //@{
90     /** matrix data */
91
92     /// Number of matrices to be applied.
93     uint8_t     num_primitive_matrices;
94
95     /// matrix output channel
96     uint8_t     matrix_out_ch[MAX_MATRICES];
97
98     /// Whether the LSBs of the matrix output are encoded in the bitstream.
99     uint8_t     lsb_bypass[MAX_MATRICES];
100     /// Matrix coefficients, stored as 2.14 fixed point.
101     int32_t     matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
102     /// Left shift to apply to noise values in 0x31eb substreams.
103     uint8_t     matrix_noise_shift[MAX_MATRICES];
104     //@}
105
106     /// Left shift to apply to Huffman-decoded residuals.
107     uint8_t     quant_step_size[MAX_CHANNELS];
108
109     /// number of PCM samples in current audio block
110     uint16_t    blocksize;
111     /// Number of PCM samples decoded so far in this frame.
112     uint16_t    blockpos;
113
114     /// Left shift to apply to decoded PCM values to get final 24-bit output.
115     int8_t      output_shift[MAX_CHANNELS];
116
117     /// Running XOR of all output samples.
118     int32_t     lossless_check_data;
119
120 } SubStream;
121
122 typedef struct MLPDecodeContext {
123     AVCodecContext *avctx;
124
125     /// Current access unit being read has a major sync.
126     int         is_major_sync_unit;
127
128     /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
129     uint8_t     params_valid;
130
131     /// Number of substreams contained within this stream.
132     uint8_t     num_substreams;
133
134     /// Index of the last substream to decode - further substreams are skipped.
135     uint8_t     max_decoded_substream;
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         avpriv_request_sample(m->avctx,
336                               "%d substreams (more than the "
337                               "maximum supported by the decoder)",
338                               mh.num_substreams);
339         return AVERROR_PATCHWELCOME;
340     }
341
342     m->access_unit_size      = mh.access_unit_size;
343     m->access_unit_size_pow2 = mh.access_unit_size_pow2;
344
345     m->num_substreams        = mh.num_substreams;
346     m->max_decoded_substream = m->num_substreams - 1;
347
348     m->avctx->sample_rate    = mh.group1_samplerate;
349     m->avctx->frame_size     = mh.access_unit_size;
350
351     m->avctx->bits_per_raw_sample = mh.group1_bits;
352     if (mh.group1_bits > 16)
353         m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
354     else
355         m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
356
357     m->params_valid = 1;
358     for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
359         m->substream[substr].restart_seen = 0;
360
361     /* Set the layout for each substream. When there's more than one, the first
362      * substream is Stereo. Subsequent substreams' layouts are indicated in the
363      * major sync. */
364     if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
365         if ((substr = (mh.num_substreams > 1)))
366             m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
367         m->substream[substr].ch_layout = mh.channel_layout_mlp;
368     } else {
369         if ((substr = (mh.num_substreams > 1)))
370             m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
371         if (mh.num_substreams > 2)
372             if (mh.channel_layout_thd_stream2)
373                 m->substream[2].ch_layout = mh.channel_layout_thd_stream2;
374             else
375                 m->substream[2].ch_layout = mh.channel_layout_thd_stream1;
376         m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;
377     }
378
379     /* Parse the TrueHD decoder channel modifiers and set each substream's
380      * AVMatrixEncoding accordingly.
381      *
382      * The meaning of the modifiers depends on the channel layout:
383      *
384      * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
385      *
386      * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
387      *
388      * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
389      *   layouts with an Ls/Rs channel pair
390      */
391     for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
392         m->substream[substr].matrix_encoding = AV_MATRIX_ENCODING_NONE;
393     if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
394         if (mh.num_substreams > 2 &&
395             mh.channel_layout_thd_stream2 & AV_CH_SIDE_LEFT &&
396             mh.channel_layout_thd_stream2 & AV_CH_SIDE_RIGHT &&
397             mh.channel_modifier_thd_stream2 == THD_CH_MODIFIER_SURROUNDEX)
398             m->substream[2].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
399
400         if (mh.num_substreams > 1 &&
401             mh.channel_layout_thd_stream1 & AV_CH_SIDE_LEFT &&
402             mh.channel_layout_thd_stream1 & AV_CH_SIDE_RIGHT &&
403             mh.channel_modifier_thd_stream1 == THD_CH_MODIFIER_SURROUNDEX)
404             m->substream[1].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
405
406         if (mh.num_substreams > 0)
407             switch (mh.channel_modifier_thd_stream0) {
408             case THD_CH_MODIFIER_LTRT:
409                 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
410                 break;
411             case THD_CH_MODIFIER_LBINRBIN:
412                 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
413                 break;
414             default:
415                 break;
416             }
417     }
418
419     return 0;
420 }
421
422 /** Read a restart header from a block in a substream. This contains parameters
423  *  required to decode the audio that do not change very often. Generally
424  *  (always) present only in blocks following a major sync. */
425
426 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
427                                const uint8_t *buf, unsigned int substr)
428 {
429     SubStream *s = &m->substream[substr];
430     unsigned int ch;
431     int sync_word, tmp;
432     uint8_t checksum;
433     uint8_t lossless_check;
434     int start_count = get_bits_count(gbp);
435     int min_channel, max_channel, max_matrix_channel;
436     const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
437                                      ? MAX_MATRIX_CHANNEL_MLP
438                                      : MAX_MATRIX_CHANNEL_TRUEHD;
439
440     sync_word = get_bits(gbp, 13);
441
442     if (sync_word != 0x31ea >> 1) {
443         av_log(m->avctx, AV_LOG_ERROR,
444                "restart header sync incorrect (got 0x%04x)\n", sync_word);
445         return AVERROR_INVALIDDATA;
446     }
447
448     s->noise_type = get_bits1(gbp);
449
450     if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
451         av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
452         return AVERROR_INVALIDDATA;
453     }
454
455     skip_bits(gbp, 16); /* Output timestamp */
456
457     min_channel        = get_bits(gbp, 4);
458     max_channel        = get_bits(gbp, 4);
459     max_matrix_channel = get_bits(gbp, 4);
460
461     if (max_matrix_channel > std_max_matrix_channel) {
462         av_log(m->avctx, AV_LOG_ERROR,
463                "Max matrix channel cannot be greater than %d.\n",
464                max_matrix_channel);
465         return AVERROR_INVALIDDATA;
466     }
467
468     if (max_channel != max_matrix_channel) {
469         av_log(m->avctx, AV_LOG_ERROR,
470                "Max channel must be equal max matrix channel.\n");
471         return AVERROR_INVALIDDATA;
472     }
473
474     /* This should happen for TrueHD streams with >6 channels and MLP's noise
475      * type. It is not yet known if this is allowed. */
476     if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
477         avpriv_request_sample(m->avctx,
478                               "%d channels (more than the "
479                               "maximum supported by the decoder)",
480                               s->max_channel + 2);
481         return AVERROR_PATCHWELCOME;
482     }
483
484     if (min_channel > max_channel) {
485         av_log(m->avctx, AV_LOG_ERROR,
486                "Substream min channel cannot be greater than max channel.\n");
487         return AVERROR_INVALIDDATA;
488     }
489
490     s->min_channel        = min_channel;
491     s->max_channel        = max_channel;
492     s->max_matrix_channel = max_matrix_channel;
493
494 #if FF_API_REQUEST_CHANNELS
495 FF_DISABLE_DEPRECATION_WARNINGS
496     if (m->avctx->request_channels > 0 &&
497         m->avctx->request_channels <= s->max_channel + 1 &&
498         m->max_decoded_substream > substr) {
499         av_log(m->avctx, AV_LOG_DEBUG,
500                "Extracting %d-channel downmix from substream %d. "
501                "Further substreams will be skipped.\n",
502                s->max_channel + 1, substr);
503         m->max_decoded_substream = substr;
504     } else
505 FF_ENABLE_DEPRECATION_WARNINGS
506 #endif
507     if ((s->ch_layout & m->avctx->request_channel_layout) ==
508         m->avctx->request_channel_layout && m->max_decoded_substream > substr) {
509         av_log(m->avctx, AV_LOG_DEBUG,
510                "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
511                "Further substreams will be skipped.\n",
512                s->max_channel + 1, s->ch_layout, substr);
513         m->max_decoded_substream = substr;
514     }
515
516     s->noise_shift   = get_bits(gbp,  4);
517     s->noisegen_seed = get_bits(gbp, 23);
518
519     skip_bits(gbp, 19);
520
521     s->data_check_present = get_bits1(gbp);
522     lossless_check = get_bits(gbp, 8);
523     if (substr == m->max_decoded_substream
524         && s->lossless_check_data != 0xffffffff) {
525         tmp = xor_32_to_8(s->lossless_check_data);
526         if (tmp != lossless_check)
527             av_log(m->avctx, AV_LOG_WARNING,
528                    "Lossless check failed - expected %02x, calculated %02x.\n",
529                    lossless_check, tmp);
530     }
531
532     skip_bits(gbp, 16);
533
534     memset(s->ch_assign, 0, sizeof(s->ch_assign));
535
536     for (ch = 0; ch <= s->max_matrix_channel; ch++) {
537         int ch_assign = get_bits(gbp, 6);
538         if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
539             uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
540                                                                   ch_assign);
541             ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
542                                                             channel);
543         }
544         if (ch_assign > s->max_matrix_channel) {
545             avpriv_request_sample(m->avctx,
546                                   "Assignment of matrix channel %d to invalid output channel %d",
547                                   ch, ch_assign);
548             return AVERROR_PATCHWELCOME;
549         }
550         s->ch_assign[ch_assign] = ch;
551     }
552
553     checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
554
555     if (checksum != get_bits(gbp, 8))
556         av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
557
558     /* Set default decoding parameters. */
559     s->param_presence_flags   = 0xff;
560     s->num_primitive_matrices = 0;
561     s->blocksize              = 8;
562     s->lossless_check_data    = 0;
563
564     memset(s->output_shift   , 0, sizeof(s->output_shift   ));
565     memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
566
567     for (ch = s->min_channel; ch <= s->max_channel; ch++) {
568         ChannelParams *cp = &s->channel_params[ch];
569         cp->filter_params[FIR].order = 0;
570         cp->filter_params[IIR].order = 0;
571         cp->filter_params[FIR].shift = 0;
572         cp->filter_params[IIR].shift = 0;
573
574         /* Default audio coding is 24-bit raw PCM. */
575         cp->huff_offset      = 0;
576         cp->sign_huff_offset = (-1) << 23;
577         cp->codebook         = 0;
578         cp->huff_lsbs        = 24;
579     }
580
581     if (substr == m->max_decoded_substream) {
582         m->avctx->channels       = s->max_matrix_channel + 1;
583         m->avctx->channel_layout = s->ch_layout;
584     }
585
586     return 0;
587 }
588
589 /** Read parameters for one of the prediction filters. */
590
591 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
592                               unsigned int substr, unsigned int channel,
593                               unsigned int filter)
594 {
595     SubStream *s = &m->substream[substr];
596     FilterParams *fp = &s->channel_params[channel].filter_params[filter];
597     const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
598     const char fchar = filter ? 'I' : 'F';
599     int i, order;
600
601     // Filter is 0 for FIR, 1 for IIR.
602     assert(filter < 2);
603
604     if (m->filter_changed[channel][filter]++ > 1) {
605         av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
606         return AVERROR_INVALIDDATA;
607     }
608
609     order = get_bits(gbp, 4);
610     if (order > max_order) {
611         av_log(m->avctx, AV_LOG_ERROR,
612                "%cIR filter order %d is greater than maximum %d.\n",
613                fchar, order, max_order);
614         return AVERROR_INVALIDDATA;
615     }
616     fp->order = order;
617
618     if (order > 0) {
619         int32_t *fcoeff = s->channel_params[channel].coeff[filter];
620         int coeff_bits, coeff_shift;
621
622         fp->shift = get_bits(gbp, 4);
623
624         coeff_bits  = get_bits(gbp, 5);
625         coeff_shift = get_bits(gbp, 3);
626         if (coeff_bits < 1 || coeff_bits > 16) {
627             av_log(m->avctx, AV_LOG_ERROR,
628                    "%cIR filter coeff_bits must be between 1 and 16.\n",
629                    fchar);
630             return AVERROR_INVALIDDATA;
631         }
632         if (coeff_bits + coeff_shift > 16) {
633             av_log(m->avctx, AV_LOG_ERROR,
634                    "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
635                    fchar);
636             return AVERROR_INVALIDDATA;
637         }
638
639         for (i = 0; i < order; i++)
640             fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
641
642         if (get_bits1(gbp)) {
643             int state_bits, state_shift;
644
645             if (filter == FIR) {
646                 av_log(m->avctx, AV_LOG_ERROR,
647                        "FIR filter has state data specified.\n");
648                 return AVERROR_INVALIDDATA;
649             }
650
651             state_bits  = get_bits(gbp, 4);
652             state_shift = get_bits(gbp, 4);
653
654             /* TODO: Check validity of state data. */
655
656             for (i = 0; i < order; i++)
657                 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
658         }
659     }
660
661     return 0;
662 }
663
664 /** Read parameters for primitive matrices. */
665
666 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
667 {
668     SubStream *s = &m->substream[substr];
669     unsigned int mat, ch;
670     const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
671                                      ? MAX_MATRICES_MLP
672                                      : MAX_MATRICES_TRUEHD;
673
674     if (m->matrix_changed++ > 1) {
675         av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
676         return AVERROR_INVALIDDATA;
677     }
678
679     s->num_primitive_matrices = get_bits(gbp, 4);
680
681     if (s->num_primitive_matrices > max_primitive_matrices) {
682         av_log(m->avctx, AV_LOG_ERROR,
683                "Number of primitive matrices cannot be greater than %d.\n",
684                max_primitive_matrices);
685         return AVERROR_INVALIDDATA;
686     }
687
688     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
689         int frac_bits, max_chan;
690         s->matrix_out_ch[mat] = get_bits(gbp, 4);
691         frac_bits             = get_bits(gbp, 4);
692         s->lsb_bypass   [mat] = get_bits1(gbp);
693
694         if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
695             av_log(m->avctx, AV_LOG_ERROR,
696                     "Invalid channel %d specified as output from matrix.\n",
697                     s->matrix_out_ch[mat]);
698             return AVERROR_INVALIDDATA;
699         }
700         if (frac_bits > 14) {
701             av_log(m->avctx, AV_LOG_ERROR,
702                     "Too many fractional bits specified.\n");
703             return AVERROR_INVALIDDATA;
704         }
705
706         max_chan = s->max_matrix_channel;
707         if (!s->noise_type)
708             max_chan+=2;
709
710         for (ch = 0; ch <= max_chan; ch++) {
711             int coeff_val = 0;
712             if (get_bits1(gbp))
713                 coeff_val = get_sbits(gbp, frac_bits + 2);
714
715             s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
716         }
717
718         if (s->noise_type)
719             s->matrix_noise_shift[mat] = get_bits(gbp, 4);
720         else
721             s->matrix_noise_shift[mat] = 0;
722     }
723
724     return 0;
725 }
726
727 /** Read channel parameters. */
728
729 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
730                                GetBitContext *gbp, unsigned int ch)
731 {
732     SubStream *s = &m->substream[substr];
733     ChannelParams *cp = &s->channel_params[ch];
734     FilterParams *fir = &cp->filter_params[FIR];
735     FilterParams *iir = &cp->filter_params[IIR];
736     int ret;
737
738     if (s->param_presence_flags & PARAM_FIR)
739         if (get_bits1(gbp))
740             if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
741                 return ret;
742
743     if (s->param_presence_flags & PARAM_IIR)
744         if (get_bits1(gbp))
745             if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
746                 return ret;
747
748     if (fir->order + iir->order > 8) {
749         av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
750         return AVERROR_INVALIDDATA;
751     }
752
753     if (fir->order && iir->order &&
754         fir->shift != iir->shift) {
755         av_log(m->avctx, AV_LOG_ERROR,
756                 "FIR and IIR filters must use the same precision.\n");
757         return AVERROR_INVALIDDATA;
758     }
759     /* The FIR and IIR filters must have the same precision.
760      * To simplify the filtering code, only the precision of the
761      * FIR filter is considered. If only the IIR filter is employed,
762      * the FIR filter precision is set to that of the IIR filter, so
763      * that the filtering code can use it. */
764     if (!fir->order && iir->order)
765         fir->shift = iir->shift;
766
767     if (s->param_presence_flags & PARAM_HUFFOFFSET)
768         if (get_bits1(gbp))
769             cp->huff_offset = get_sbits(gbp, 15);
770
771     cp->codebook  = get_bits(gbp, 2);
772     cp->huff_lsbs = get_bits(gbp, 5);
773
774     if (cp->huff_lsbs > 24) {
775         av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
776         return AVERROR_INVALIDDATA;
777     }
778
779     cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
780
781     return 0;
782 }
783
784 /** Read decoding parameters that change more often than those in the restart
785  *  header. */
786
787 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
788                                 unsigned int substr)
789 {
790     SubStream *s = &m->substream[substr];
791     unsigned int ch;
792     int ret;
793
794     if (s->param_presence_flags & PARAM_PRESENCE)
795         if (get_bits1(gbp))
796             s->param_presence_flags = get_bits(gbp, 8);
797
798     if (s->param_presence_flags & PARAM_BLOCKSIZE)
799         if (get_bits1(gbp)) {
800             s->blocksize = get_bits(gbp, 9);
801             if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
802                 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
803                 s->blocksize = 0;
804                 return AVERROR_INVALIDDATA;
805             }
806         }
807
808     if (s->param_presence_flags & PARAM_MATRIX)
809         if (get_bits1(gbp))
810             if ((ret = read_matrix_params(m, substr, gbp)) < 0)
811                 return ret;
812
813     if (s->param_presence_flags & PARAM_OUTSHIFT)
814         if (get_bits1(gbp))
815             for (ch = 0; ch <= s->max_matrix_channel; ch++)
816                 s->output_shift[ch] = get_sbits(gbp, 4);
817
818     if (s->param_presence_flags & PARAM_QUANTSTEP)
819         if (get_bits1(gbp))
820             for (ch = 0; ch <= s->max_channel; ch++) {
821                 ChannelParams *cp = &s->channel_params[ch];
822
823                 s->quant_step_size[ch] = get_bits(gbp, 4);
824
825                 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
826             }
827
828     for (ch = s->min_channel; ch <= s->max_channel; ch++)
829         if (get_bits1(gbp))
830             if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
831                 return ret;
832
833     return 0;
834 }
835
836 #define MSB_MASK(bits)  (-1u << bits)
837
838 /** Generate PCM samples using the prediction filters and residual values
839  *  read from the data stream, and update the filter state. */
840
841 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
842                            unsigned int channel)
843 {
844     SubStream *s = &m->substream[substr];
845     const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
846     int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
847     int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
848     int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
849     FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
850     FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
851     unsigned int filter_shift = fir->shift;
852     int32_t mask = MSB_MASK(s->quant_step_size[channel]);
853
854     memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
855     memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
856
857     m->dsp.mlp_filter_channel(firbuf, fircoeff,
858                               fir->order, iir->order,
859                               filter_shift, mask, s->blocksize,
860                               &m->sample_buffer[s->blockpos][channel]);
861
862     memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
863     memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
864 }
865
866 /** Read a block of PCM residual data (or actual if no filtering active). */
867
868 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
869                            unsigned int substr)
870 {
871     SubStream *s = &m->substream[substr];
872     unsigned int i, ch, expected_stream_pos = 0;
873     int ret;
874
875     if (s->data_check_present) {
876         expected_stream_pos  = get_bits_count(gbp);
877         expected_stream_pos += get_bits(gbp, 16);
878         avpriv_request_sample(m->avctx,
879                               "Substreams with VLC block size check info");
880     }
881
882     if (s->blockpos + s->blocksize > m->access_unit_size) {
883         av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
884         return AVERROR_INVALIDDATA;
885     }
886
887     memset(&m->bypassed_lsbs[s->blockpos][0], 0,
888            s->blocksize * sizeof(m->bypassed_lsbs[0]));
889
890     for (i = 0; i < s->blocksize; i++)
891         if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
892             return ret;
893
894     for (ch = s->min_channel; ch <= s->max_channel; ch++)
895         filter_channel(m, substr, ch);
896
897     s->blockpos += s->blocksize;
898
899     if (s->data_check_present) {
900         if (get_bits_count(gbp) != expected_stream_pos)
901             av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
902         skip_bits(gbp, 8);
903     }
904
905     return 0;
906 }
907
908 /** Data table used for TrueHD noise generation function. */
909
910 static const int8_t noise_table[256] = {
911      30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
912      52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
913      10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
914      51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
915      38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
916      61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
917      67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
918      48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
919       0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
920      16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
921      13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
922      89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
923      36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
924      39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
925      45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
926     -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
927 };
928
929 /** Noise generation functions.
930  *  I'm not sure what these are for - they seem to be some kind of pseudorandom
931  *  sequence generators, used to generate noise data which is used when the
932  *  channels are rematrixed. I'm not sure if they provide a practical benefit
933  *  to compression, or just obfuscate the decoder. Are they for some kind of
934  *  dithering? */
935
936 /** Generate two channels of noise, used in the matrix when
937  *  restart sync word == 0x31ea. */
938
939 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
940 {
941     SubStream *s = &m->substream[substr];
942     unsigned int i;
943     uint32_t seed = s->noisegen_seed;
944     unsigned int maxchan = s->max_matrix_channel;
945
946     for (i = 0; i < s->blockpos; i++) {
947         uint16_t seed_shr7 = seed >> 7;
948         m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
949         m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
950
951         seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
952     }
953
954     s->noisegen_seed = seed;
955 }
956
957 /** Generate a block of noise, used when restart sync word == 0x31eb. */
958
959 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
960 {
961     SubStream *s = &m->substream[substr];
962     unsigned int i;
963     uint32_t seed = s->noisegen_seed;
964
965     for (i = 0; i < m->access_unit_size_pow2; i++) {
966         uint8_t seed_shr15 = seed >> 15;
967         m->noise_buffer[i] = noise_table[seed_shr15];
968         seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
969     }
970
971     s->noisegen_seed = seed;
972 }
973
974
975 /** Apply the channel matrices in turn to reconstruct the original audio
976  *  samples. */
977
978 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
979 {
980     SubStream *s = &m->substream[substr];
981     unsigned int mat, src_ch, i;
982     unsigned int maxchan;
983
984     maxchan = s->max_matrix_channel;
985     if (!s->noise_type) {
986         generate_2_noise_channels(m, substr);
987         maxchan += 2;
988     } else {
989         fill_noise_buffer(m, substr);
990     }
991
992     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
993         int matrix_noise_shift = s->matrix_noise_shift[mat];
994         unsigned int dest_ch = s->matrix_out_ch[mat];
995         int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
996         int32_t *coeffs = s->matrix_coeff[mat];
997         int index  = s->num_primitive_matrices - mat;
998         int index2 = 2 * index + 1;
999
1000         /* TODO: DSPContext? */
1001
1002         for (i = 0; i < s->blockpos; i++) {
1003             int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
1004             int32_t *samples = m->sample_buffer[i];
1005             int64_t accum = 0;
1006
1007             for (src_ch = 0; src_ch <= maxchan; src_ch++)
1008                 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
1009
1010             if (matrix_noise_shift) {
1011                 index &= m->access_unit_size_pow2 - 1;
1012                 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
1013                 index += index2;
1014             }
1015
1016             samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
1017         }
1018     }
1019 }
1020
1021 /** Write the audio data into the output buffer. */
1022
1023 static int output_data(MLPDecodeContext *m, unsigned int substr,
1024                        AVFrame *frame, int *got_frame_ptr)
1025 {
1026     AVCodecContext *avctx = m->avctx;
1027     SubStream *s = &m->substream[substr];
1028     unsigned int i, out_ch = 0;
1029     int32_t *data_32;
1030     int16_t *data_16;
1031     int ret;
1032     int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1033
1034     if (m->avctx->channels != s->max_matrix_channel + 1) {
1035         av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1036         return AVERROR_INVALIDDATA;
1037     }
1038
1039     if (!s->blockpos) {
1040         av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1041         return AVERROR_INVALIDDATA;
1042     }
1043
1044     /* get output buffer */
1045     frame->nb_samples = s->blockpos;
1046     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1047         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1048         return ret;
1049     }
1050     data_32 = (int32_t *)frame->data[0];
1051     data_16 = (int16_t *)frame->data[0];
1052
1053     for (i = 0; i < s->blockpos; i++) {
1054         for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
1055             int mat_ch = s->ch_assign[out_ch];
1056             int32_t sample = m->sample_buffer[i][mat_ch]
1057                           << s->output_shift[mat_ch];
1058             s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
1059             if (is32) *data_32++ = sample << 8;
1060             else      *data_16++ = sample >> 8;
1061         }
1062     }
1063
1064     /* Update matrix encoding side data */
1065     if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1066         return ret;
1067
1068     *got_frame_ptr = 1;
1069
1070     return 0;
1071 }
1072
1073 /** Read an access unit from the stream.
1074  *  @return negative on error, 0 if not enough data is present in the input stream,
1075  *  otherwise the number of bytes consumed. */
1076
1077 static int read_access_unit(AVCodecContext *avctx, void* data,
1078                             int *got_frame_ptr, AVPacket *avpkt)
1079 {
1080     const uint8_t *buf = avpkt->data;
1081     int buf_size = avpkt->size;
1082     MLPDecodeContext *m = avctx->priv_data;
1083     GetBitContext gb;
1084     unsigned int length, substr;
1085     unsigned int substream_start;
1086     unsigned int header_size = 4;
1087     unsigned int substr_header_size = 0;
1088     uint8_t substream_parity_present[MAX_SUBSTREAMS];
1089     uint16_t substream_data_len[MAX_SUBSTREAMS];
1090     uint8_t parity_bits;
1091     int ret;
1092
1093     if (buf_size < 4)
1094         return 0;
1095
1096     length = (AV_RB16(buf) & 0xfff) * 2;
1097
1098     if (length < 4 || length > buf_size)
1099         return AVERROR_INVALIDDATA;
1100
1101     init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1102
1103     m->is_major_sync_unit = 0;
1104     if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1105         if (read_major_sync(m, &gb) < 0)
1106             goto error;
1107         m->is_major_sync_unit = 1;
1108         header_size += 28;
1109     }
1110
1111     if (!m->params_valid) {
1112         av_log(m->avctx, AV_LOG_WARNING,
1113                "Stream parameters not seen; skipping frame.\n");
1114         *got_frame_ptr = 0;
1115         return length;
1116     }
1117
1118     substream_start = 0;
1119
1120     for (substr = 0; substr < m->num_substreams; substr++) {
1121         int extraword_present, checkdata_present, end, nonrestart_substr;
1122
1123         extraword_present = get_bits1(&gb);
1124         nonrestart_substr = get_bits1(&gb);
1125         checkdata_present = get_bits1(&gb);
1126         skip_bits1(&gb);
1127
1128         end = get_bits(&gb, 12) * 2;
1129
1130         substr_header_size += 2;
1131
1132         if (extraword_present) {
1133             if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1134                 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1135                 goto error;
1136             }
1137             skip_bits(&gb, 16);
1138             substr_header_size += 2;
1139         }
1140
1141         if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1142             av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1143             goto error;
1144         }
1145
1146         if (end + header_size + substr_header_size > length) {
1147             av_log(m->avctx, AV_LOG_ERROR,
1148                    "Indicated length of substream %d data goes off end of "
1149                    "packet.\n", substr);
1150             end = length - header_size - substr_header_size;
1151         }
1152
1153         if (end < substream_start) {
1154             av_log(avctx, AV_LOG_ERROR,
1155                    "Indicated end offset of substream %d data "
1156                    "is smaller than calculated start offset.\n",
1157                    substr);
1158             goto error;
1159         }
1160
1161         if (substr > m->max_decoded_substream)
1162             continue;
1163
1164         substream_parity_present[substr] = checkdata_present;
1165         substream_data_len[substr] = end - substream_start;
1166         substream_start = end;
1167     }
1168
1169     parity_bits  = ff_mlp_calculate_parity(buf, 4);
1170     parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1171
1172     if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1173         av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1174         goto error;
1175     }
1176
1177     buf += header_size + substr_header_size;
1178
1179     for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1180         SubStream *s = &m->substream[substr];
1181         init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1182
1183         m->matrix_changed = 0;
1184         memset(m->filter_changed, 0, sizeof(m->filter_changed));
1185
1186         s->blockpos = 0;
1187         do {
1188             if (get_bits1(&gb)) {
1189                 if (get_bits1(&gb)) {
1190                     /* A restart header should be present. */
1191                     if (read_restart_header(m, &gb, buf, substr) < 0)
1192                         goto next_substr;
1193                     s->restart_seen = 1;
1194                 }
1195
1196                 if (!s->restart_seen)
1197                     goto next_substr;
1198                 if (read_decoding_params(m, &gb, substr) < 0)
1199                     goto next_substr;
1200             }
1201
1202             if (!s->restart_seen)
1203                 goto next_substr;
1204
1205             if ((ret = read_block_data(m, &gb, substr)) < 0)
1206                 return ret;
1207
1208             if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1209                 goto substream_length_mismatch;
1210
1211         } while (!get_bits1(&gb));
1212
1213         skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1214
1215         if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1216             int shorten_by;
1217
1218             if (get_bits(&gb, 16) != 0xD234)
1219                 return AVERROR_INVALIDDATA;
1220
1221             shorten_by = get_bits(&gb, 16);
1222             if      (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by  & 0x2000)
1223                 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1224             else if (m->avctx->codec_id == AV_CODEC_ID_MLP    && shorten_by != 0xD234)
1225                 return AVERROR_INVALIDDATA;
1226
1227             if (substr == m->max_decoded_substream)
1228                 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1229         }
1230
1231         if (substream_parity_present[substr]) {
1232             uint8_t parity, checksum;
1233
1234             if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1235                 goto substream_length_mismatch;
1236
1237             parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1238             checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
1239
1240             if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
1241                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1242             if ( get_bits(&gb, 8)           != checksum)
1243                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
1244         }
1245
1246         if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1247             goto substream_length_mismatch;
1248
1249 next_substr:
1250         if (!s->restart_seen)
1251             av_log(m->avctx, AV_LOG_ERROR,
1252                    "No restart header present in substream %d.\n", substr);
1253
1254         buf += substream_data_len[substr];
1255     }
1256
1257     rematrix_channels(m, m->max_decoded_substream);
1258
1259     if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1260         return ret;
1261
1262     return length;
1263
1264 substream_length_mismatch:
1265     av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1266     return AVERROR_INVALIDDATA;
1267
1268 error:
1269     m->params_valid = 0;
1270     return AVERROR_INVALIDDATA;
1271 }
1272
1273 AVCodec ff_mlp_decoder = {
1274     .name           = "mlp",
1275     .long_name      = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1276     .type           = AVMEDIA_TYPE_AUDIO,
1277     .id             = AV_CODEC_ID_MLP,
1278     .priv_data_size = sizeof(MLPDecodeContext),
1279     .init           = mlp_decode_init,
1280     .decode         = read_access_unit,
1281     .capabilities   = CODEC_CAP_DR1,
1282 };
1283
1284 #if CONFIG_TRUEHD_DECODER
1285 AVCodec ff_truehd_decoder = {
1286     .name           = "truehd",
1287     .long_name      = NULL_IF_CONFIG_SMALL("TrueHD"),
1288     .type           = AVMEDIA_TYPE_AUDIO,
1289     .id             = AV_CODEC_ID_TRUEHD,
1290     .priv_data_size = sizeof(MLPDecodeContext),
1291     .init           = mlp_decode_init,
1292     .decode         = read_access_unit,
1293     .capabilities   = CODEC_CAP_DR1,
1294 };
1295 #endif /* CONFIG_TRUEHD_DECODER */