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