3 * Copyright (c) 2007-2008 Ian Caulfield
5 * This file is part of FFmpeg.
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.
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.
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
23 * @file libavcodec/mlpdec.c
31 #include "libavutil/intreadwrite.h"
33 #include "libavutil/crc.h"
35 #include "mlp_parser.h"
38 /** number of bits used for VLC lookup - longest Huffman code is 9 */
42 static const char* sample_message =
43 "Please file a bug report following the instructions at "
44 "http://ffmpeg.org/bugreports.html and include "
45 "a sample of this file.";
47 typedef struct SubStream {
48 //! Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
52 /** restart header data */
53 //! The type of noise to be used in the rematrix stage.
56 //! The index of the first channel coded in this substream.
58 //! The index of the last channel coded in this substream.
60 //! The number of channels input into the rematrix stage.
61 uint8_t max_matrix_channel;
62 //! For each channel output by the matrix, the output channel to map it to
63 uint8_t ch_assign[MAX_CHANNELS];
65 //! The left shift applied to random noise in 0x31ea substreams.
67 //! The current seed value for the pseudorandom noise generator(s).
68 uint32_t noisegen_seed;
70 //! Set if the substream contains extra info to check the size of VLC blocks.
71 uint8_t data_check_present;
73 //! Bitmask of which parameter sets are conveyed in a decoding parameter block.
74 uint8_t param_presence_flags;
75 #define PARAM_BLOCKSIZE (1 << 7)
76 #define PARAM_MATRIX (1 << 6)
77 #define PARAM_OUTSHIFT (1 << 5)
78 #define PARAM_QUANTSTEP (1 << 4)
79 #define PARAM_FIR (1 << 3)
80 #define PARAM_IIR (1 << 2)
81 #define PARAM_HUFFOFFSET (1 << 1)
82 #define PARAM_PRESENCE (1 << 0)
88 //! Number of matrices to be applied.
89 uint8_t num_primitive_matrices;
91 //! matrix output channel
92 uint8_t matrix_out_ch[MAX_MATRICES];
94 //! Whether the LSBs of the matrix output are encoded in the bitstream.
95 uint8_t lsb_bypass[MAX_MATRICES];
96 //! Matrix coefficients, stored as 2.14 fixed point.
97 int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
98 //! Left shift to apply to noise values in 0x31eb substreams.
99 uint8_t matrix_noise_shift[MAX_MATRICES];
102 //! Left shift to apply to Huffman-decoded residuals.
103 uint8_t quant_step_size[MAX_CHANNELS];
105 //! number of PCM samples in current audio block
107 //! Number of PCM samples decoded so far in this frame.
110 //! Left shift to apply to decoded PCM values to get final 24-bit output.
111 int8_t output_shift[MAX_CHANNELS];
113 //! Running XOR of all output samples.
114 int32_t lossless_check_data;
118 typedef struct MLPDecodeContext {
119 AVCodecContext *avctx;
121 //! Current access unit being read has a major sync.
122 int is_major_sync_unit;
124 //! Set if a valid major sync block has been read. Otherwise no decoding is possible.
125 uint8_t params_valid;
127 //! Number of substreams contained within this stream.
128 uint8_t num_substreams;
130 //! Index of the last substream to decode - further substreams are skipped.
131 uint8_t max_decoded_substream;
133 //! number of PCM samples contained in each frame
134 int access_unit_size;
135 //! next power of two above the number of samples in each frame
136 int access_unit_size_pow2;
138 SubStream substream[MAX_SUBSTREAMS];
140 ChannelParams channel_params[MAX_CHANNELS];
143 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
145 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
146 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
147 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
152 static VLC huff_vlc[3];
154 /** Initialize static data, constant between all invocations of the codec. */
156 static av_cold void init_static(void)
158 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
159 &ff_mlp_huffman_tables[0][0][1], 2, 1,
160 &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
161 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
162 &ff_mlp_huffman_tables[1][0][1], 2, 1,
163 &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
164 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
165 &ff_mlp_huffman_tables[2][0][1], 2, 1,
166 &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
171 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
172 unsigned int substr, unsigned int ch)
174 ChannelParams *cp = &m->channel_params[ch];
175 SubStream *s = &m->substream[substr];
176 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
177 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
178 int32_t sign_huff_offset = cp->huff_offset;
180 if (cp->codebook > 0)
181 sign_huff_offset -= 7 << lsb_bits;
184 sign_huff_offset -= 1 << sign_shift;
186 return sign_huff_offset;
189 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
192 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
193 unsigned int substr, unsigned int pos)
195 SubStream *s = &m->substream[substr];
196 unsigned int mat, channel;
198 for (mat = 0; mat < s->num_primitive_matrices; mat++)
199 if (s->lsb_bypass[mat])
200 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
202 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
203 ChannelParams *cp = &m->channel_params[channel];
204 int codebook = cp->codebook;
205 int quant_step_size = s->quant_step_size[channel];
206 int lsb_bits = cp->huff_lsbs - quant_step_size;
210 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
211 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
217 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
219 result += cp->sign_huff_offset;
220 result <<= quant_step_size;
222 m->sample_buffer[pos + s->blockpos][channel] = result;
228 static av_cold int mlp_decode_init(AVCodecContext *avctx)
230 MLPDecodeContext *m = avctx->priv_data;
235 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
236 m->substream[substr].lossless_check_data = 0xffffffff;
237 dsputil_init(&m->dsp, avctx);
242 /** Read a major sync info header - contains high level information about
243 * the stream - sample rate, channel arrangement etc. Most of this
244 * information is not actually necessary for decoding, only for playback.
247 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
252 if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
255 if (mh.group1_bits == 0) {
256 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
259 if (mh.group2_bits > mh.group1_bits) {
260 av_log(m->avctx, AV_LOG_ERROR,
261 "Channel group 2 cannot have more bits per sample than group 1.\n");
265 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
266 av_log(m->avctx, AV_LOG_ERROR,
267 "Channel groups with differing sample rates are not currently supported.\n");
271 if (mh.group1_samplerate == 0) {
272 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
275 if (mh.group1_samplerate > MAX_SAMPLERATE) {
276 av_log(m->avctx, AV_LOG_ERROR,
277 "Sampling rate %d is greater than the supported maximum (%d).\n",
278 mh.group1_samplerate, MAX_SAMPLERATE);
281 if (mh.access_unit_size > MAX_BLOCKSIZE) {
282 av_log(m->avctx, AV_LOG_ERROR,
283 "Block size %d is greater than the supported maximum (%d).\n",
284 mh.access_unit_size, MAX_BLOCKSIZE);
287 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
288 av_log(m->avctx, AV_LOG_ERROR,
289 "Block size pow2 %d is greater than the supported maximum (%d).\n",
290 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
294 if (mh.num_substreams == 0)
296 if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
297 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
300 if (mh.num_substreams > MAX_SUBSTREAMS) {
301 av_log(m->avctx, AV_LOG_ERROR,
302 "Number of substreams %d is larger than the maximum supported "
303 "by the decoder. %s\n", mh.num_substreams, sample_message);
307 m->access_unit_size = mh.access_unit_size;
308 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
310 m->num_substreams = mh.num_substreams;
311 m->max_decoded_substream = m->num_substreams - 1;
313 m->avctx->sample_rate = mh.group1_samplerate;
314 m->avctx->frame_size = mh.access_unit_size;
316 m->avctx->bits_per_raw_sample = mh.group1_bits;
317 if (mh.group1_bits > 16)
318 m->avctx->sample_fmt = SAMPLE_FMT_S32;
320 m->avctx->sample_fmt = SAMPLE_FMT_S16;
323 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
324 m->substream[substr].restart_seen = 0;
329 /** Read a restart header from a block in a substream. This contains parameters
330 * required to decode the audio that do not change very often. Generally
331 * (always) present only in blocks following a major sync. */
333 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
334 const uint8_t *buf, unsigned int substr)
336 SubStream *s = &m->substream[substr];
340 uint8_t lossless_check;
341 int start_count = get_bits_count(gbp);
342 const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP
343 ? MAX_MATRIX_CHANNEL_MLP
344 : MAX_MATRIX_CHANNEL_TRUEHD;
346 sync_word = get_bits(gbp, 13);
348 if (sync_word != 0x31ea >> 1) {
349 av_log(m->avctx, AV_LOG_ERROR,
350 "restart header sync incorrect (got 0x%04x)\n", sync_word);
354 s->noise_type = get_bits1(gbp);
356 if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) {
357 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
361 skip_bits(gbp, 16); /* Output timestamp */
363 s->min_channel = get_bits(gbp, 4);
364 s->max_channel = get_bits(gbp, 4);
365 s->max_matrix_channel = get_bits(gbp, 4);
367 if (s->max_matrix_channel > max_matrix_channel) {
368 av_log(m->avctx, AV_LOG_ERROR,
369 "Max matrix channel cannot be greater than %d.\n",
374 if (s->max_channel != s->max_matrix_channel) {
375 av_log(m->avctx, AV_LOG_ERROR,
376 "Max channel must be equal max matrix channel.\n");
380 if (s->min_channel > s->max_channel) {
381 av_log(m->avctx, AV_LOG_ERROR,
382 "Substream min channel cannot be greater than max channel.\n");
386 if (m->avctx->request_channels > 0
387 && s->max_channel + 1 >= m->avctx->request_channels
388 && substr < m->max_decoded_substream) {
389 av_log(m->avctx, AV_LOG_INFO,
390 "Extracting %d channel downmix from substream %d. "
391 "Further substreams will be skipped.\n",
392 s->max_channel + 1, substr);
393 m->max_decoded_substream = substr;
396 s->noise_shift = get_bits(gbp, 4);
397 s->noisegen_seed = get_bits(gbp, 23);
401 s->data_check_present = get_bits1(gbp);
402 lossless_check = get_bits(gbp, 8);
403 if (substr == m->max_decoded_substream
404 && s->lossless_check_data != 0xffffffff) {
405 tmp = xor_32_to_8(s->lossless_check_data);
406 if (tmp != lossless_check)
407 av_log(m->avctx, AV_LOG_WARNING,
408 "Lossless check failed - expected %02x, calculated %02x.\n",
409 lossless_check, tmp);
414 memset(s->ch_assign, 0, sizeof(s->ch_assign));
416 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
417 int ch_assign = get_bits(gbp, 6);
418 if (ch_assign > s->max_matrix_channel) {
419 av_log(m->avctx, AV_LOG_ERROR,
420 "Assignment of matrix channel %d to invalid output channel %d. %s\n",
421 ch, ch_assign, sample_message);
424 s->ch_assign[ch_assign] = ch;
427 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
429 if (checksum != get_bits(gbp, 8))
430 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
432 /* Set default decoding parameters. */
433 s->param_presence_flags = 0xff;
434 s->num_primitive_matrices = 0;
436 s->lossless_check_data = 0;
438 memset(s->output_shift , 0, sizeof(s->output_shift ));
439 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
441 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
442 ChannelParams *cp = &m->channel_params[ch];
443 cp->filter_params[FIR].order = 0;
444 cp->filter_params[IIR].order = 0;
445 cp->filter_params[FIR].shift = 0;
446 cp->filter_params[IIR].shift = 0;
448 /* Default audio coding is 24-bit raw PCM. */
450 cp->sign_huff_offset = (-1) << 23;
455 if (substr == m->max_decoded_substream)
456 m->avctx->channels = s->max_matrix_channel + 1;
461 /** Read parameters for one of the prediction filters. */
463 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
464 unsigned int channel, unsigned int filter)
466 FilterParams *fp = &m->channel_params[channel].filter_params[filter];
467 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
468 const char fchar = filter ? 'I' : 'F';
471 // Filter is 0 for FIR, 1 for IIR.
474 if (m->filter_changed[channel][filter]++ > 1) {
475 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
479 order = get_bits(gbp, 4);
480 if (order > max_order) {
481 av_log(m->avctx, AV_LOG_ERROR,
482 "%cIR filter order %d is greater than maximum %d.\n",
483 fchar, order, max_order);
489 int coeff_bits, coeff_shift;
491 fp->shift = get_bits(gbp, 4);
493 coeff_bits = get_bits(gbp, 5);
494 coeff_shift = get_bits(gbp, 3);
495 if (coeff_bits < 1 || coeff_bits > 16) {
496 av_log(m->avctx, AV_LOG_ERROR,
497 "%cIR filter coeff_bits must be between 1 and 16.\n",
501 if (coeff_bits + coeff_shift > 16) {
502 av_log(m->avctx, AV_LOG_ERROR,
503 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
508 for (i = 0; i < order; i++)
509 fp->coeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
511 if (get_bits1(gbp)) {
512 int state_bits, state_shift;
515 av_log(m->avctx, AV_LOG_ERROR,
516 "FIR filter has state data specified.\n");
520 state_bits = get_bits(gbp, 4);
521 state_shift = get_bits(gbp, 4);
523 /* TODO: Check validity of state data. */
525 for (i = 0; i < order; i++)
526 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
533 /** Read parameters for primitive matrices. */
535 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
537 SubStream *s = &m->substream[substr];
538 unsigned int mat, ch;
539 const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
541 : MAX_MATRICES_TRUEHD;
543 if (m->matrix_changed++ > 1) {
544 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
548 s->num_primitive_matrices = get_bits(gbp, 4);
550 if (s->num_primitive_matrices > max_primitive_matrices) {
551 av_log(m->avctx, AV_LOG_ERROR,
552 "Number of primitive matrices cannot be greater than %d.\n",
553 max_primitive_matrices);
557 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
558 int frac_bits, max_chan;
559 s->matrix_out_ch[mat] = get_bits(gbp, 4);
560 frac_bits = get_bits(gbp, 4);
561 s->lsb_bypass [mat] = get_bits1(gbp);
563 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
564 av_log(m->avctx, AV_LOG_ERROR,
565 "Invalid channel %d specified as output from matrix.\n",
566 s->matrix_out_ch[mat]);
569 if (frac_bits > 14) {
570 av_log(m->avctx, AV_LOG_ERROR,
571 "Too many fractional bits specified.\n");
575 max_chan = s->max_matrix_channel;
579 for (ch = 0; ch <= max_chan; ch++) {
582 coeff_val = get_sbits(gbp, frac_bits + 2);
584 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
588 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
590 s->matrix_noise_shift[mat] = 0;
596 /** Read channel parameters. */
598 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
599 GetBitContext *gbp, unsigned int ch)
601 ChannelParams *cp = &m->channel_params[ch];
602 FilterParams *fir = &cp->filter_params[FIR];
603 FilterParams *iir = &cp->filter_params[IIR];
604 SubStream *s = &m->substream[substr];
606 if (s->param_presence_flags & PARAM_FIR)
608 if (read_filter_params(m, gbp, ch, FIR) < 0)
611 if (s->param_presence_flags & PARAM_IIR)
613 if (read_filter_params(m, gbp, ch, IIR) < 0)
616 if (fir->order + iir->order > 8) {
617 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
621 if (fir->order && iir->order &&
622 fir->shift != iir->shift) {
623 av_log(m->avctx, AV_LOG_ERROR,
624 "FIR and IIR filters must use the same precision.\n");
627 /* The FIR and IIR filters must have the same precision.
628 * To simplify the filtering code, only the precision of the
629 * FIR filter is considered. If only the IIR filter is employed,
630 * the FIR filter precision is set to that of the IIR filter, so
631 * that the filtering code can use it. */
632 if (!fir->order && iir->order)
633 fir->shift = iir->shift;
635 if (s->param_presence_flags & PARAM_HUFFOFFSET)
637 cp->huff_offset = get_sbits(gbp, 15);
639 cp->codebook = get_bits(gbp, 2);
640 cp->huff_lsbs = get_bits(gbp, 5);
642 if (cp->huff_lsbs > 24) {
643 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
647 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
652 /** Read decoding parameters that change more often than those in the restart
655 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
658 SubStream *s = &m->substream[substr];
661 if (s->param_presence_flags & PARAM_PRESENCE)
663 s->param_presence_flags = get_bits(gbp, 8);
665 if (s->param_presence_flags & PARAM_BLOCKSIZE)
666 if (get_bits1(gbp)) {
667 s->blocksize = get_bits(gbp, 9);
668 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
669 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
675 if (s->param_presence_flags & PARAM_MATRIX)
677 if (read_matrix_params(m, substr, gbp) < 0)
680 if (s->param_presence_flags & PARAM_OUTSHIFT)
682 for (ch = 0; ch <= s->max_matrix_channel; ch++)
683 s->output_shift[ch] = get_sbits(gbp, 4);
685 if (s->param_presence_flags & PARAM_QUANTSTEP)
687 for (ch = 0; ch <= s->max_channel; ch++) {
688 ChannelParams *cp = &m->channel_params[ch];
690 s->quant_step_size[ch] = get_bits(gbp, 4);
692 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
695 for (ch = s->min_channel; ch <= s->max_channel; ch++)
697 if (read_channel_params(m, substr, gbp, ch) < 0)
703 #define MSB_MASK(bits) (-1u << bits)
705 /** Generate PCM samples using the prediction filters and residual values
706 * read from the data stream, and update the filter state. */
708 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
709 unsigned int channel)
711 SubStream *s = &m->substream[substr];
712 int32_t fir_state_buffer[MAX_BLOCKSIZE + MAX_FIR_ORDER];
713 int32_t iir_state_buffer[MAX_BLOCKSIZE + MAX_IIR_ORDER];
714 int32_t *firbuf = fir_state_buffer + MAX_BLOCKSIZE;
715 int32_t *iirbuf = iir_state_buffer + MAX_BLOCKSIZE;
716 FilterParams *fir = &m->channel_params[channel].filter_params[FIR];
717 FilterParams *iir = &m->channel_params[channel].filter_params[IIR];
718 unsigned int filter_shift = fir->shift;
719 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
721 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
722 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
724 m->dsp.mlp_filter_channel(firbuf, fir->coeff, fir->order,
725 iirbuf, iir->coeff, iir->order,
726 filter_shift, mask, s->blocksize,
727 &m->sample_buffer[s->blockpos][channel]);
729 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
730 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
733 /** Read a block of PCM residual data (or actual if no filtering active). */
735 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
738 SubStream *s = &m->substream[substr];
739 unsigned int i, ch, expected_stream_pos = 0;
741 if (s->data_check_present) {
742 expected_stream_pos = get_bits_count(gbp);
743 expected_stream_pos += get_bits(gbp, 16);
744 av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
745 "we have not tested yet. %s\n", sample_message);
748 if (s->blockpos + s->blocksize > m->access_unit_size) {
749 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
753 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
754 s->blocksize * sizeof(m->bypassed_lsbs[0]));
756 for (i = 0; i < s->blocksize; i++)
757 if (read_huff_channels(m, gbp, substr, i) < 0)
760 for (ch = s->min_channel; ch <= s->max_channel; ch++)
761 filter_channel(m, substr, ch);
763 s->blockpos += s->blocksize;
765 if (s->data_check_present) {
766 if (get_bits_count(gbp) != expected_stream_pos)
767 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
774 /** Data table used for TrueHD noise generation function. */
776 static const int8_t noise_table[256] = {
777 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
778 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
779 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
780 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
781 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
782 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
783 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
784 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
785 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
786 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
787 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
788 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
789 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
790 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
791 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
792 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
795 /** Noise generation functions.
796 * I'm not sure what these are for - they seem to be some kind of pseudorandom
797 * sequence generators, used to generate noise data which is used when the
798 * channels are rematrixed. I'm not sure if they provide a practical benefit
799 * to compression, or just obfuscate the decoder. Are they for some kind of
802 /** Generate two channels of noise, used in the matrix when
803 * restart sync word == 0x31ea. */
805 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
807 SubStream *s = &m->substream[substr];
809 uint32_t seed = s->noisegen_seed;
810 unsigned int maxchan = s->max_matrix_channel;
812 for (i = 0; i < s->blockpos; i++) {
813 uint16_t seed_shr7 = seed >> 7;
814 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
815 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
817 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
820 s->noisegen_seed = seed;
823 /** Generate a block of noise, used when restart sync word == 0x31eb. */
825 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
827 SubStream *s = &m->substream[substr];
829 uint32_t seed = s->noisegen_seed;
831 for (i = 0; i < m->access_unit_size_pow2; i++) {
832 uint8_t seed_shr15 = seed >> 15;
833 m->noise_buffer[i] = noise_table[seed_shr15];
834 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
837 s->noisegen_seed = seed;
841 /** Apply the channel matrices in turn to reconstruct the original audio
844 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
846 SubStream *s = &m->substream[substr];
847 unsigned int mat, src_ch, i;
848 unsigned int maxchan;
850 maxchan = s->max_matrix_channel;
851 if (!s->noise_type) {
852 generate_2_noise_channels(m, substr);
855 fill_noise_buffer(m, substr);
858 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
859 int matrix_noise_shift = s->matrix_noise_shift[mat];
860 unsigned int dest_ch = s->matrix_out_ch[mat];
861 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
862 int32_t *coeffs = s->matrix_coeff[mat];
863 int index = s->num_primitive_matrices - mat;
864 int index2 = 2 * index + 1;
866 /* TODO: DSPContext? */
868 for (i = 0; i < s->blockpos; i++) {
869 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
870 int32_t *samples = m->sample_buffer[i];
873 for (src_ch = 0; src_ch <= maxchan; src_ch++)
874 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
876 if (matrix_noise_shift) {
877 index &= m->access_unit_size_pow2 - 1;
878 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
882 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
887 /** Write the audio data into the output buffer. */
889 static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
890 uint8_t *data, unsigned int *data_size, int is32)
892 SubStream *s = &m->substream[substr];
893 unsigned int i, out_ch = 0;
894 int32_t *data_32 = (int32_t*) data;
895 int16_t *data_16 = (int16_t*) data;
897 if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
900 for (i = 0; i < s->blockpos; i++) {
901 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
902 int mat_ch = s->ch_assign[out_ch];
903 int32_t sample = m->sample_buffer[i][mat_ch]
904 << s->output_shift[mat_ch];
905 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
906 if (is32) *data_32++ = sample << 8;
907 else *data_16++ = sample >> 8;
911 *data_size = i * out_ch * (is32 ? 4 : 2);
916 static int output_data(MLPDecodeContext *m, unsigned int substr,
917 uint8_t *data, unsigned int *data_size)
919 if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
920 return output_data_internal(m, substr, data, data_size, 1);
922 return output_data_internal(m, substr, data, data_size, 0);
926 /** Read an access unit from the stream.
927 * Returns < 0 on error, 0 if not enough data is present in the input stream
928 * otherwise returns the number of bytes consumed. */
930 static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
933 const uint8_t *buf = avpkt->data;
934 int buf_size = avpkt->size;
935 MLPDecodeContext *m = avctx->priv_data;
937 unsigned int length, substr;
938 unsigned int substream_start;
939 unsigned int header_size = 4;
940 unsigned int substr_header_size = 0;
941 uint8_t substream_parity_present[MAX_SUBSTREAMS];
942 uint16_t substream_data_len[MAX_SUBSTREAMS];
948 length = (AV_RB16(buf) & 0xfff) * 2;
950 if (length > buf_size)
953 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
955 m->is_major_sync_unit = 0;
956 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
957 if (read_major_sync(m, &gb) < 0)
959 m->is_major_sync_unit = 1;
963 if (!m->params_valid) {
964 av_log(m->avctx, AV_LOG_WARNING,
965 "Stream parameters not seen; skipping frame.\n");
972 for (substr = 0; substr < m->num_substreams; substr++) {
973 int extraword_present, checkdata_present, end, nonrestart_substr;
975 extraword_present = get_bits1(&gb);
976 nonrestart_substr = get_bits1(&gb);
977 checkdata_present = get_bits1(&gb);
980 end = get_bits(&gb, 12) * 2;
982 substr_header_size += 2;
984 if (extraword_present) {
985 if (m->avctx->codec_id == CODEC_ID_MLP) {
986 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
990 substr_header_size += 2;
993 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
994 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
998 if (end + header_size + substr_header_size > length) {
999 av_log(m->avctx, AV_LOG_ERROR,
1000 "Indicated length of substream %d data goes off end of "
1001 "packet.\n", substr);
1002 end = length - header_size - substr_header_size;
1005 if (end < substream_start) {
1006 av_log(avctx, AV_LOG_ERROR,
1007 "Indicated end offset of substream %d data "
1008 "is smaller than calculated start offset.\n",
1013 if (substr > m->max_decoded_substream)
1016 substream_parity_present[substr] = checkdata_present;
1017 substream_data_len[substr] = end - substream_start;
1018 substream_start = end;
1021 parity_bits = ff_mlp_calculate_parity(buf, 4);
1022 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1024 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1025 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1029 buf += header_size + substr_header_size;
1031 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1032 SubStream *s = &m->substream[substr];
1033 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1035 m->matrix_changed = 0;
1036 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1040 if (get_bits1(&gb)) {
1041 if (get_bits1(&gb)) {
1042 /* A restart header should be present. */
1043 if (read_restart_header(m, &gb, buf, substr) < 0)
1045 s->restart_seen = 1;
1048 if (!s->restart_seen)
1050 if (read_decoding_params(m, &gb, substr) < 0)
1054 if (!s->restart_seen)
1057 if (read_block_data(m, &gb, substr) < 0)
1060 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1061 goto substream_length_mismatch;
1063 } while (!get_bits1(&gb));
1065 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1067 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1070 if (get_bits(&gb, 16) != 0xD234)
1073 shorten_by = get_bits(&gb, 16);
1074 if (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by & 0x2000)
1075 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1076 else if (m->avctx->codec_id == CODEC_ID_MLP && shorten_by != 0xD234)
1079 if (substr == m->max_decoded_substream)
1080 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1083 if (substream_parity_present[substr]) {
1084 uint8_t parity, checksum;
1086 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1087 goto substream_length_mismatch;
1089 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1090 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1092 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1093 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1094 if ( get_bits(&gb, 8) != checksum)
1095 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1098 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1099 goto substream_length_mismatch;
1102 if (!s->restart_seen)
1103 av_log(m->avctx, AV_LOG_ERROR,
1104 "No restart header present in substream %d.\n", substr);
1106 buf += substream_data_len[substr];
1109 rematrix_channels(m, m->max_decoded_substream);
1111 if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1116 substream_length_mismatch:
1117 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1121 m->params_valid = 0;
1125 #if CONFIG_MLP_DECODER
1126 AVCodec mlp_decoder = {
1130 sizeof(MLPDecodeContext),
1135 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1137 #endif /* CONFIG_MLP_DECODER */
1139 #if CONFIG_TRUEHD_DECODER
1140 AVCodec truehd_decoder = {
1144 sizeof(MLPDecodeContext),
1149 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1151 #endif /* CONFIG_TRUEHD_DECODER */