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