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);
220 return AVERROR_INVALIDDATA;
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 ((ret = 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");
263 return AVERROR_INVALIDDATA;
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");
268 return AVERROR_INVALIDDATA;
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");
274 return AVERROR_INVALIDDATA;
277 if (mh.group1_samplerate == 0) {
278 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
279 return AVERROR_INVALIDDATA;
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);
285 return AVERROR_INVALIDDATA;
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);
291 return AVERROR_INVALIDDATA;
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);
297 return AVERROR_INVALIDDATA;
300 if (mh.num_substreams == 0)
301 return AVERROR_INVALIDDATA;
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");
304 return AVERROR_INVALIDDATA;
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);
310 return AVERROR_INVALIDDATA;
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);
377 return AVERROR_INVALIDDATA;
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");
384 return AVERROR_INVALIDDATA;
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",
397 return AVERROR_INVALIDDATA;
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");
403 return AVERROR_INVALIDDATA;
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);
412 return AVERROR_INVALIDDATA;
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");
418 return AVERROR_INVALIDDATA;
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);
457 return AVERROR_INVALIDDATA;
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");
531 return AVERROR_INVALIDDATA;
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);
539 return AVERROR_INVALIDDATA;
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",
555 return AVERROR_INVALIDDATA;
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",
561 return AVERROR_INVALIDDATA;
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");
573 return AVERROR_INVALIDDATA;
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");
601 return AVERROR_INVALIDDATA;
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);
610 return AVERROR_INVALIDDATA;
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]);
623 return AVERROR_INVALIDDATA;
625 if (frac_bits > 14) {
626 av_log(m->avctx, AV_LOG_ERROR,
627 "Too many fractional bits specified.\n");
628 return AVERROR_INVALIDDATA;
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];
663 if (s->param_presence_flags & PARAM_FIR)
665 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
668 if (s->param_presence_flags & PARAM_IIR)
670 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
673 if (fir->order + iir->order > 8) {
674 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
675 return AVERROR_INVALIDDATA;
678 if (fir->order && iir->order &&
679 fir->shift != iir->shift) {
680 av_log(m->avctx, AV_LOG_ERROR,
681 "FIR and IIR filters must use the same precision.\n");
682 return AVERROR_INVALIDDATA;
684 /* The FIR and IIR filters must have the same precision.
685 * To simplify the filtering code, only the precision of the
686 * FIR filter is considered. If only the IIR filter is employed,
687 * the FIR filter precision is set to that of the IIR filter, so
688 * that the filtering code can use it. */
689 if (!fir->order && iir->order)
690 fir->shift = iir->shift;
692 if (s->param_presence_flags & PARAM_HUFFOFFSET)
694 cp->huff_offset = get_sbits(gbp, 15);
696 cp->codebook = get_bits(gbp, 2);
697 cp->huff_lsbs = get_bits(gbp, 5);
699 if (cp->huff_lsbs > 24) {
700 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
701 return AVERROR_INVALIDDATA;
704 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
709 /** Read decoding parameters that change more often than those in the restart
712 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
715 SubStream *s = &m->substream[substr];
719 if (s->param_presence_flags & PARAM_PRESENCE)
721 s->param_presence_flags = get_bits(gbp, 8);
723 if (s->param_presence_flags & PARAM_BLOCKSIZE)
724 if (get_bits1(gbp)) {
725 s->blocksize = get_bits(gbp, 9);
726 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
727 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
729 return AVERROR_INVALIDDATA;
733 if (s->param_presence_flags & PARAM_MATRIX)
735 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
738 if (s->param_presence_flags & PARAM_OUTSHIFT)
740 for (ch = 0; ch <= s->max_matrix_channel; ch++)
741 s->output_shift[ch] = get_sbits(gbp, 4);
743 if (s->param_presence_flags & PARAM_QUANTSTEP)
745 for (ch = 0; ch <= s->max_channel; ch++) {
746 ChannelParams *cp = &s->channel_params[ch];
748 s->quant_step_size[ch] = get_bits(gbp, 4);
750 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
753 for (ch = s->min_channel; ch <= s->max_channel; ch++)
755 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
761 #define MSB_MASK(bits) (-1u << bits)
763 /** Generate PCM samples using the prediction filters and residual values
764 * read from the data stream, and update the filter state. */
766 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
767 unsigned int channel)
769 SubStream *s = &m->substream[substr];
770 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
771 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
772 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
773 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
774 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
775 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
776 unsigned int filter_shift = fir->shift;
777 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
779 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
780 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
782 m->dsp.mlp_filter_channel(firbuf, fircoeff,
783 fir->order, iir->order,
784 filter_shift, mask, s->blocksize,
785 &m->sample_buffer[s->blockpos][channel]);
787 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
788 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
791 /** Read a block of PCM residual data (or actual if no filtering active). */
793 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
796 SubStream *s = &m->substream[substr];
797 unsigned int i, ch, expected_stream_pos = 0;
800 if (s->data_check_present) {
801 expected_stream_pos = get_bits_count(gbp);
802 expected_stream_pos += get_bits(gbp, 16);
803 av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
804 "we have not tested yet. %s\n", sample_message);
807 if (s->blockpos + s->blocksize > m->access_unit_size) {
808 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
809 return AVERROR_INVALIDDATA;
812 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
813 s->blocksize * sizeof(m->bypassed_lsbs[0]));
815 for (i = 0; i < s->blocksize; i++)
816 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
819 for (ch = s->min_channel; ch <= s->max_channel; ch++)
820 filter_channel(m, substr, ch);
822 s->blockpos += s->blocksize;
824 if (s->data_check_present) {
825 if (get_bits_count(gbp) != expected_stream_pos)
826 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
833 /** Data table used for TrueHD noise generation function. */
835 static const int8_t noise_table[256] = {
836 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
837 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
838 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
839 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
840 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
841 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
842 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
843 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
844 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
845 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
846 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
847 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
848 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
849 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
850 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
851 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
854 /** Noise generation functions.
855 * I'm not sure what these are for - they seem to be some kind of pseudorandom
856 * sequence generators, used to generate noise data which is used when the
857 * channels are rematrixed. I'm not sure if they provide a practical benefit
858 * to compression, or just obfuscate the decoder. Are they for some kind of
861 /** Generate two channels of noise, used in the matrix when
862 * restart sync word == 0x31ea. */
864 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
866 SubStream *s = &m->substream[substr];
868 uint32_t seed = s->noisegen_seed;
869 unsigned int maxchan = s->max_matrix_channel;
871 for (i = 0; i < s->blockpos; i++) {
872 uint16_t seed_shr7 = seed >> 7;
873 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
874 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
876 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
879 s->noisegen_seed = seed;
882 /** Generate a block of noise, used when restart sync word == 0x31eb. */
884 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
886 SubStream *s = &m->substream[substr];
888 uint32_t seed = s->noisegen_seed;
890 for (i = 0; i < m->access_unit_size_pow2; i++) {
891 uint8_t seed_shr15 = seed >> 15;
892 m->noise_buffer[i] = noise_table[seed_shr15];
893 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
896 s->noisegen_seed = seed;
900 /** Apply the channel matrices in turn to reconstruct the original audio
903 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
905 SubStream *s = &m->substream[substr];
906 unsigned int mat, src_ch, i;
907 unsigned int maxchan;
909 maxchan = s->max_matrix_channel;
910 if (!s->noise_type) {
911 generate_2_noise_channels(m, substr);
914 fill_noise_buffer(m, substr);
917 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
918 int matrix_noise_shift = s->matrix_noise_shift[mat];
919 unsigned int dest_ch = s->matrix_out_ch[mat];
920 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
921 int32_t *coeffs = s->matrix_coeff[mat];
922 int index = s->num_primitive_matrices - mat;
923 int index2 = 2 * index + 1;
925 /* TODO: DSPContext? */
927 for (i = 0; i < s->blockpos; i++) {
928 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
929 int32_t *samples = m->sample_buffer[i];
932 for (src_ch = 0; src_ch <= maxchan; src_ch++)
933 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
935 if (matrix_noise_shift) {
936 index &= m->access_unit_size_pow2 - 1;
937 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
941 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
946 /** Write the audio data into the output buffer. */
948 static int output_data(MLPDecodeContext *m, unsigned int substr,
949 uint8_t *data, unsigned int *data_size)
951 SubStream *s = &m->substream[substr];
952 unsigned int i, out_ch = 0;
954 int32_t *data_32 = (int32_t*) data;
955 int16_t *data_16 = (int16_t*) data;
956 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
958 if (m->avctx->channels != s->max_matrix_channel + 1) {
959 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
960 return AVERROR_INVALIDDATA;
963 out_size = s->blockpos * m->avctx->channels *
964 av_get_bytes_per_sample(m->avctx->sample_fmt);
966 if (*data_size < out_size)
967 return AVERROR(EINVAL);
969 for (i = 0; i < s->blockpos; i++) {
970 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
971 int mat_ch = s->ch_assign[out_ch];
972 int32_t sample = m->sample_buffer[i][mat_ch]
973 << s->output_shift[mat_ch];
974 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
975 if (is32) *data_32++ = sample << 8;
976 else *data_16++ = sample >> 8;
980 *data_size = out_size;
985 /** Read an access unit from the stream.
986 * @return negative on error, 0 if not enough data is present in the input stream,
987 * otherwise the number of bytes consumed. */
989 static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
992 const uint8_t *buf = avpkt->data;
993 int buf_size = avpkt->size;
994 MLPDecodeContext *m = avctx->priv_data;
996 unsigned int length, substr;
997 unsigned int substream_start;
998 unsigned int header_size = 4;
999 unsigned int substr_header_size = 0;
1000 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1001 uint16_t substream_data_len[MAX_SUBSTREAMS];
1002 uint8_t parity_bits;
1008 length = (AV_RB16(buf) & 0xfff) * 2;
1010 if (length < 4 || length > buf_size)
1011 return AVERROR_INVALIDDATA;
1013 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1015 m->is_major_sync_unit = 0;
1016 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1017 if (read_major_sync(m, &gb) < 0)
1019 m->is_major_sync_unit = 1;
1023 if (!m->params_valid) {
1024 av_log(m->avctx, AV_LOG_WARNING,
1025 "Stream parameters not seen; skipping frame.\n");
1030 substream_start = 0;
1032 for (substr = 0; substr < m->num_substreams; substr++) {
1033 int extraword_present, checkdata_present, end, nonrestart_substr;
1035 extraword_present = get_bits1(&gb);
1036 nonrestart_substr = get_bits1(&gb);
1037 checkdata_present = get_bits1(&gb);
1040 end = get_bits(&gb, 12) * 2;
1042 substr_header_size += 2;
1044 if (extraword_present) {
1045 if (m->avctx->codec_id == CODEC_ID_MLP) {
1046 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1050 substr_header_size += 2;
1053 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1054 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1058 if (end + header_size + substr_header_size > length) {
1059 av_log(m->avctx, AV_LOG_ERROR,
1060 "Indicated length of substream %d data goes off end of "
1061 "packet.\n", substr);
1062 end = length - header_size - substr_header_size;
1065 if (end < substream_start) {
1066 av_log(avctx, AV_LOG_ERROR,
1067 "Indicated end offset of substream %d data "
1068 "is smaller than calculated start offset.\n",
1073 if (substr > m->max_decoded_substream)
1076 substream_parity_present[substr] = checkdata_present;
1077 substream_data_len[substr] = end - substream_start;
1078 substream_start = end;
1081 parity_bits = ff_mlp_calculate_parity(buf, 4);
1082 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1084 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1085 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1089 buf += header_size + substr_header_size;
1091 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1092 SubStream *s = &m->substream[substr];
1093 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1095 m->matrix_changed = 0;
1096 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1100 if (get_bits1(&gb)) {
1101 if (get_bits1(&gb)) {
1102 /* A restart header should be present. */
1103 if (read_restart_header(m, &gb, buf, substr) < 0)
1105 s->restart_seen = 1;
1108 if (!s->restart_seen)
1110 if (read_decoding_params(m, &gb, substr) < 0)
1114 if (!s->restart_seen)
1117 if ((ret = read_block_data(m, &gb, substr)) < 0)
1120 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1121 goto substream_length_mismatch;
1123 } while (!get_bits1(&gb));
1125 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1127 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1130 if (get_bits(&gb, 16) != 0xD234)
1131 return AVERROR_INVALIDDATA;
1133 shorten_by = get_bits(&gb, 16);
1134 if (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by & 0x2000)
1135 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1136 else if (m->avctx->codec_id == CODEC_ID_MLP && shorten_by != 0xD234)
1137 return AVERROR_INVALIDDATA;
1139 if (substr == m->max_decoded_substream)
1140 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1143 if (substream_parity_present[substr]) {
1144 uint8_t parity, checksum;
1146 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1147 goto substream_length_mismatch;
1149 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1150 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1152 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1153 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1154 if ( get_bits(&gb, 8) != checksum)
1155 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1158 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1159 goto substream_length_mismatch;
1162 if (!s->restart_seen)
1163 av_log(m->avctx, AV_LOG_ERROR,
1164 "No restart header present in substream %d.\n", substr);
1166 buf += substream_data_len[substr];
1169 rematrix_channels(m, m->max_decoded_substream);
1171 if ((ret = output_data(m, m->max_decoded_substream, data, data_size)) < 0)
1176 substream_length_mismatch:
1177 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1178 return AVERROR_INVALIDDATA;
1181 m->params_valid = 0;
1182 return AVERROR_INVALIDDATA;
1185 AVCodec ff_mlp_decoder = {
1187 .type = AVMEDIA_TYPE_AUDIO,
1189 .priv_data_size = sizeof(MLPDecodeContext),
1190 .init = mlp_decode_init,
1191 .decode = read_access_unit,
1192 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1195 #if CONFIG_TRUEHD_DECODER
1196 AVCodec ff_truehd_decoder = {
1198 .type = AVMEDIA_TYPE_AUDIO,
1199 .id = CODEC_ID_TRUEHD,
1200 .priv_data_size = sizeof(MLPDecodeContext),
1201 .init = mlp_decode_init,
1202 .decode = read_access_unit,
1203 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1205 #endif /* CONFIG_TRUEHD_DECODER */