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
30 #include "libavutil/intreadwrite.h"
31 #include "bitstream.h"
32 #include "libavutil/crc.h"
34 #include "mlp_parser.h"
37 /** number of bits used for VLC lookup - longest Huffman code is 9 */
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.";
46 typedef struct SubStream {
47 //! Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
51 /** restart header data */
52 //! The type of noise to be used in the rematrix stage.
55 //! The index of the first channel coded in this substream.
57 //! The index of the last channel coded in this substream.
59 //! The number of channels input into the rematrix stage.
60 uint8_t max_matrix_channel;
62 //! The left shift applied to random noise in 0x31ea substreams.
64 //! The current seed value for the pseudorandom noise generator(s).
65 uint32_t noisegen_seed;
67 //! Set if the substream contains extra info to check the size of VLC blocks.
68 uint8_t data_check_present;
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)
84 //! Number of matrices to be applied.
85 uint8_t num_primitive_matrices;
87 //! matrix output channel
88 uint8_t matrix_out_ch[MAX_MATRICES];
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];
98 //! Left shift to apply to Huffman-decoded residuals.
99 uint8_t quant_step_size[MAX_CHANNELS];
101 //! number of PCM samples in current audio block
103 //! Number of PCM samples decoded so far in this frame.
106 //! Left shift to apply to decoded PCM values to get final 24-bit output.
107 int8_t output_shift[MAX_CHANNELS];
109 //! Running XOR of all output samples.
110 int32_t lossless_check_data;
114 typedef struct MLPDecodeContext {
115 AVCodecContext *avctx;
117 //! Set if a valid major sync block has been read. Otherwise no decoding is possible.
118 uint8_t params_valid;
120 //! Number of substreams contained within this stream.
121 uint8_t num_substreams;
123 //! Index of the last substream to decode - further substreams are skipped.
124 uint8_t max_decoded_substream;
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;
131 SubStream substream[MAX_SUBSTREAMS];
133 ChannelParams channel_params[MAX_CHANNELS];
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];
140 static VLC huff_vlc[3];
142 /** Initialize static data, constant between all invocations of the codec. */
144 static av_cold void init_static(void)
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);
159 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
160 unsigned int substr, unsigned int ch)
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;
168 if (cp->codebook > 0)
169 sign_huff_offset -= 7 << lsb_bits;
172 sign_huff_offset -= 1 << sign_shift;
174 return sign_huff_offset;
177 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
180 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
181 unsigned int substr, unsigned int pos)
183 SubStream *s = &m->substream[substr];
184 unsigned int mat, channel;
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);
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;
198 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
199 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
205 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
207 result += cp->sign_huff_offset;
208 result <<= quant_step_size;
210 m->sample_buffer[pos + s->blockpos][channel] = result;
216 static av_cold int mlp_decode_init(AVCodecContext *avctx)
218 MLPDecodeContext *m = avctx->priv_data;
223 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
224 m->substream[substr].lossless_check_data = 0xffffffff;
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.
234 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
239 if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
242 if (mh.group1_bits == 0) {
243 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
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");
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");
258 if (mh.group1_samplerate == 0) {
259 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
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);
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);
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);
281 if (mh.num_substreams == 0)
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);
290 m->access_unit_size = mh.access_unit_size;
291 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
293 m->num_substreams = mh.num_substreams;
294 m->max_decoded_substream = m->num_substreams - 1;
296 m->avctx->sample_rate = mh.group1_samplerate;
297 m->avctx->frame_size = mh.access_unit_size;
299 m->avctx->bits_per_raw_sample = mh.group1_bits;
300 if (mh.group1_bits > 16)
301 m->avctx->sample_fmt = SAMPLE_FMT_S32;
303 m->avctx->sample_fmt = SAMPLE_FMT_S16;
306 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
307 m->substream[substr].restart_seen = 0;
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. */
316 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
317 const uint8_t *buf, unsigned int substr)
319 SubStream *s = &m->substream[substr];
323 uint8_t lossless_check;
324 int start_count = get_bits_count(gbp);
326 sync_word = get_bits(gbp, 13);
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);
333 s->noise_type = get_bits1(gbp);
335 skip_bits(gbp, 16); /* Output timestamp */
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);
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");
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;
357 s->noise_shift = get_bits(gbp, 4);
358 s->noisegen_seed = get_bits(gbp, 23);
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);
372 dprintf(m->avctx, "Lossless check passed for substream %d (%x).\n",
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,
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",
390 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
392 if (checksum != get_bits(gbp, 8))
393 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
395 /* Set default decoding parameters. */
396 s->param_presence_flags = 0xff;
397 s->num_primitive_matrices = 0;
399 s->lossless_check_data = 0;
401 memset(s->output_shift , 0, sizeof(s->output_shift ));
402 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
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;
411 /* Default audio coding is 24-bit raw PCM. */
413 cp->sign_huff_offset = (-1) << 23;
418 if (substr == m->max_decoded_substream) {
419 m->avctx->channels = s->max_channel + 1;
425 /** Read parameters for one of the prediction filters. */
427 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
428 unsigned int channel, unsigned int filter)
430 FilterParams *fp = &m->channel_params[channel].filter_params[filter];
431 const char fchar = filter ? 'I' : 'F';
434 // Filter is 0 for FIR, 1 for IIR.
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);
447 int coeff_bits, coeff_shift;
449 fp->shift = get_bits(gbp, 4);
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",
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",
466 for (i = 0; i < order; i++)
467 fp->coeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
469 if (get_bits1(gbp)) {
470 int state_bits, state_shift;
473 av_log(m->avctx, AV_LOG_ERROR,
474 "FIR filter has state data specified.\n");
478 state_bits = get_bits(gbp, 4);
479 state_shift = get_bits(gbp, 4);
481 /* TODO: Check validity of state data. */
483 for (i = 0; i < order; i++)
484 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
491 /** Read decoding parameters that change more often than those in the restart
494 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
497 SubStream *s = &m->substream[substr];
498 unsigned int mat, ch;
501 s->param_presence_flags = get_bits(gbp, 8);
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");
513 if (s->param_presence_flags & PARAM_MATRIX)
514 if (get_bits1(gbp)) {
515 s->num_primitive_matrices = get_bits(gbp, 4);
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);
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]);
529 if (frac_bits > 14) {
530 av_log(m->avctx, AV_LOG_ERROR,
531 "Too many fractional bits specified.\n");
535 max_chan = s->max_matrix_channel;
539 for (ch = 0; ch <= max_chan; ch++) {
542 coeff_val = get_sbits(gbp, frac_bits + 2);
544 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
548 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
550 s->matrix_noise_shift[mat] = 0;
554 if (s->param_presence_flags & PARAM_OUTSHIFT)
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]);
563 if (s->param_presence_flags & PARAM_QUANTSTEP)
565 for (ch = 0; ch <= s->max_channel; ch++) {
566 ChannelParams *cp = &m->channel_params[ch];
568 s->quant_step_size[ch] = get_bits(gbp, 4);
571 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
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];
580 if (s->param_presence_flags & PARAM_FIR)
582 if (read_filter_params(m, gbp, ch, FIR) < 0)
585 if (s->param_presence_flags & PARAM_IIR)
587 if (read_filter_params(m, gbp, ch, IIR) < 0)
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");
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;
604 if (s->param_presence_flags & PARAM_HUFFOFFSET)
606 cp->huff_offset = get_sbits(gbp, 15);
608 cp->codebook = get_bits(gbp, 2);
609 cp->huff_lsbs = get_bits(gbp, 5);
611 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
619 #define MSB_MASK(bits) (-1u << bits)
621 /** Generate PCM samples using the prediction filters and residual values
622 * read from the data stream, and update the filter state. */
624 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
625 unsigned int channel)
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;
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));
641 for (i = 0; i < s->blocksize; i++) {
642 int32_t residual = m->sample_buffer[i + s->blockpos][channel];
647 /* TODO: Move this code to DSPContext? */
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] *
654 accum = accum >> filter_shift;
655 result = (accum + residual) & mask;
659 filter_state_buffer[FIR][index] = result;
660 filter_state_buffer[IIR][index] = result - accum;
662 m->sample_buffer[i + s->blockpos][channel] = result;
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));
671 /** Read a block of PCM residual data (or actual if no filtering active). */
673 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
676 SubStream *s = &m->substream[substr];
677 unsigned int i, ch, expected_stream_pos = 0;
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);
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");
691 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
692 s->blocksize * sizeof(m->bypassed_lsbs[0]));
694 for (i = 0; i < s->blocksize; i++) {
695 if (read_huff_channels(m, gbp, substr, i) < 0)
699 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
700 filter_channel(m, substr, ch);
703 s->blockpos += s->blocksize;
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");
714 /** Data table used for TrueHD noise generation function. */
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,
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
742 /** Generate two channels of noise, used in the matrix when
743 * restart sync word == 0x31ea. */
745 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
747 SubStream *s = &m->substream[substr];
749 uint32_t seed = s->noisegen_seed;
750 unsigned int maxchan = s->max_matrix_channel;
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;
757 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
760 s->noisegen_seed = seed;
763 /** Generate a block of noise, used when restart sync word == 0x31eb. */
765 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
767 SubStream *s = &m->substream[substr];
769 uint32_t seed = s->noisegen_seed;
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);
777 s->noisegen_seed = seed;
781 /** Apply the channel matrices in turn to reconstruct the original audio
784 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
786 SubStream *s = &m->substream[substr];
787 unsigned int mat, src_ch, i;
788 unsigned int maxchan;
790 maxchan = s->max_matrix_channel;
791 if (!s->noise_type) {
792 generate_2_noise_channels(m, substr);
795 fill_noise_buffer(m, substr);
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]);
803 /* TODO: DSPContext? */
805 for (i = 0; i < s->blockpos; i++) {
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];
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);
816 m->sample_buffer[i][dest_ch] = ((accum >> 14) & mask)
817 + m->bypassed_lsbs[i][mat];
822 /** Write the audio data into the output buffer. */
824 static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
825 uint8_t *data, unsigned int *data_size, int is32)
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;
832 if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
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;
844 *data_size = i * ch * (is32 ? 4 : 2);
849 static int output_data(MLPDecodeContext *m, unsigned int substr,
850 uint8_t *data, unsigned int *data_size)
852 if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
853 return output_data_internal(m, substr, data, data_size, 1);
855 return output_data_internal(m, substr, data, data_size, 0);
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. */
863 static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
864 const uint8_t *buf, int buf_size)
866 MLPDecodeContext *m = avctx->priv_data;
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];
879 length = (AV_RB16(buf) & 0xfff) * 2;
881 if (length > buf_size)
884 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
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)
893 if (!m->params_valid) {
894 av_log(m->avctx, AV_LOG_WARNING,
895 "Stream parameters not seen; skipping frame.\n");
902 for (substr = 0; substr < m->num_substreams; substr++) {
903 int extraword_present, checkdata_present, end;
905 extraword_present = get_bits1(&gb);
907 checkdata_present = get_bits1(&gb);
910 end = get_bits(&gb, 12) * 2;
912 substr_header_size += 2;
914 if (extraword_present) {
916 substr_header_size += 2;
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;
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",
934 if (substr > m->max_decoded_substream)
937 substream_parity_present[substr] = checkdata_present;
938 substream_data_len[substr] = end - substream_start;
939 substream_start = end;
942 parity_bits = ff_mlp_calculate_parity(buf, 4);
943 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
945 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
946 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
950 buf += header_size + substr_header_size;
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);
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)
966 if (!s->restart_seen) {
967 av_log(m->avctx, AV_LOG_ERROR,
968 "No restart header present in substream %d.\n",
973 if (read_decoding_params(m, &gb, substr) < 0)
977 if (!s->restart_seen) {
978 av_log(m->avctx, AV_LOG_ERROR,
979 "No restart header present in substream %d.\n",
984 if (read_block_data(m, &gb, substr) < 0)
987 } while ((get_bits_count(&gb) < substream_data_len[substr] * 8)
988 && get_bits1(&gb) == 0);
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)) {
995 if (substr == m->max_decoded_substream)
996 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
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;
1005 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 16 &&
1006 substream_parity_present[substr]) {
1007 uint8_t parity, checksum;
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);
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",
1019 if (substream_data_len[substr] * 8 != get_bits_count(&gb)) {
1020 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n",
1026 buf += substream_data_len[substr];
1029 rematrix_channels(m, m->max_decoded_substream);
1031 if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1037 m->params_valid = 0;
1041 AVCodec mlp_decoder = {
1045 sizeof(MLPDecodeContext),
1050 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)/TrueHD"),