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