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