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