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
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 //! Channel coding parameters for channels in the substream
66 ChannelParams channel_params[MAX_CHANNELS];
68 //! The left shift applied to random noise in 0x31ea substreams.
70 //! The current seed value for the pseudorandom noise generator(s).
71 uint32_t noisegen_seed;
73 //! Set if the substream contains extra info to check the size of VLC blocks.
74 uint8_t data_check_present;
76 //! Bitmask of which parameter sets are conveyed in a decoding parameter block.
77 uint8_t param_presence_flags;
78 #define PARAM_BLOCKSIZE (1 << 7)
79 #define PARAM_MATRIX (1 << 6)
80 #define PARAM_OUTSHIFT (1 << 5)
81 #define PARAM_QUANTSTEP (1 << 4)
82 #define PARAM_FIR (1 << 3)
83 #define PARAM_IIR (1 << 2)
84 #define PARAM_HUFFOFFSET (1 << 1)
85 #define PARAM_PRESENCE (1 << 0)
91 //! Number of matrices to be applied.
92 uint8_t num_primitive_matrices;
94 //! matrix output channel
95 uint8_t matrix_out_ch[MAX_MATRICES];
97 //! Whether the LSBs of the matrix output are encoded in the bitstream.
98 uint8_t lsb_bypass[MAX_MATRICES];
99 //! Matrix coefficients, stored as 2.14 fixed point.
100 int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
101 //! Left shift to apply to noise values in 0x31eb substreams.
102 uint8_t matrix_noise_shift[MAX_MATRICES];
105 //! Left shift to apply to Huffman-decoded residuals.
106 uint8_t quant_step_size[MAX_CHANNELS];
108 //! number of PCM samples in current audio block
110 //! Number of PCM samples decoded so far in this frame.
113 //! Left shift to apply to decoded PCM values to get final 24-bit output.
114 int8_t output_shift[MAX_CHANNELS];
116 //! Running XOR of all output samples.
117 int32_t lossless_check_data;
121 typedef struct MLPDecodeContext {
122 AVCodecContext *avctx;
124 //! Current access unit being read has a major sync.
125 int is_major_sync_unit;
127 //! Set if a valid major sync block has been read. Otherwise no decoding is possible.
128 uint8_t params_valid;
130 //! Number of substreams contained within this stream.
131 uint8_t num_substreams;
133 //! Index of the last substream to decode - further substreams are skipped.
134 uint8_t max_decoded_substream;
136 //! Stream needs channel reordering to comply with FFmpeg's channel order
137 uint8_t needs_reordering;
139 //! number of PCM samples contained in each frame
140 int access_unit_size;
141 //! next power of two above the number of samples in each frame
142 int access_unit_size_pow2;
144 SubStream substream[MAX_SUBSTREAMS];
147 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
149 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
150 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
151 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
156 static VLC huff_vlc[3];
158 /** Initialize static data, constant between all invocations of the codec. */
160 static av_cold void init_static(void)
162 if (!huff_vlc[0].bits) {
163 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
164 &ff_mlp_huffman_tables[0][0][1], 2, 1,
165 &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
166 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
167 &ff_mlp_huffman_tables[1][0][1], 2, 1,
168 &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
169 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
170 &ff_mlp_huffman_tables[2][0][1], 2, 1,
171 &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
177 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
178 unsigned int substr, unsigned int ch)
180 SubStream *s = &m->substream[substr];
181 ChannelParams *cp = &s->channel_params[ch];
182 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
183 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
184 int32_t sign_huff_offset = cp->huff_offset;
186 if (cp->codebook > 0)
187 sign_huff_offset -= 7 << lsb_bits;
190 sign_huff_offset -= 1 << sign_shift;
192 return sign_huff_offset;
195 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
198 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
199 unsigned int substr, unsigned int pos)
201 SubStream *s = &m->substream[substr];
202 unsigned int mat, channel;
204 for (mat = 0; mat < s->num_primitive_matrices; mat++)
205 if (s->lsb_bypass[mat])
206 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
208 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
209 ChannelParams *cp = &s->channel_params[channel];
210 int codebook = cp->codebook;
211 int quant_step_size = s->quant_step_size[channel];
212 int lsb_bits = cp->huff_lsbs - quant_step_size;
216 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
217 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
223 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
225 result += cp->sign_huff_offset;
226 result <<= quant_step_size;
228 m->sample_buffer[pos + s->blockpos][channel] = result;
234 static av_cold int mlp_decode_init(AVCodecContext *avctx)
236 MLPDecodeContext *m = avctx->priv_data;
241 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
242 m->substream[substr].lossless_check_data = 0xffffffff;
243 dsputil_init(&m->dsp, avctx);
248 /** Read a major sync info header - contains high level information about
249 * the stream - sample rate, channel arrangement etc. Most of this
250 * information is not actually necessary for decoding, only for playback.
253 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
258 if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
261 if (mh.group1_bits == 0) {
262 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
265 if (mh.group2_bits > mh.group1_bits) {
266 av_log(m->avctx, AV_LOG_ERROR,
267 "Channel group 2 cannot have more bits per sample than group 1.\n");
271 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
272 av_log(m->avctx, AV_LOG_ERROR,
273 "Channel groups with differing sample rates are not currently supported.\n");
277 if (mh.group1_samplerate == 0) {
278 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
281 if (mh.group1_samplerate > MAX_SAMPLERATE) {
282 av_log(m->avctx, AV_LOG_ERROR,
283 "Sampling rate %d is greater than the supported maximum (%d).\n",
284 mh.group1_samplerate, MAX_SAMPLERATE);
287 if (mh.access_unit_size > MAX_BLOCKSIZE) {
288 av_log(m->avctx, AV_LOG_ERROR,
289 "Block size %d is greater than the supported maximum (%d).\n",
290 mh.access_unit_size, MAX_BLOCKSIZE);
293 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
294 av_log(m->avctx, AV_LOG_ERROR,
295 "Block size pow2 %d is greater than the supported maximum (%d).\n",
296 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
300 if (mh.num_substreams == 0)
302 if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
303 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
306 if (mh.num_substreams > MAX_SUBSTREAMS) {
307 av_log(m->avctx, AV_LOG_ERROR,
308 "Number of substreams %d is larger than the maximum supported "
309 "by the decoder. %s\n", mh.num_substreams, sample_message);
313 m->access_unit_size = mh.access_unit_size;
314 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
316 m->num_substreams = mh.num_substreams;
317 m->max_decoded_substream = m->num_substreams - 1;
319 m->avctx->sample_rate = mh.group1_samplerate;
320 m->avctx->frame_size = mh.access_unit_size;
322 m->avctx->bits_per_raw_sample = mh.group1_bits;
323 if (mh.group1_bits > 16)
324 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
326 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
329 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
330 m->substream[substr].restart_seen = 0;
332 if (mh.stream_type == 0xbb) {
334 m->avctx->channel_layout = ff_mlp_layout[mh.channels_mlp];
335 } else { /* mh.stream_type == 0xba */
337 if (mh.channels_thd_stream2) {
338 m->avctx->channel_layout = ff_truehd_layout(mh.channels_thd_stream2);
340 m->avctx->channel_layout = ff_truehd_layout(mh.channels_thd_stream1);
342 if (m->avctx->channels &&
343 !m->avctx->request_channels && !m->avctx->request_channel_layout &&
344 av_get_channel_layout_nb_channels(m->avctx->channel_layout) != m->avctx->channels) {
345 m->avctx->channel_layout = 0;
346 av_log_ask_for_sample(m->avctx, "Unknown channel layout.");
350 m->needs_reordering = mh.channels_mlp >= 18 && mh.channels_mlp <= 20;
355 /** Read a restart header from a block in a substream. This contains parameters
356 * required to decode the audio that do not change very often. Generally
357 * (always) present only in blocks following a major sync. */
359 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
360 const uint8_t *buf, unsigned int substr)
362 SubStream *s = &m->substream[substr];
366 uint8_t lossless_check;
367 int start_count = get_bits_count(gbp);
368 const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP
369 ? MAX_MATRIX_CHANNEL_MLP
370 : MAX_MATRIX_CHANNEL_TRUEHD;
372 sync_word = get_bits(gbp, 13);
374 if (sync_word != 0x31ea >> 1) {
375 av_log(m->avctx, AV_LOG_ERROR,
376 "restart header sync incorrect (got 0x%04x)\n", sync_word);
380 s->noise_type = get_bits1(gbp);
382 if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) {
383 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
387 skip_bits(gbp, 16); /* Output timestamp */
389 s->min_channel = get_bits(gbp, 4);
390 s->max_channel = get_bits(gbp, 4);
391 s->max_matrix_channel = get_bits(gbp, 4);
393 if (s->max_matrix_channel > max_matrix_channel) {
394 av_log(m->avctx, AV_LOG_ERROR,
395 "Max matrix channel cannot be greater than %d.\n",
400 if (s->max_channel != s->max_matrix_channel) {
401 av_log(m->avctx, AV_LOG_ERROR,
402 "Max channel must be equal max matrix channel.\n");
406 /* This should happen for TrueHD streams with >6 channels and MLP's noise
407 * type. It is not yet known if this is allowed. */
408 if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
409 av_log(m->avctx, AV_LOG_ERROR,
410 "Number of channels %d is larger than the maximum supported "
411 "by the decoder. %s\n", s->max_channel+2, sample_message);
415 if (s->min_channel > s->max_channel) {
416 av_log(m->avctx, AV_LOG_ERROR,
417 "Substream min channel cannot be greater than max channel.\n");
421 if (m->avctx->request_channels > 0
422 && s->max_channel + 1 >= m->avctx->request_channels
423 && substr < m->max_decoded_substream) {
424 av_log(m->avctx, AV_LOG_DEBUG,
425 "Extracting %d channel downmix from substream %d. "
426 "Further substreams will be skipped.\n",
427 s->max_channel + 1, substr);
428 m->max_decoded_substream = substr;
431 s->noise_shift = get_bits(gbp, 4);
432 s->noisegen_seed = get_bits(gbp, 23);
436 s->data_check_present = get_bits1(gbp);
437 lossless_check = get_bits(gbp, 8);
438 if (substr == m->max_decoded_substream
439 && s->lossless_check_data != 0xffffffff) {
440 tmp = xor_32_to_8(s->lossless_check_data);
441 if (tmp != lossless_check)
442 av_log(m->avctx, AV_LOG_WARNING,
443 "Lossless check failed - expected %02x, calculated %02x.\n",
444 lossless_check, tmp);
449 memset(s->ch_assign, 0, sizeof(s->ch_assign));
451 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
452 int ch_assign = get_bits(gbp, 6);
453 if (ch_assign > s->max_matrix_channel) {
454 av_log(m->avctx, AV_LOG_ERROR,
455 "Assignment of matrix channel %d to invalid output channel %d. %s\n",
456 ch, ch_assign, sample_message);
459 s->ch_assign[ch_assign] = ch;
462 if (m->avctx->codec_id == CODEC_ID_MLP && m->needs_reordering) {
463 if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
464 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
465 int i = s->ch_assign[4];
466 s->ch_assign[4] = s->ch_assign[3];
467 s->ch_assign[3] = s->ch_assign[2];
469 } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
470 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
471 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
474 if (m->avctx->codec_id == CODEC_ID_TRUEHD &&
475 m->avctx->channel_layout == AV_CH_LAYOUT_7POINT1) {
476 FFSWAP(int, s->ch_assign[4], s->ch_assign[6]);
477 FFSWAP(int, s->ch_assign[5], s->ch_assign[7]);
480 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
482 if (checksum != get_bits(gbp, 8))
483 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
485 /* Set default decoding parameters. */
486 s->param_presence_flags = 0xff;
487 s->num_primitive_matrices = 0;
489 s->lossless_check_data = 0;
491 memset(s->output_shift , 0, sizeof(s->output_shift ));
492 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
494 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
495 ChannelParams *cp = &s->channel_params[ch];
496 cp->filter_params[FIR].order = 0;
497 cp->filter_params[IIR].order = 0;
498 cp->filter_params[FIR].shift = 0;
499 cp->filter_params[IIR].shift = 0;
501 /* Default audio coding is 24-bit raw PCM. */
503 cp->sign_huff_offset = (-1) << 23;
508 if (substr == m->max_decoded_substream)
509 m->avctx->channels = s->max_matrix_channel + 1;
514 /** Read parameters for one of the prediction filters. */
516 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
517 unsigned int substr, unsigned int channel,
520 SubStream *s = &m->substream[substr];
521 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
522 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
523 const char fchar = filter ? 'I' : 'F';
526 // Filter is 0 for FIR, 1 for IIR.
529 if (m->filter_changed[channel][filter]++ > 1) {
530 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
534 order = get_bits(gbp, 4);
535 if (order > max_order) {
536 av_log(m->avctx, AV_LOG_ERROR,
537 "%cIR filter order %d is greater than maximum %d.\n",
538 fchar, order, max_order);
544 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
545 int coeff_bits, coeff_shift;
547 fp->shift = get_bits(gbp, 4);
549 coeff_bits = get_bits(gbp, 5);
550 coeff_shift = get_bits(gbp, 3);
551 if (coeff_bits < 1 || coeff_bits > 16) {
552 av_log(m->avctx, AV_LOG_ERROR,
553 "%cIR filter coeff_bits must be between 1 and 16.\n",
557 if (coeff_bits + coeff_shift > 16) {
558 av_log(m->avctx, AV_LOG_ERROR,
559 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
564 for (i = 0; i < order; i++)
565 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
567 if (get_bits1(gbp)) {
568 int state_bits, state_shift;
571 av_log(m->avctx, AV_LOG_ERROR,
572 "FIR filter has state data specified.\n");
576 state_bits = get_bits(gbp, 4);
577 state_shift = get_bits(gbp, 4);
579 /* TODO: Check validity of state data. */
581 for (i = 0; i < order; i++)
582 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
589 /** Read parameters for primitive matrices. */
591 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
593 SubStream *s = &m->substream[substr];
594 unsigned int mat, ch;
595 const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
597 : MAX_MATRICES_TRUEHD;
599 if (m->matrix_changed++ > 1) {
600 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
604 s->num_primitive_matrices = get_bits(gbp, 4);
606 if (s->num_primitive_matrices > max_primitive_matrices) {
607 av_log(m->avctx, AV_LOG_ERROR,
608 "Number of primitive matrices cannot be greater than %d.\n",
609 max_primitive_matrices);
613 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
614 int frac_bits, max_chan;
615 s->matrix_out_ch[mat] = get_bits(gbp, 4);
616 frac_bits = get_bits(gbp, 4);
617 s->lsb_bypass [mat] = get_bits1(gbp);
619 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
620 av_log(m->avctx, AV_LOG_ERROR,
621 "Invalid channel %d specified as output from matrix.\n",
622 s->matrix_out_ch[mat]);
625 if (frac_bits > 14) {
626 av_log(m->avctx, AV_LOG_ERROR,
627 "Too many fractional bits specified.\n");
631 max_chan = s->max_matrix_channel;
635 for (ch = 0; ch <= max_chan; ch++) {
638 coeff_val = get_sbits(gbp, frac_bits + 2);
640 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
644 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
646 s->matrix_noise_shift[mat] = 0;
652 /** Read channel parameters. */
654 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
655 GetBitContext *gbp, unsigned int ch)
657 SubStream *s = &m->substream[substr];
658 ChannelParams *cp = &s->channel_params[ch];
659 FilterParams *fir = &cp->filter_params[FIR];
660 FilterParams *iir = &cp->filter_params[IIR];
662 if (s->param_presence_flags & PARAM_FIR)
664 if (read_filter_params(m, gbp, substr, ch, FIR) < 0)
667 if (s->param_presence_flags & PARAM_IIR)
669 if (read_filter_params(m, gbp, substr, ch, IIR) < 0)
672 if (fir->order + iir->order > 8) {
673 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
677 if (fir->order && iir->order &&
678 fir->shift != iir->shift) {
679 av_log(m->avctx, AV_LOG_ERROR,
680 "FIR and IIR filters must use the same precision.\n");
683 /* The FIR and IIR filters must have the same precision.
684 * To simplify the filtering code, only the precision of the
685 * FIR filter is considered. If only the IIR filter is employed,
686 * the FIR filter precision is set to that of the IIR filter, so
687 * that the filtering code can use it. */
688 if (!fir->order && iir->order)
689 fir->shift = iir->shift;
691 if (s->param_presence_flags & PARAM_HUFFOFFSET)
693 cp->huff_offset = get_sbits(gbp, 15);
695 cp->codebook = get_bits(gbp, 2);
696 cp->huff_lsbs = get_bits(gbp, 5);
698 if (cp->huff_lsbs > 24) {
699 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
703 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
708 /** Read decoding parameters that change more often than those in the restart
711 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
714 SubStream *s = &m->substream[substr];
717 if (s->param_presence_flags & PARAM_PRESENCE)
719 s->param_presence_flags = get_bits(gbp, 8);
721 if (s->param_presence_flags & PARAM_BLOCKSIZE)
722 if (get_bits1(gbp)) {
723 s->blocksize = get_bits(gbp, 9);
724 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
725 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
731 if (s->param_presence_flags & PARAM_MATRIX)
733 if (read_matrix_params(m, substr, gbp) < 0)
736 if (s->param_presence_flags & PARAM_OUTSHIFT)
738 for (ch = 0; ch <= s->max_matrix_channel; ch++)
739 s->output_shift[ch] = get_sbits(gbp, 4);
741 if (s->param_presence_flags & PARAM_QUANTSTEP)
743 for (ch = 0; ch <= s->max_channel; ch++) {
744 ChannelParams *cp = &s->channel_params[ch];
746 s->quant_step_size[ch] = get_bits(gbp, 4);
748 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
751 for (ch = s->min_channel; ch <= s->max_channel; ch++)
753 if (read_channel_params(m, substr, gbp, ch) < 0)
759 #define MSB_MASK(bits) (-1u << bits)
761 /** Generate PCM samples using the prediction filters and residual values
762 * read from the data stream, and update the filter state. */
764 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
765 unsigned int channel)
767 SubStream *s = &m->substream[substr];
768 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
769 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
770 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
771 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
772 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
773 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
774 unsigned int filter_shift = fir->shift;
775 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
777 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
778 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
780 m->dsp.mlp_filter_channel(firbuf, fircoeff,
781 fir->order, iir->order,
782 filter_shift, mask, s->blocksize,
783 &m->sample_buffer[s->blockpos][channel]);
785 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
786 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
789 /** Read a block of PCM residual data (or actual if no filtering active). */
791 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
794 SubStream *s = &m->substream[substr];
795 unsigned int i, ch, expected_stream_pos = 0;
797 if (s->data_check_present) {
798 expected_stream_pos = get_bits_count(gbp);
799 expected_stream_pos += get_bits(gbp, 16);
800 av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
801 "we have not tested yet. %s\n", sample_message);
804 if (s->blockpos + s->blocksize > m->access_unit_size) {
805 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
809 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
810 s->blocksize * sizeof(m->bypassed_lsbs[0]));
812 for (i = 0; i < s->blocksize; i++)
813 if (read_huff_channels(m, gbp, substr, i) < 0)
816 for (ch = s->min_channel; ch <= s->max_channel; ch++)
817 filter_channel(m, substr, ch);
819 s->blockpos += s->blocksize;
821 if (s->data_check_present) {
822 if (get_bits_count(gbp) != expected_stream_pos)
823 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
830 /** Data table used for TrueHD noise generation function. */
832 static const int8_t noise_table[256] = {
833 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
834 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
835 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
836 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
837 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
838 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
839 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
840 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
841 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
842 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
843 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
844 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
845 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
846 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
847 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
848 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
851 /** Noise generation functions.
852 * I'm not sure what these are for - they seem to be some kind of pseudorandom
853 * sequence generators, used to generate noise data which is used when the
854 * channels are rematrixed. I'm not sure if they provide a practical benefit
855 * to compression, or just obfuscate the decoder. Are they for some kind of
858 /** Generate two channels of noise, used in the matrix when
859 * restart sync word == 0x31ea. */
861 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
863 SubStream *s = &m->substream[substr];
865 uint32_t seed = s->noisegen_seed;
866 unsigned int maxchan = s->max_matrix_channel;
868 for (i = 0; i < s->blockpos; i++) {
869 uint16_t seed_shr7 = seed >> 7;
870 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
871 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
873 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
876 s->noisegen_seed = seed;
879 /** Generate a block of noise, used when restart sync word == 0x31eb. */
881 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
883 SubStream *s = &m->substream[substr];
885 uint32_t seed = s->noisegen_seed;
887 for (i = 0; i < m->access_unit_size_pow2; i++) {
888 uint8_t seed_shr15 = seed >> 15;
889 m->noise_buffer[i] = noise_table[seed_shr15];
890 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
893 s->noisegen_seed = seed;
897 /** Apply the channel matrices in turn to reconstruct the original audio
900 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
902 SubStream *s = &m->substream[substr];
903 unsigned int mat, src_ch, i;
904 unsigned int maxchan;
906 maxchan = s->max_matrix_channel;
907 if (!s->noise_type) {
908 generate_2_noise_channels(m, substr);
911 fill_noise_buffer(m, substr);
914 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
915 int matrix_noise_shift = s->matrix_noise_shift[mat];
916 unsigned int dest_ch = s->matrix_out_ch[mat];
917 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
918 int32_t *coeffs = s->matrix_coeff[mat];
919 int index = s->num_primitive_matrices - mat;
920 int index2 = 2 * index + 1;
922 /* TODO: DSPContext? */
924 for (i = 0; i < s->blockpos; i++) {
925 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
926 int32_t *samples = m->sample_buffer[i];
929 for (src_ch = 0; src_ch <= maxchan; src_ch++)
930 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
932 if (matrix_noise_shift) {
933 index &= m->access_unit_size_pow2 - 1;
934 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
938 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
943 /** Write the audio data into the output buffer. */
945 static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
946 uint8_t *data, unsigned int *data_size, int is32)
948 SubStream *s = &m->substream[substr];
949 unsigned int i, out_ch = 0;
950 int32_t *data_32 = (int32_t*) data;
951 int16_t *data_16 = (int16_t*) data;
953 if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
956 for (i = 0; i < s->blockpos; i++) {
957 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
958 int mat_ch = s->ch_assign[out_ch];
959 int32_t sample = m->sample_buffer[i][mat_ch]
960 << s->output_shift[mat_ch];
961 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
962 if (is32) *data_32++ = sample << 8;
963 else *data_16++ = sample >> 8;
967 *data_size = i * out_ch * (is32 ? 4 : 2);
972 static int output_data(MLPDecodeContext *m, unsigned int substr,
973 uint8_t *data, unsigned int *data_size)
975 if (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32)
976 return output_data_internal(m, substr, data, data_size, 1);
978 return output_data_internal(m, substr, data, data_size, 0);
982 /** Read an access unit from the stream.
983 * @return negative on error, 0 if not enough data is present in the input stream,
984 * otherwise the number of bytes consumed. */
986 static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
989 const uint8_t *buf = avpkt->data;
990 int buf_size = avpkt->size;
991 MLPDecodeContext *m = avctx->priv_data;
993 unsigned int length, substr;
994 unsigned int substream_start;
995 unsigned int header_size = 4;
996 unsigned int substr_header_size = 0;
997 uint8_t substream_parity_present[MAX_SUBSTREAMS];
998 uint16_t substream_data_len[MAX_SUBSTREAMS];
1004 length = (AV_RB16(buf) & 0xfff) * 2;
1006 if (length < 4 || length > buf_size)
1009 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1011 m->is_major_sync_unit = 0;
1012 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1013 if (read_major_sync(m, &gb) < 0)
1015 m->is_major_sync_unit = 1;
1019 if (!m->params_valid) {
1020 av_log(m->avctx, AV_LOG_WARNING,
1021 "Stream parameters not seen; skipping frame.\n");
1026 substream_start = 0;
1028 for (substr = 0; substr < m->num_substreams; substr++) {
1029 int extraword_present, checkdata_present, end, nonrestart_substr;
1031 extraword_present = get_bits1(&gb);
1032 nonrestart_substr = get_bits1(&gb);
1033 checkdata_present = get_bits1(&gb);
1036 end = get_bits(&gb, 12) * 2;
1038 substr_header_size += 2;
1040 if (extraword_present) {
1041 if (m->avctx->codec_id == CODEC_ID_MLP) {
1042 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1046 substr_header_size += 2;
1049 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1050 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1054 if (end + header_size + substr_header_size > length) {
1055 av_log(m->avctx, AV_LOG_ERROR,
1056 "Indicated length of substream %d data goes off end of "
1057 "packet.\n", substr);
1058 end = length - header_size - substr_header_size;
1061 if (end < substream_start) {
1062 av_log(avctx, AV_LOG_ERROR,
1063 "Indicated end offset of substream %d data "
1064 "is smaller than calculated start offset.\n",
1069 if (substr > m->max_decoded_substream)
1072 substream_parity_present[substr] = checkdata_present;
1073 substream_data_len[substr] = end - substream_start;
1074 substream_start = end;
1077 parity_bits = ff_mlp_calculate_parity(buf, 4);
1078 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1080 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1081 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1085 buf += header_size + substr_header_size;
1087 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1088 SubStream *s = &m->substream[substr];
1089 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1091 m->matrix_changed = 0;
1092 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1096 if (get_bits1(&gb)) {
1097 if (get_bits1(&gb)) {
1098 /* A restart header should be present. */
1099 if (read_restart_header(m, &gb, buf, substr) < 0)
1101 s->restart_seen = 1;
1104 if (!s->restart_seen)
1106 if (read_decoding_params(m, &gb, substr) < 0)
1110 if (!s->restart_seen)
1113 if (read_block_data(m, &gb, substr) < 0)
1116 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1117 goto substream_length_mismatch;
1119 } while (!get_bits1(&gb));
1121 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1123 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1126 if (get_bits(&gb, 16) != 0xD234)
1129 shorten_by = get_bits(&gb, 16);
1130 if (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by & 0x2000)
1131 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1132 else if (m->avctx->codec_id == CODEC_ID_MLP && shorten_by != 0xD234)
1135 if (substr == m->max_decoded_substream)
1136 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1139 if (substream_parity_present[substr]) {
1140 uint8_t parity, checksum;
1142 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1143 goto substream_length_mismatch;
1145 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1146 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1148 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1149 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1150 if ( get_bits(&gb, 8) != checksum)
1151 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1154 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1155 goto substream_length_mismatch;
1158 if (!s->restart_seen)
1159 av_log(m->avctx, AV_LOG_ERROR,
1160 "No restart header present in substream %d.\n", substr);
1162 buf += substream_data_len[substr];
1165 rematrix_channels(m, m->max_decoded_substream);
1167 if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1172 substream_length_mismatch:
1173 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1177 m->params_valid = 0;
1181 AVCodec ff_mlp_decoder = {
1183 .type = AVMEDIA_TYPE_AUDIO,
1185 .priv_data_size = sizeof(MLPDecodeContext),
1186 .init = mlp_decode_init,
1187 .decode = read_access_unit,
1188 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1191 #if CONFIG_TRUEHD_DECODER
1192 AVCodec ff_truehd_decoder = {
1194 .type = AVMEDIA_TYPE_AUDIO,
1195 .id = CODEC_ID_TRUEHD,
1196 .priv_data_size = sizeof(MLPDecodeContext),
1197 .init = mlp_decode_init,
1198 .decode = read_access_unit,
1199 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1201 #endif /* CONFIG_TRUEHD_DECODER */