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