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