j2k: restructure bitstream decoding
[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         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         if (m->avctx->channels<=2 && m->substream[substr].ch_layout == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
379             av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
380             m->max_decoded_substream = 0;
381             if (m->avctx->channels==2)
382                 m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
383         }
384     }
385
386     m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
387
388     return 0;
389 }
390
391 /** Read a restart header from a block in a substream. This contains parameters
392  *  required to decode the audio that do not change very often. Generally
393  *  (always) present only in blocks following a major sync. */
394
395 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
396                                const uint8_t *buf, unsigned int substr)
397 {
398     SubStream *s = &m->substream[substr];
399     unsigned int ch;
400     int sync_word, tmp;
401     uint8_t checksum;
402     uint8_t lossless_check;
403     int start_count = get_bits_count(gbp);
404     const int max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
405                                  ? MAX_MATRIX_CHANNEL_MLP
406                                  : MAX_MATRIX_CHANNEL_TRUEHD;
407     int max_channel, min_channel, matrix_channel;
408
409     sync_word = get_bits(gbp, 13);
410
411     if (sync_word != 0x31ea >> 1) {
412         av_log(m->avctx, AV_LOG_ERROR,
413                "restart header sync incorrect (got 0x%04x)\n", sync_word);
414         return AVERROR_INVALIDDATA;
415     }
416
417     s->noise_type = get_bits1(gbp);
418
419     if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
420         av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
421         return AVERROR_INVALIDDATA;
422     }
423
424     skip_bits(gbp, 16); /* Output timestamp */
425
426     min_channel    = get_bits(gbp, 4);
427     max_channel    = get_bits(gbp, 4);
428     matrix_channel = get_bits(gbp, 4);
429
430     if (matrix_channel > max_matrix_channel) {
431         av_log(m->avctx, AV_LOG_ERROR,
432                "Max matrix channel cannot be greater than %d.\n",
433                max_matrix_channel);
434         return AVERROR_INVALIDDATA;
435     }
436
437     if (max_channel != matrix_channel) {
438         av_log(m->avctx, AV_LOG_ERROR,
439                "Max channel must be equal max matrix channel.\n");
440         return AVERROR_INVALIDDATA;
441     }
442
443     /* This should happen for TrueHD streams with >6 channels and MLP's noise
444      * type. It is not yet known if this is allowed. */
445     if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
446         avpriv_request_sample(m->avctx,
447                               "%d channels (more than the "
448                               "maximum supported by the decoder)",
449                               max_channel + 2);
450         return AVERROR_PATCHWELCOME;
451     }
452
453     if (min_channel > max_channel) {
454         av_log(m->avctx, AV_LOG_ERROR,
455                "Substream min channel cannot be greater than max channel.\n");
456         return AVERROR_INVALIDDATA;
457     }
458
459     s->min_channel = min_channel;
460     s->max_channel = max_channel;
461     s->max_matrix_channel = matrix_channel;
462
463 #if FF_API_REQUEST_CHANNELS
464     if (m->avctx->request_channels > 0 &&
465         m->avctx->request_channels <= s->max_channel + 1 &&
466         m->max_decoded_substream > substr) {
467         av_log(m->avctx, AV_LOG_DEBUG,
468                "Extracting %d-channel downmix from substream %d. "
469                "Further substreams will be skipped.\n",
470                s->max_channel + 1, substr);
471         m->max_decoded_substream = substr;
472     } else
473 #endif
474     if (m->avctx->request_channel_layout == s->ch_layout &&
475         m->max_decoded_substream > substr) {
476         av_log(m->avctx, AV_LOG_DEBUG,
477                "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
478                "Further substreams will be skipped.\n",
479                s->max_channel + 1, s->ch_layout, substr);
480         m->max_decoded_substream = substr;
481     }
482
483     s->noise_shift   = get_bits(gbp,  4);
484     s->noisegen_seed = get_bits(gbp, 23);
485
486     skip_bits(gbp, 19);
487
488     s->data_check_present = get_bits1(gbp);
489     lossless_check = get_bits(gbp, 8);
490     if (substr == m->max_decoded_substream
491         && s->lossless_check_data != 0xffffffff) {
492         tmp = xor_32_to_8(s->lossless_check_data);
493         if (tmp != lossless_check)
494             av_log(m->avctx, AV_LOG_WARNING,
495                    "Lossless check failed - expected %02x, calculated %02x.\n",
496                    lossless_check, tmp);
497     }
498
499     skip_bits(gbp, 16);
500
501     memset(s->ch_assign, 0, sizeof(s->ch_assign));
502
503     for (ch = 0; ch <= s->max_matrix_channel; ch++) {
504         int ch_assign = get_bits(gbp, 6);
505         if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
506             uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
507                                                                   ch_assign);
508             ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
509                                                             channel);
510         }
511         if ((unsigned)ch_assign > s->max_matrix_channel) {
512             avpriv_request_sample(m->avctx,
513                                   "Assignment of matrix channel %d to invalid output channel %d",
514                                   ch, ch_assign);
515             return AVERROR_PATCHWELCOME;
516         }
517         s->ch_assign[ch_assign] = ch;
518     }
519
520     checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
521
522     if (checksum != get_bits(gbp, 8))
523         av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
524
525     /* Set default decoding parameters. */
526     s->param_presence_flags   = 0xff;
527     s->num_primitive_matrices = 0;
528     s->blocksize              = 8;
529     s->lossless_check_data    = 0;
530
531     memset(s->output_shift   , 0, sizeof(s->output_shift   ));
532     memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
533
534     for (ch = s->min_channel; ch <= s->max_channel; ch++) {
535         ChannelParams *cp = &s->channel_params[ch];
536         cp->filter_params[FIR].order = 0;
537         cp->filter_params[IIR].order = 0;
538         cp->filter_params[FIR].shift = 0;
539         cp->filter_params[IIR].shift = 0;
540
541         /* Default audio coding is 24-bit raw PCM. */
542         cp->huff_offset      = 0;
543         cp->sign_huff_offset = (-1) << 23;
544         cp->codebook         = 0;
545         cp->huff_lsbs        = 24;
546     }
547
548     if (substr == m->max_decoded_substream) {
549         m->avctx->channels       = s->max_matrix_channel + 1;
550         m->avctx->channel_layout = s->ch_layout;
551
552         if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
553             if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
554                 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
555                 int i = s->ch_assign[4];
556                 s->ch_assign[4] = s->ch_assign[3];
557                 s->ch_assign[3] = s->ch_assign[2];
558                 s->ch_assign[2] = i;
559             } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
560                 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
561                 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
562             }
563         }
564
565     }
566
567     return 0;
568 }
569
570 /** Read parameters for one of the prediction filters. */
571
572 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
573                               unsigned int substr, unsigned int channel,
574                               unsigned int filter)
575 {
576     SubStream *s = &m->substream[substr];
577     FilterParams *fp = &s->channel_params[channel].filter_params[filter];
578     const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
579     const char fchar = filter ? 'I' : 'F';
580     int i, order;
581
582     // Filter is 0 for FIR, 1 for IIR.
583     av_assert0(filter < 2);
584
585     if (m->filter_changed[channel][filter]++ > 1) {
586         av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
587         return AVERROR_INVALIDDATA;
588     }
589
590     order = get_bits(gbp, 4);
591     if (order > max_order) {
592         av_log(m->avctx, AV_LOG_ERROR,
593                "%cIR filter order %d is greater than maximum %d.\n",
594                fchar, order, max_order);
595         return AVERROR_INVALIDDATA;
596     }
597     fp->order = order;
598
599     if (order > 0) {
600         int32_t *fcoeff = s->channel_params[channel].coeff[filter];
601         int coeff_bits, coeff_shift;
602
603         fp->shift = get_bits(gbp, 4);
604
605         coeff_bits  = get_bits(gbp, 5);
606         coeff_shift = get_bits(gbp, 3);
607         if (coeff_bits < 1 || coeff_bits > 16) {
608             av_log(m->avctx, AV_LOG_ERROR,
609                    "%cIR filter coeff_bits must be between 1 and 16.\n",
610                    fchar);
611             return AVERROR_INVALIDDATA;
612         }
613         if (coeff_bits + coeff_shift > 16) {
614             av_log(m->avctx, AV_LOG_ERROR,
615                    "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
616                    fchar);
617             return AVERROR_INVALIDDATA;
618         }
619
620         for (i = 0; i < order; i++)
621             fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
622
623         if (get_bits1(gbp)) {
624             int state_bits, state_shift;
625
626             if (filter == FIR) {
627                 av_log(m->avctx, AV_LOG_ERROR,
628                        "FIR filter has state data specified.\n");
629                 return AVERROR_INVALIDDATA;
630             }
631
632             state_bits  = get_bits(gbp, 4);
633             state_shift = get_bits(gbp, 4);
634
635             /* TODO: Check validity of state data. */
636
637             for (i = 0; i < order; i++)
638                 fp->state[i] = state_bits ? get_sbits(gbp, state_bits) << state_shift : 0;
639         }
640     }
641
642     return 0;
643 }
644
645 /** Read parameters for primitive matrices. */
646
647 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
648 {
649     SubStream *s = &m->substream[substr];
650     unsigned int mat, ch;
651     const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
652                                      ? MAX_MATRICES_MLP
653                                      : MAX_MATRICES_TRUEHD;
654
655     if (m->matrix_changed++ > 1) {
656         av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
657         return AVERROR_INVALIDDATA;
658     }
659
660     s->num_primitive_matrices = get_bits(gbp, 4);
661
662     if (s->num_primitive_matrices > max_primitive_matrices) {
663         av_log(m->avctx, AV_LOG_ERROR,
664                "Number of primitive matrices cannot be greater than %d.\n",
665                max_primitive_matrices);
666         return AVERROR_INVALIDDATA;
667     }
668
669     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
670         int frac_bits, max_chan;
671         s->matrix_out_ch[mat] = get_bits(gbp, 4);
672         frac_bits             = get_bits(gbp, 4);
673         s->lsb_bypass   [mat] = get_bits1(gbp);
674
675         if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
676             av_log(m->avctx, AV_LOG_ERROR,
677                     "Invalid channel %d specified as output from matrix.\n",
678                     s->matrix_out_ch[mat]);
679             return AVERROR_INVALIDDATA;
680         }
681         if (frac_bits > 14) {
682             av_log(m->avctx, AV_LOG_ERROR,
683                     "Too many fractional bits specified.\n");
684             return AVERROR_INVALIDDATA;
685         }
686
687         max_chan = s->max_matrix_channel;
688         if (!s->noise_type)
689             max_chan+=2;
690
691         for (ch = 0; ch <= max_chan; ch++) {
692             int coeff_val = 0;
693             if (get_bits1(gbp))
694                 coeff_val = get_sbits(gbp, frac_bits + 2);
695
696             s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
697         }
698
699         if (s->noise_type)
700             s->matrix_noise_shift[mat] = get_bits(gbp, 4);
701         else
702             s->matrix_noise_shift[mat] = 0;
703     }
704
705     return 0;
706 }
707
708 /** Read channel parameters. */
709
710 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
711                                GetBitContext *gbp, unsigned int ch)
712 {
713     SubStream *s = &m->substream[substr];
714     ChannelParams *cp = &s->channel_params[ch];
715     FilterParams *fir = &cp->filter_params[FIR];
716     FilterParams *iir = &cp->filter_params[IIR];
717     int ret;
718
719     if (s->param_presence_flags & PARAM_FIR)
720         if (get_bits1(gbp))
721             if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
722                 return ret;
723
724     if (s->param_presence_flags & PARAM_IIR)
725         if (get_bits1(gbp))
726             if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
727                 return ret;
728
729     if (fir->order + iir->order > 8) {
730         av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
731         return AVERROR_INVALIDDATA;
732     }
733
734     if (fir->order && iir->order &&
735         fir->shift != iir->shift) {
736         av_log(m->avctx, AV_LOG_ERROR,
737                 "FIR and IIR filters must use the same precision.\n");
738         return AVERROR_INVALIDDATA;
739     }
740     /* The FIR and IIR filters must have the same precision.
741      * To simplify the filtering code, only the precision of the
742      * FIR filter is considered. If only the IIR filter is employed,
743      * the FIR filter precision is set to that of the IIR filter, so
744      * that the filtering code can use it. */
745     if (!fir->order && iir->order)
746         fir->shift = iir->shift;
747
748     if (s->param_presence_flags & PARAM_HUFFOFFSET)
749         if (get_bits1(gbp))
750             cp->huff_offset = get_sbits(gbp, 15);
751
752     cp->codebook  = get_bits(gbp, 2);
753     cp->huff_lsbs = get_bits(gbp, 5);
754
755     if (cp->huff_lsbs > 24) {
756         av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
757         cp->huff_lsbs = 0;
758         return AVERROR_INVALIDDATA;
759     }
760
761     cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
762
763     return 0;
764 }
765
766 /** Read decoding parameters that change more often than those in the restart
767  *  header. */
768
769 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
770                                 unsigned int substr)
771 {
772     SubStream *s = &m->substream[substr];
773     unsigned int ch;
774     int ret;
775
776     if (s->param_presence_flags & PARAM_PRESENCE)
777         if (get_bits1(gbp))
778             s->param_presence_flags = get_bits(gbp, 8);
779
780     if (s->param_presence_flags & PARAM_BLOCKSIZE)
781         if (get_bits1(gbp)) {
782             s->blocksize = get_bits(gbp, 9);
783             if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
784                 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
785                 s->blocksize = 0;
786                 return AVERROR_INVALIDDATA;
787             }
788         }
789
790     if (s->param_presence_flags & PARAM_MATRIX)
791         if (get_bits1(gbp))
792             if ((ret = read_matrix_params(m, substr, gbp)) < 0)
793                 return ret;
794
795     if (s->param_presence_flags & PARAM_OUTSHIFT)
796         if (get_bits1(gbp))
797             for (ch = 0; ch <= s->max_matrix_channel; ch++)
798                 s->output_shift[ch] = get_sbits(gbp, 4);
799
800     if (s->param_presence_flags & PARAM_QUANTSTEP)
801         if (get_bits1(gbp))
802             for (ch = 0; ch <= s->max_channel; ch++) {
803                 ChannelParams *cp = &s->channel_params[ch];
804
805                 s->quant_step_size[ch] = get_bits(gbp, 4);
806
807                 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
808             }
809
810     for (ch = s->min_channel; ch <= s->max_channel; ch++)
811         if (get_bits1(gbp))
812             if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
813                 return ret;
814
815     return 0;
816 }
817
818 #define MSB_MASK(bits)  (-1u << bits)
819
820 /** Generate PCM samples using the prediction filters and residual values
821  *  read from the data stream, and update the filter state. */
822
823 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
824                            unsigned int channel)
825 {
826     SubStream *s = &m->substream[substr];
827     const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
828     int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
829     int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
830     int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
831     FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
832     FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
833     unsigned int filter_shift = fir->shift;
834     int32_t mask = MSB_MASK(s->quant_step_size[channel]);
835
836     memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
837     memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
838
839     m->dsp.mlp_filter_channel(firbuf, fircoeff,
840                               fir->order, iir->order,
841                               filter_shift, mask, s->blocksize,
842                               &m->sample_buffer[s->blockpos][channel]);
843
844     memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
845     memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
846 }
847
848 /** Read a block of PCM residual data (or actual if no filtering active). */
849
850 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
851                            unsigned int substr)
852 {
853     SubStream *s = &m->substream[substr];
854     unsigned int i, ch, expected_stream_pos = 0;
855     int ret;
856
857     if (s->data_check_present) {
858         expected_stream_pos  = get_bits_count(gbp);
859         expected_stream_pos += get_bits(gbp, 16);
860         avpriv_request_sample(m->avctx,
861                               "Substreams with VLC block size check info");
862     }
863
864     if (s->blockpos + s->blocksize > m->access_unit_size) {
865         av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
866         return AVERROR_INVALIDDATA;
867     }
868
869     memset(&m->bypassed_lsbs[s->blockpos][0], 0,
870            s->blocksize * sizeof(m->bypassed_lsbs[0]));
871
872     for (i = 0; i < s->blocksize; i++)
873         if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
874             return ret;
875
876     for (ch = s->min_channel; ch <= s->max_channel; ch++)
877         filter_channel(m, substr, ch);
878
879     s->blockpos += s->blocksize;
880
881     if (s->data_check_present) {
882         if (get_bits_count(gbp) != expected_stream_pos)
883             av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
884         skip_bits(gbp, 8);
885     }
886
887     return 0;
888 }
889
890 /** Data table used for TrueHD noise generation function. */
891
892 static const int8_t noise_table[256] = {
893      30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
894      52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
895      10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
896      51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
897      38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
898      61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
899      67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
900      48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
901       0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
902      16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
903      13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
904      89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
905      36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
906      39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
907      45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
908     -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
909 };
910
911 /** Noise generation functions.
912  *  I'm not sure what these are for - they seem to be some kind of pseudorandom
913  *  sequence generators, used to generate noise data which is used when the
914  *  channels are rematrixed. I'm not sure if they provide a practical benefit
915  *  to compression, or just obfuscate the decoder. Are they for some kind of
916  *  dithering? */
917
918 /** Generate two channels of noise, used in the matrix when
919  *  restart sync word == 0x31ea. */
920
921 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
922 {
923     SubStream *s = &m->substream[substr];
924     unsigned int i;
925     uint32_t seed = s->noisegen_seed;
926     unsigned int maxchan = s->max_matrix_channel;
927
928     for (i = 0; i < s->blockpos; i++) {
929         uint16_t seed_shr7 = seed >> 7;
930         m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
931         m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
932
933         seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
934     }
935
936     s->noisegen_seed = seed;
937 }
938
939 /** Generate a block of noise, used when restart sync word == 0x31eb. */
940
941 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
942 {
943     SubStream *s = &m->substream[substr];
944     unsigned int i;
945     uint32_t seed = s->noisegen_seed;
946
947     for (i = 0; i < m->access_unit_size_pow2; i++) {
948         uint8_t seed_shr15 = seed >> 15;
949         m->noise_buffer[i] = noise_table[seed_shr15];
950         seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
951     }
952
953     s->noisegen_seed = seed;
954 }
955
956
957 /** Apply the channel matrices in turn to reconstruct the original audio
958  *  samples. */
959
960 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
961 {
962     SubStream *s = &m->substream[substr];
963     unsigned int mat, src_ch, i;
964     unsigned int maxchan;
965
966     maxchan = s->max_matrix_channel;
967     if (!s->noise_type) {
968         generate_2_noise_channels(m, substr);
969         maxchan += 2;
970     } else {
971         fill_noise_buffer(m, substr);
972     }
973
974     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
975         int matrix_noise_shift = s->matrix_noise_shift[mat];
976         unsigned int dest_ch = s->matrix_out_ch[mat];
977         int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
978         int32_t *coeffs = s->matrix_coeff[mat];
979         int index  = s->num_primitive_matrices - mat;
980         int index2 = 2 * index + 1;
981
982         /* TODO: DSPContext? */
983
984         for (i = 0; i < s->blockpos; i++) {
985             int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
986             int32_t *samples = m->sample_buffer[i];
987             int64_t accum = 0;
988
989             for (src_ch = 0; src_ch <= maxchan; src_ch++)
990                 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
991
992             if (matrix_noise_shift) {
993                 index &= m->access_unit_size_pow2 - 1;
994                 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
995                 index += index2;
996             }
997
998             samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
999         }
1000     }
1001 }
1002
1003 /** Write the audio data into the output buffer. */
1004
1005 static int output_data(MLPDecodeContext *m, unsigned int substr,
1006                        AVFrame *frame, int *got_frame_ptr)
1007 {
1008     AVCodecContext *avctx = m->avctx;
1009     SubStream *s = &m->substream[substr];
1010     unsigned int i, out_ch = 0;
1011     int32_t *data_32;
1012     int16_t *data_16;
1013     int ret;
1014     int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1015
1016     if (m->avctx->channels != s->max_matrix_channel + 1) {
1017         av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1018         return AVERROR_INVALIDDATA;
1019     }
1020
1021     if (!s->blockpos) {
1022         av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1023         return AVERROR_INVALIDDATA;
1024     }
1025
1026     /* get output buffer */
1027     frame->nb_samples = s->blockpos;
1028     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1029         return ret;
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 */