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