d44c9b0b292ecdc99b1ec03192cd8f6dc6d2a230
[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 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.mplayerhq.hu/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()
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     avctx->sample_fmt = SAMPLE_FMT_S16;
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 #ifdef CONFIG_AUDIO_NONSHORT
300     m->avctx->bits_per_sample = mh.group1_bits;
301     if (mh.group1_bits > 16) {
302         m->avctx->sample_fmt = SAMPLE_FMT_S32;
303     }
304 #endif
305
306     m->params_valid = 1;
307     for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
308         m->substream[substr].restart_seen = 0;
309
310     return 0;
311 }
312
313 /** Read a restart header from a block in a substream. This contains parameters
314  *  required to decode the audio that do not change very often. Generally
315  *  (always) present only in blocks following a major sync. */
316
317 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
318                                const uint8_t *buf, unsigned int substr)
319 {
320     SubStream *s = &m->substream[substr];
321     unsigned int ch;
322     int sync_word, tmp;
323     uint8_t checksum;
324     uint8_t lossless_check;
325     int start_count = get_bits_count(gbp);
326
327     sync_word = get_bits(gbp, 13);
328
329     if (sync_word != 0x31ea >> 1) {
330         av_log(m->avctx, AV_LOG_ERROR,
331                "restart header sync incorrect (got 0x%04x)\n", sync_word);
332         return -1;
333     }
334     s->noise_type = get_bits1(gbp);
335
336     skip_bits(gbp, 16); /* Output timestamp */
337
338     s->min_channel        = get_bits(gbp, 4);
339     s->max_channel        = get_bits(gbp, 4);
340     s->max_matrix_channel = get_bits(gbp, 4);
341
342     if (s->min_channel > s->max_channel) {
343         av_log(m->avctx, AV_LOG_ERROR,
344                "Substream min channel cannot be greater than max channel.\n");
345         return -1;
346     }
347
348     if (m->avctx->request_channels > 0
349         && s->max_channel + 1 >= m->avctx->request_channels
350         && substr < m->max_decoded_substream) {
351         av_log(m->avctx, AV_LOG_INFO,
352                "Extracting %d channel downmix from substream %d. "
353                "Further substreams will be skipped.\n",
354                s->max_channel + 1, substr);
355         m->max_decoded_substream = substr;
356     }
357
358     s->noise_shift   = get_bits(gbp,  4);
359     s->noisegen_seed = get_bits(gbp, 23);
360
361     skip_bits(gbp, 19);
362
363     s->data_check_present = get_bits1(gbp);
364     lossless_check = get_bits(gbp, 8);
365     if (substr == m->max_decoded_substream
366         && s->lossless_check_data != 0xffffffff) {
367         tmp = s->lossless_check_data;
368         tmp ^= tmp >> 16;
369         tmp ^= tmp >> 8;
370         tmp &= 0xff;
371         if (tmp != lossless_check)
372             av_log(m->avctx, AV_LOG_WARNING,
373                    "Lossless check failed - expected %02x, calculated %02x.\n",
374                    lossless_check, tmp);
375         else
376             dprintf(m->avctx, "Lossless check passed for substream %d (%x).\n",
377                     substr, tmp);
378     }
379
380     skip_bits(gbp, 16);
381
382     for (ch = 0; ch <= s->max_matrix_channel; ch++) {
383         int ch_assign = get_bits(gbp, 6);
384         dprintf(m->avctx, "ch_assign[%d][%d] = %d\n", substr, ch,
385                 ch_assign);
386         if (ch_assign != ch) {
387             av_log(m->avctx, AV_LOG_ERROR,
388                    "Non-1:1 channel assignments are used in this stream. %s\n",
389                    sample_message);
390             return -1;
391         }
392     }
393
394     checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
395
396     if (checksum != get_bits(gbp, 8))
397         av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
398
399     /* Set default decoding parameters. */
400     s->param_presence_flags   = 0xff;
401     s->num_primitive_matrices = 0;
402     s->blocksize              = 8;
403     s->lossless_check_data    = 0;
404
405     memset(s->output_shift   , 0, sizeof(s->output_shift   ));
406     memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
407
408     for (ch = s->min_channel; ch <= s->max_channel; ch++) {
409         ChannelParams *cp = &m->channel_params[ch];
410         cp->filter_params[FIR].order = 0;
411         cp->filter_params[IIR].order = 0;
412         cp->filter_params[FIR].shift = 0;
413         cp->filter_params[IIR].shift = 0;
414
415         /* Default audio coding is 24-bit raw PCM. */
416         cp->huff_offset      = 0;
417         cp->sign_huff_offset = (-1) << 23;
418         cp->codebook         = 0;
419         cp->huff_lsbs        = 24;
420     }
421
422     if (substr == m->max_decoded_substream) {
423         m->avctx->channels = s->max_channel + 1;
424     }
425
426     return 0;
427 }
428
429 /** Read parameters for one of the prediction filters. */
430
431 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
432                               unsigned int channel, unsigned int filter)
433 {
434     FilterParams *fp = &m->channel_params[channel].filter_params[filter];
435     const char fchar = filter ? 'I' : 'F';
436     int i, order;
437
438     // Filter is 0 for FIR, 1 for IIR.
439     assert(filter < 2);
440
441     order = get_bits(gbp, 4);
442     if (order > MAX_FILTER_ORDER) {
443         av_log(m->avctx, AV_LOG_ERROR,
444                "%cIR filter order %d is greater than maximum %d.\n",
445                fchar, order, MAX_FILTER_ORDER);
446         return -1;
447     }
448     fp->order = order;
449
450     if (order > 0) {
451         int coeff_bits, coeff_shift;
452
453         fp->shift = get_bits(gbp, 4);
454
455         coeff_bits  = get_bits(gbp, 5);
456         coeff_shift = get_bits(gbp, 3);
457         if (coeff_bits < 1 || coeff_bits > 16) {
458             av_log(m->avctx, AV_LOG_ERROR,
459                    "%cIR filter coeff_bits must be between 1 and 16.\n",
460                    fchar);
461             return -1;
462         }
463         if (coeff_bits + coeff_shift > 16) {
464             av_log(m->avctx, AV_LOG_ERROR,
465                    "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
466                    fchar);
467             return -1;
468         }
469
470         for (i = 0; i < order; i++)
471             fp->coeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
472
473         if (get_bits1(gbp)) {
474             int state_bits, state_shift;
475
476             if (filter == FIR) {
477                 av_log(m->avctx, AV_LOG_ERROR,
478                        "FIR filter has state data specified.\n");
479                 return -1;
480             }
481
482             state_bits  = get_bits(gbp, 4);
483             state_shift = get_bits(gbp, 4);
484
485             /* TODO: Check validity of state data. */
486
487             for (i = 0; i < order; i++)
488                 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
489         }
490     }
491
492     return 0;
493 }
494
495 /** Read decoding parameters that change more often than those in the restart
496  *  header. */
497
498 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
499                                 unsigned int substr)
500 {
501     SubStream *s = &m->substream[substr];
502     unsigned int mat, ch;
503
504     if (get_bits1(gbp))
505         s->param_presence_flags = get_bits(gbp, 8);
506
507     if (s->param_presence_flags & PARAM_BLOCKSIZE)
508         if (get_bits1(gbp)) {
509             s->blocksize = get_bits(gbp, 9);
510             if (s->blocksize > MAX_BLOCKSIZE) {
511                 av_log(m->avctx, AV_LOG_ERROR, "block size too large\n");
512                 s->blocksize = 0;
513                 return -1;
514             }
515         }
516
517     if (s->param_presence_flags & PARAM_MATRIX)
518         if (get_bits1(gbp)) {
519             s->num_primitive_matrices = get_bits(gbp, 4);
520
521             for (mat = 0; mat < s->num_primitive_matrices; mat++) {
522                 int frac_bits, max_chan;
523                 s->matrix_out_ch[mat] = get_bits(gbp, 4);
524                 frac_bits             = get_bits(gbp, 4);
525                 s->lsb_bypass   [mat] = get_bits1(gbp);
526
527                 if (s->matrix_out_ch[mat] > s->max_channel) {
528                     av_log(m->avctx, AV_LOG_ERROR,
529                            "Invalid channel %d specified as output from matrix.\n",
530                            s->matrix_out_ch[mat]);
531                     return -1;
532                 }
533                 if (frac_bits > 14) {
534                     av_log(m->avctx, AV_LOG_ERROR,
535                            "Too many fractional bits specified.\n");
536                     return -1;
537                 }
538
539                 max_chan = s->max_matrix_channel;
540                 if (!s->noise_type)
541                     max_chan+=2;
542
543                 for (ch = 0; ch <= max_chan; ch++) {
544                     int coeff_val = 0;
545                     if (get_bits1(gbp))
546                         coeff_val = get_sbits(gbp, frac_bits + 2);
547
548                     s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
549                 }
550
551                 if (s->noise_type)
552                     s->matrix_noise_shift[mat] = get_bits(gbp, 4);
553                 else
554                     s->matrix_noise_shift[mat] = 0;
555             }
556         }
557
558     if (s->param_presence_flags & PARAM_OUTSHIFT)
559         if (get_bits1(gbp))
560             for (ch = 0; ch <= s->max_matrix_channel; ch++) {
561                 s->output_shift[ch] = get_bits(gbp, 4);
562                 dprintf(m->avctx, "output shift[%d] = %d\n",
563                         ch, s->output_shift[ch]);
564                 /* TODO: validate */
565             }
566
567     if (s->param_presence_flags & PARAM_QUANTSTEP)
568         if (get_bits1(gbp))
569             for (ch = 0; ch <= s->max_channel; ch++) {
570                 ChannelParams *cp = &m->channel_params[ch];
571
572                 s->quant_step_size[ch] = get_bits(gbp, 4);
573                 /* TODO: validate */
574
575                 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
576             }
577
578     for (ch = s->min_channel; ch <= s->max_channel; ch++)
579         if (get_bits1(gbp)) {
580             ChannelParams *cp = &m->channel_params[ch];
581             FilterParams *fir = &cp->filter_params[FIR];
582             FilterParams *iir = &cp->filter_params[IIR];
583
584             if (s->param_presence_flags & PARAM_FIR)
585                 if (get_bits1(gbp))
586                     if (read_filter_params(m, gbp, ch, FIR) < 0)
587                         return -1;
588
589             if (s->param_presence_flags & PARAM_IIR)
590                 if (get_bits1(gbp))
591                     if (read_filter_params(m, gbp, ch, IIR) < 0)
592                         return -1;
593
594             if (fir->order && iir->order &&
595                 fir->shift != iir->shift) {
596                 av_log(m->avctx, AV_LOG_ERROR,
597                        "FIR and IIR filters must use the same precision.\n");
598                 return -1;
599             }
600             /* The FIR and IIR filters must have the same precision.
601              * To simplify the filtering code, only the precision of the
602              * FIR filter is considered. If only the IIR filter is employed,
603              * the FIR filter precision is set to that of the IIR filter, so
604              * that the filtering code can use it. */
605             if (!fir->order && iir->order)
606                 fir->shift = iir->shift;
607
608             if (s->param_presence_flags & PARAM_HUFFOFFSET)
609                 if (get_bits1(gbp))
610                     cp->huff_offset = get_sbits(gbp, 15);
611
612             cp->codebook  = get_bits(gbp, 2);
613             cp->huff_lsbs = get_bits(gbp, 5);
614
615             cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
616
617             /* TODO: validate */
618         }
619
620     return 0;
621 }
622
623 #define MSB_MASK(bits)  (-1u << bits)
624
625 /** Generate PCM samples using the prediction filters and residual values
626  *  read from the data stream, and update the filter state. */
627
628 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
629                            unsigned int channel)
630 {
631     SubStream *s = &m->substream[substr];
632     int32_t filter_state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FILTER_ORDER];
633     FilterParams *fp[NUM_FILTERS] = { &m->channel_params[channel].filter_params[FIR],
634                                       &m->channel_params[channel].filter_params[IIR], };
635     unsigned int filter_shift = fp[FIR]->shift;
636     int32_t mask = MSB_MASK(s->quant_step_size[channel]);
637     int index = MAX_BLOCKSIZE;
638     int j, i;
639
640     for (j = 0; j < NUM_FILTERS; j++) {
641         memcpy(&filter_state_buffer[j][MAX_BLOCKSIZE], &fp[j]->state[0],
642                MAX_FILTER_ORDER * sizeof(int32_t));
643     }
644
645     for (i = 0; i < s->blocksize; i++) {
646         int32_t residual = m->sample_buffer[i + s->blockpos][channel];
647         unsigned int order;
648         int64_t accum = 0;
649         int32_t result;
650
651         /* TODO: Move this code to DSPContext? */
652
653         for (j = 0; j < NUM_FILTERS; j++)
654             for (order = 0; order < fp[j]->order; order++)
655                 accum += (int64_t)filter_state_buffer[j][index + order] *
656                                   fp[j]->coeff[order];
657
658         accum  = accum >> filter_shift;
659         result = (accum + residual) & mask;
660
661         --index;
662
663         filter_state_buffer[FIR][index] = result;
664         filter_state_buffer[IIR][index] = result - accum;
665
666         m->sample_buffer[i + s->blockpos][channel] = result;
667     }
668
669     for (j = 0; j < NUM_FILTERS; j++) {
670         memcpy(&fp[j]->state[0], &filter_state_buffer[j][index],
671                MAX_FILTER_ORDER * sizeof(int32_t));
672     }
673 }
674
675 /** Read a block of PCM residual data (or actual if no filtering active). */
676
677 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
678                            unsigned int substr)
679 {
680     SubStream *s = &m->substream[substr];
681     unsigned int i, ch, expected_stream_pos = 0;
682
683     if (s->data_check_present) {
684         expected_stream_pos  = get_bits_count(gbp);
685         expected_stream_pos += get_bits(gbp, 16);
686         av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
687                "we have not tested yet. %s\n", sample_message);
688     }
689
690     if (s->blockpos + s->blocksize > m->access_unit_size) {
691         av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
692         return -1;
693     }
694
695     memset(&m->bypassed_lsbs[s->blockpos][0], 0,
696            s->blocksize * sizeof(m->bypassed_lsbs[0]));
697
698     for (i = 0; i < s->blocksize; i++) {
699         if (read_huff_channels(m, gbp, substr, i) < 0)
700             return -1;
701     }
702
703     for (ch = s->min_channel; ch <= s->max_channel; ch++) {
704         filter_channel(m, substr, ch);
705     }
706
707     s->blockpos += s->blocksize;
708
709     if (s->data_check_present) {
710         if (get_bits_count(gbp) != expected_stream_pos)
711             av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
712         skip_bits(gbp, 8);
713     }
714
715     return 0;
716 }
717
718 /** Data table used for TrueHD noise generation function. */
719
720 static const int8_t noise_table[256] = {
721      30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
722      52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
723      10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
724      51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
725      38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
726      61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
727      67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
728      48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
729       0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
730      16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
731      13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
732      89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
733      36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
734      39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
735      45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
736     -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
737 };
738
739 /** Noise generation functions.
740  *  I'm not sure what these are for - they seem to be some kind of pseudorandom
741  *  sequence generators, used to generate noise data which is used when the
742  *  channels are rematrixed. I'm not sure if they provide a practical benefit
743  *  to compression, or just obfuscate the decoder. Are they for some kind of
744  *  dithering? */
745
746 /** Generate two channels of noise, used in the matrix when
747  *  restart sync word == 0x31ea. */
748
749 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
750 {
751     SubStream *s = &m->substream[substr];
752     unsigned int i;
753     uint32_t seed = s->noisegen_seed;
754     unsigned int maxchan = s->max_matrix_channel;
755
756     for (i = 0; i < s->blockpos; i++) {
757         uint16_t seed_shr7 = seed >> 7;
758         m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
759         m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
760
761         seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
762     }
763
764     s->noisegen_seed = seed;
765 }
766
767 /** Generate a block of noise, used when restart sync word == 0x31eb. */
768
769 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
770 {
771     SubStream *s = &m->substream[substr];
772     unsigned int i;
773     uint32_t seed = s->noisegen_seed;
774
775     for (i = 0; i < m->access_unit_size_pow2; i++) {
776         uint8_t seed_shr15 = seed >> 15;
777         m->noise_buffer[i] = noise_table[seed_shr15];
778         seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
779     }
780
781     s->noisegen_seed = seed;
782 }
783
784
785 /** Apply the channel matrices in turn to reconstruct the original audio
786  *  samples. */
787
788 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
789 {
790     SubStream *s = &m->substream[substr];
791     unsigned int mat, src_ch, i;
792     unsigned int maxchan;
793
794     maxchan = s->max_matrix_channel;
795     if (!s->noise_type) {
796         generate_2_noise_channels(m, substr);
797         maxchan += 2;
798     } else {
799         fill_noise_buffer(m, substr);
800     }
801
802     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
803         int matrix_noise_shift = s->matrix_noise_shift[mat];
804         unsigned int dest_ch = s->matrix_out_ch[mat];
805         int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
806
807         /* TODO: DSPContext? */
808
809         for (i = 0; i < s->blockpos; i++) {
810             int64_t accum = 0;
811             for (src_ch = 0; src_ch <= maxchan; src_ch++) {
812                 accum += (int64_t)m->sample_buffer[i][src_ch]
813                                   * s->matrix_coeff[mat][src_ch];
814             }
815             if (matrix_noise_shift) {
816                 uint32_t index = s->num_primitive_matrices - mat;
817                 index = (i * (index * 2 + 1) + index) & (m->access_unit_size_pow2 - 1);
818                 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
819             }
820             m->sample_buffer[i][dest_ch] = ((accum >> 14) & mask)
821                                              + m->bypassed_lsbs[i][mat];
822         }
823     }
824 }
825
826 /** Write the audio data into the output buffer. */
827
828 static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
829                                 uint8_t *data, unsigned int *data_size, int is32)
830 {
831     SubStream *s = &m->substream[substr];
832     unsigned int i, ch = 0;
833     int32_t *data_32 = (int32_t*) data;
834     int16_t *data_16 = (int16_t*) data;
835
836     if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
837         return -1;
838
839     for (i = 0; i < s->blockpos; i++) {
840         for (ch = 0; ch <= s->max_channel; ch++) {
841             int32_t sample = m->sample_buffer[i][ch] << s->output_shift[ch];
842             s->lossless_check_data ^= (sample & 0xffffff) << ch;
843             if (is32) *data_32++ = sample << 8;
844             else      *data_16++ = sample >> 8;
845         }
846     }
847
848     *data_size = i * ch * (is32 ? 4 : 2);
849
850     return 0;
851 }
852
853 static int output_data(MLPDecodeContext *m, unsigned int substr,
854                        uint8_t *data, unsigned int *data_size)
855 {
856     if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
857         return output_data_internal(m, substr, data, data_size, 1);
858     else
859         return output_data_internal(m, substr, data, data_size, 0);
860 }
861
862
863 /** Read an access unit from the stream.
864  *  Returns < 0 on error, 0 if not enough data is present in the input stream
865  *  otherwise returns the number of bytes consumed. */
866
867 static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
868                             const uint8_t *buf, int buf_size)
869 {
870     MLPDecodeContext *m = avctx->priv_data;
871     GetBitContext gb;
872     unsigned int length, substr;
873     unsigned int substream_start;
874     unsigned int header_size = 4;
875     unsigned int substr_header_size = 0;
876     uint8_t substream_parity_present[MAX_SUBSTREAMS];
877     uint16_t substream_data_len[MAX_SUBSTREAMS];
878     uint8_t parity_bits;
879
880     if (buf_size < 4)
881         return 0;
882
883     length = (AV_RB16(buf) & 0xfff) * 2;
884
885     if (length > buf_size)
886         return -1;
887
888     init_get_bits(&gb, (buf + 4), (length - 4) * 8);
889
890     if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
891         dprintf(m->avctx, "Found major sync.\n");
892         if (read_major_sync(m, &gb) < 0)
893             goto error;
894         header_size += 28;
895     }
896
897     if (!m->params_valid) {
898         av_log(m->avctx, AV_LOG_WARNING,
899                "Stream parameters not seen; skipping frame.\n");
900         *data_size = 0;
901         return length;
902     }
903
904     substream_start = 0;
905
906     for (substr = 0; substr < m->num_substreams; substr++) {
907         int extraword_present, checkdata_present, end;
908
909         extraword_present = get_bits1(&gb);
910         skip_bits1(&gb);
911         checkdata_present = get_bits1(&gb);
912         skip_bits1(&gb);
913
914         end = get_bits(&gb, 12) * 2;
915
916         substr_header_size += 2;
917
918         if (extraword_present) {
919             skip_bits(&gb, 16);
920             substr_header_size += 2;
921         }
922
923         if (end + header_size + substr_header_size > length) {
924             av_log(m->avctx, AV_LOG_ERROR,
925                    "Indicated length of substream %d data goes off end of "
926                    "packet.\n", substr);
927             end = length - header_size - substr_header_size;
928         }
929
930         if (end < substream_start) {
931             av_log(avctx, AV_LOG_ERROR,
932                    "Indicated end offset of substream %d data "
933                    "is smaller than calculated start offset.\n",
934                    substr);
935             goto error;
936         }
937
938         if (substr > m->max_decoded_substream)
939             continue;
940
941         substream_parity_present[substr] = checkdata_present;
942         substream_data_len[substr] = end - substream_start;
943         substream_start = end;
944     }
945
946     parity_bits  = ff_mlp_calculate_parity(buf, 4);
947     parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
948
949     if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
950         av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
951         goto error;
952     }
953
954     buf += header_size + substr_header_size;
955
956     for (substr = 0; substr <= m->max_decoded_substream; substr++) {
957         SubStream *s = &m->substream[substr];
958         init_get_bits(&gb, buf, substream_data_len[substr] * 8);
959
960         s->blockpos = 0;
961         do {
962             if (get_bits1(&gb)) {
963                 if (get_bits1(&gb)) {
964                     /* A restart header should be present. */
965                     if (read_restart_header(m, &gb, buf, substr) < 0)
966                         goto next_substr;
967                     s->restart_seen = 1;
968                 }
969
970                 if (!s->restart_seen) {
971                     av_log(m->avctx, AV_LOG_ERROR,
972                            "No restart header present in substream %d.\n",
973                            substr);
974                     goto next_substr;
975                 }
976
977                 if (read_decoding_params(m, &gb, substr) < 0)
978                     goto next_substr;
979             }
980
981             if (!s->restart_seen) {
982                 av_log(m->avctx, AV_LOG_ERROR,
983                        "No restart header present in substream %d.\n",
984                        substr);
985                 goto next_substr;
986             }
987
988             if (read_block_data(m, &gb, substr) < 0)
989                 return -1;
990
991         } while ((get_bits_count(&gb) < substream_data_len[substr] * 8)
992                  && get_bits1(&gb) == 0);
993
994         skip_bits(&gb, (-get_bits_count(&gb)) & 15);
995         if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32 &&
996             (show_bits_long(&gb, 32) == 0xd234d234 ||
997              show_bits_long(&gb, 20) == 0xd234e)) {
998             skip_bits(&gb, 18);
999             if (substr == m->max_decoded_substream)
1000                 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1001
1002             if (get_bits1(&gb)) {
1003                 int shorten_by = get_bits(&gb, 13);
1004                 shorten_by = FFMIN(shorten_by, s->blockpos);
1005                 s->blockpos -= shorten_by;
1006             } else
1007                 skip_bits(&gb, 13);
1008         }
1009         if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 16 &&
1010             substream_parity_present[substr]) {
1011             uint8_t parity, checksum;
1012
1013             parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1014             if ((parity ^ get_bits(&gb, 8)) != 0xa9)
1015                 av_log(m->avctx, AV_LOG_ERROR,
1016                        "Substream %d parity check failed.\n", substr);
1017
1018             checksum = ff_mlp_checksum8(buf, substream_data_len[substr] - 2);
1019             if (checksum != get_bits(&gb, 8))
1020                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n",
1021                        substr);
1022         }
1023         if (substream_data_len[substr] * 8 != get_bits_count(&gb)) {
1024             av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n",
1025                    substr);
1026             return -1;
1027         }
1028
1029 next_substr:
1030         buf += substream_data_len[substr];
1031     }
1032
1033     rematrix_channels(m, m->max_decoded_substream);
1034
1035     if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1036         return -1;
1037
1038     return length;
1039
1040 error:
1041     m->params_valid = 0;
1042     return -1;
1043 }
1044
1045 AVCodec mlp_decoder = {
1046     "mlp",
1047     CODEC_TYPE_AUDIO,
1048     CODEC_ID_MLP,
1049     sizeof(MLPDecodeContext),
1050     mlp_decode_init,
1051     NULL,
1052     NULL,
1053     read_access_unit,
1054     .long_name = NULL_IF_CONFIG_SMALL("Meridian Lossless Packing"),
1055 };
1056