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;
125 /// Current access unit being read has a major sync.
126 int is_major_sync_unit;
128 /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
129 uint8_t params_valid;
131 /// Number of substreams contained within this stream.
132 uint8_t num_substreams;
134 /// Index of the last substream to decode - further substreams are skipped.
135 uint8_t max_decoded_substream;
137 /// Stream needs channel reordering to comply with FFmpeg's channel order
138 uint8_t needs_reordering;
140 /// number of PCM samples contained in each frame
141 int access_unit_size;
142 /// next power of two above the number of samples in each frame
143 int access_unit_size_pow2;
145 SubStream substream[MAX_SUBSTREAMS];
148 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
150 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
151 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
152 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
157 static VLC huff_vlc[3];
159 /** Initialize static data, constant between all invocations of the codec. */
161 static av_cold void init_static(void)
163 if (!huff_vlc[0].bits) {
164 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
165 &ff_mlp_huffman_tables[0][0][1], 2, 1,
166 &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
167 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
168 &ff_mlp_huffman_tables[1][0][1], 2, 1,
169 &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
170 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
171 &ff_mlp_huffman_tables[2][0][1], 2, 1,
172 &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
178 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
179 unsigned int substr, unsigned int ch)
181 SubStream *s = &m->substream[substr];
182 ChannelParams *cp = &s->channel_params[ch];
183 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
184 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
185 int32_t sign_huff_offset = cp->huff_offset;
187 if (cp->codebook > 0)
188 sign_huff_offset -= 7 << lsb_bits;
191 sign_huff_offset -= 1 << sign_shift;
193 return sign_huff_offset;
196 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
199 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
200 unsigned int substr, unsigned int pos)
202 SubStream *s = &m->substream[substr];
203 unsigned int mat, channel;
205 for (mat = 0; mat < s->num_primitive_matrices; mat++)
206 if (s->lsb_bypass[mat])
207 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
209 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
210 ChannelParams *cp = &s->channel_params[channel];
211 int codebook = cp->codebook;
212 int quant_step_size = s->quant_step_size[channel];
213 int lsb_bits = cp->huff_lsbs - quant_step_size;
217 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
218 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
221 return AVERROR_INVALIDDATA;
224 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
226 result += cp->sign_huff_offset;
227 result <<= quant_step_size;
229 m->sample_buffer[pos + s->blockpos][channel] = result;
235 static av_cold int mlp_decode_init(AVCodecContext *avctx)
237 MLPDecodeContext *m = avctx->priv_data;
242 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
243 m->substream[substr].lossless_check_data = 0xffffffff;
244 dsputil_init(&m->dsp, avctx);
246 avcodec_get_frame_defaults(&m->frame);
247 avctx->coded_frame = &m->frame;
252 /** Read a major sync info header - contains high level information about
253 * the stream - sample rate, channel arrangement etc. Most of this
254 * information is not actually necessary for decoding, only for playback.
257 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
262 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
265 if (mh.group1_bits == 0) {
266 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
267 return AVERROR_INVALIDDATA;
269 if (mh.group2_bits > mh.group1_bits) {
270 av_log(m->avctx, AV_LOG_ERROR,
271 "Channel group 2 cannot have more bits per sample than group 1.\n");
272 return AVERROR_INVALIDDATA;
275 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
276 av_log(m->avctx, AV_LOG_ERROR,
277 "Channel groups with differing sample rates are not currently supported.\n");
278 return AVERROR_INVALIDDATA;
281 if (mh.group1_samplerate == 0) {
282 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
283 return AVERROR_INVALIDDATA;
285 if (mh.group1_samplerate > MAX_SAMPLERATE) {
286 av_log(m->avctx, AV_LOG_ERROR,
287 "Sampling rate %d is greater than the supported maximum (%d).\n",
288 mh.group1_samplerate, MAX_SAMPLERATE);
289 return AVERROR_INVALIDDATA;
291 if (mh.access_unit_size > MAX_BLOCKSIZE) {
292 av_log(m->avctx, AV_LOG_ERROR,
293 "Block size %d is greater than the supported maximum (%d).\n",
294 mh.access_unit_size, MAX_BLOCKSIZE);
295 return AVERROR_INVALIDDATA;
297 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
298 av_log(m->avctx, AV_LOG_ERROR,
299 "Block size pow2 %d is greater than the supported maximum (%d).\n",
300 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
301 return AVERROR_INVALIDDATA;
304 if (mh.num_substreams == 0)
305 return AVERROR_INVALIDDATA;
306 if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
307 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
308 return AVERROR_INVALIDDATA;
310 if (mh.num_substreams > MAX_SUBSTREAMS) {
311 av_log(m->avctx, AV_LOG_ERROR,
312 "Number of substreams %d is larger than the maximum supported "
313 "by the decoder. %s\n", mh.num_substreams, sample_message);
314 return AVERROR_INVALIDDATA;
317 m->access_unit_size = mh.access_unit_size;
318 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
320 m->num_substreams = mh.num_substreams;
321 m->max_decoded_substream = m->num_substreams - 1;
323 m->avctx->sample_rate = mh.group1_samplerate;
324 m->avctx->frame_size = mh.access_unit_size;
326 m->avctx->bits_per_raw_sample = mh.group1_bits;
327 if (mh.group1_bits > 16)
328 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
330 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
333 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
334 m->substream[substr].restart_seen = 0;
336 if (mh.stream_type == 0xbb) {
338 m->avctx->channel_layout = ff_mlp_layout[mh.channels_mlp];
339 } else { /* mh.stream_type == 0xba */
341 if (mh.channels_thd_stream2) {
342 m->avctx->channel_layout = ff_truehd_layout(mh.channels_thd_stream2);
344 m->avctx->channel_layout = ff_truehd_layout(mh.channels_thd_stream1);
346 if (m->avctx->channels &&
347 !m->avctx->request_channels && !m->avctx->request_channel_layout &&
348 av_get_channel_layout_nb_channels(m->avctx->channel_layout) != m->avctx->channels) {
349 m->avctx->channel_layout = 0;
350 av_log_ask_for_sample(m->avctx, "Unknown channel layout.");
354 m->needs_reordering = mh.channels_mlp >= 18 && mh.channels_mlp <= 20;
359 /** Read a restart header from a block in a substream. This contains parameters
360 * required to decode the audio that do not change very often. Generally
361 * (always) present only in blocks following a major sync. */
363 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
364 const uint8_t *buf, unsigned int substr)
366 SubStream *s = &m->substream[substr];
370 uint8_t lossless_check;
371 int start_count = get_bits_count(gbp);
372 const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP
373 ? MAX_MATRIX_CHANNEL_MLP
374 : MAX_MATRIX_CHANNEL_TRUEHD;
376 sync_word = get_bits(gbp, 13);
378 if (sync_word != 0x31ea >> 1) {
379 av_log(m->avctx, AV_LOG_ERROR,
380 "restart header sync incorrect (got 0x%04x)\n", sync_word);
381 return AVERROR_INVALIDDATA;
384 s->noise_type = get_bits1(gbp);
386 if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) {
387 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
388 return AVERROR_INVALIDDATA;
391 skip_bits(gbp, 16); /* Output timestamp */
393 s->min_channel = get_bits(gbp, 4);
394 s->max_channel = get_bits(gbp, 4);
395 s->max_matrix_channel = get_bits(gbp, 4);
397 if (s->max_matrix_channel > max_matrix_channel) {
398 av_log(m->avctx, AV_LOG_ERROR,
399 "Max matrix channel cannot be greater than %d.\n",
401 return AVERROR_INVALIDDATA;
404 if (s->max_channel != s->max_matrix_channel) {
405 av_log(m->avctx, AV_LOG_ERROR,
406 "Max channel must be equal max matrix channel.\n");
407 return AVERROR_INVALIDDATA;
410 /* This should happen for TrueHD streams with >6 channels and MLP's noise
411 * type. It is not yet known if this is allowed. */
412 if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
413 av_log(m->avctx, AV_LOG_ERROR,
414 "Number of channels %d is larger than the maximum supported "
415 "by the decoder. %s\n", s->max_channel+2, sample_message);
416 return AVERROR_INVALIDDATA;
419 if (s->min_channel > s->max_channel) {
420 av_log(m->avctx, AV_LOG_ERROR,
421 "Substream min channel cannot be greater than max channel.\n");
422 return AVERROR_INVALIDDATA;
425 if (m->avctx->request_channels > 0
426 && s->max_channel + 1 >= m->avctx->request_channels
427 && substr < m->max_decoded_substream) {
428 av_log(m->avctx, AV_LOG_DEBUG,
429 "Extracting %d channel downmix from substream %d. "
430 "Further substreams will be skipped.\n",
431 s->max_channel + 1, substr);
432 m->max_decoded_substream = substr;
435 s->noise_shift = get_bits(gbp, 4);
436 s->noisegen_seed = get_bits(gbp, 23);
440 s->data_check_present = get_bits1(gbp);
441 lossless_check = get_bits(gbp, 8);
442 if (substr == m->max_decoded_substream
443 && s->lossless_check_data != 0xffffffff) {
444 tmp = xor_32_to_8(s->lossless_check_data);
445 if (tmp != lossless_check)
446 av_log(m->avctx, AV_LOG_WARNING,
447 "Lossless check failed - expected %02x, calculated %02x.\n",
448 lossless_check, tmp);
453 memset(s->ch_assign, 0, sizeof(s->ch_assign));
455 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
456 int ch_assign = get_bits(gbp, 6);
457 if (ch_assign > s->max_matrix_channel) {
458 av_log(m->avctx, AV_LOG_ERROR,
459 "Assignment of matrix channel %d to invalid output channel %d. %s\n",
460 ch, ch_assign, sample_message);
461 return AVERROR_INVALIDDATA;
463 s->ch_assign[ch_assign] = ch;
466 if (m->avctx->codec_id == CODEC_ID_MLP && m->needs_reordering) {
467 if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
468 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
469 int i = s->ch_assign[4];
470 s->ch_assign[4] = s->ch_assign[3];
471 s->ch_assign[3] = s->ch_assign[2];
473 } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
474 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
475 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
478 if (m->avctx->codec_id == CODEC_ID_TRUEHD &&
479 m->avctx->channel_layout == AV_CH_LAYOUT_7POINT1) {
480 FFSWAP(int, s->ch_assign[4], s->ch_assign[6]);
481 FFSWAP(int, s->ch_assign[5], s->ch_assign[7]);
484 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
486 if (checksum != get_bits(gbp, 8))
487 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
489 /* Set default decoding parameters. */
490 s->param_presence_flags = 0xff;
491 s->num_primitive_matrices = 0;
493 s->lossless_check_data = 0;
495 memset(s->output_shift , 0, sizeof(s->output_shift ));
496 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
498 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
499 ChannelParams *cp = &s->channel_params[ch];
500 cp->filter_params[FIR].order = 0;
501 cp->filter_params[IIR].order = 0;
502 cp->filter_params[FIR].shift = 0;
503 cp->filter_params[IIR].shift = 0;
505 /* Default audio coding is 24-bit raw PCM. */
507 cp->sign_huff_offset = (-1) << 23;
512 if (substr == m->max_decoded_substream)
513 m->avctx->channels = s->max_matrix_channel + 1;
518 /** Read parameters for one of the prediction filters. */
520 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
521 unsigned int substr, unsigned int channel,
524 SubStream *s = &m->substream[substr];
525 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
526 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
527 const char fchar = filter ? 'I' : 'F';
530 // Filter is 0 for FIR, 1 for IIR.
533 if (m->filter_changed[channel][filter]++ > 1) {
534 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
535 return AVERROR_INVALIDDATA;
538 order = get_bits(gbp, 4);
539 if (order > max_order) {
540 av_log(m->avctx, AV_LOG_ERROR,
541 "%cIR filter order %d is greater than maximum %d.\n",
542 fchar, order, max_order);
543 return AVERROR_INVALIDDATA;
548 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
549 int coeff_bits, coeff_shift;
551 fp->shift = get_bits(gbp, 4);
553 coeff_bits = get_bits(gbp, 5);
554 coeff_shift = get_bits(gbp, 3);
555 if (coeff_bits < 1 || coeff_bits > 16) {
556 av_log(m->avctx, AV_LOG_ERROR,
557 "%cIR filter coeff_bits must be between 1 and 16.\n",
559 return AVERROR_INVALIDDATA;
561 if (coeff_bits + coeff_shift > 16) {
562 av_log(m->avctx, AV_LOG_ERROR,
563 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
565 return AVERROR_INVALIDDATA;
568 for (i = 0; i < order; i++)
569 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
571 if (get_bits1(gbp)) {
572 int state_bits, state_shift;
575 av_log(m->avctx, AV_LOG_ERROR,
576 "FIR filter has state data specified.\n");
577 return AVERROR_INVALIDDATA;
580 state_bits = get_bits(gbp, 4);
581 state_shift = get_bits(gbp, 4);
583 /* TODO: Check validity of state data. */
585 for (i = 0; i < order; i++)
586 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
593 /** Read parameters for primitive matrices. */
595 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
597 SubStream *s = &m->substream[substr];
598 unsigned int mat, ch;
599 const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
601 : MAX_MATRICES_TRUEHD;
603 if (m->matrix_changed++ > 1) {
604 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
605 return AVERROR_INVALIDDATA;
608 s->num_primitive_matrices = get_bits(gbp, 4);
610 if (s->num_primitive_matrices > max_primitive_matrices) {
611 av_log(m->avctx, AV_LOG_ERROR,
612 "Number of primitive matrices cannot be greater than %d.\n",
613 max_primitive_matrices);
614 return AVERROR_INVALIDDATA;
617 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
618 int frac_bits, max_chan;
619 s->matrix_out_ch[mat] = get_bits(gbp, 4);
620 frac_bits = get_bits(gbp, 4);
621 s->lsb_bypass [mat] = get_bits1(gbp);
623 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
624 av_log(m->avctx, AV_LOG_ERROR,
625 "Invalid channel %d specified as output from matrix.\n",
626 s->matrix_out_ch[mat]);
627 return AVERROR_INVALIDDATA;
629 if (frac_bits > 14) {
630 av_log(m->avctx, AV_LOG_ERROR,
631 "Too many fractional bits specified.\n");
632 return AVERROR_INVALIDDATA;
635 max_chan = s->max_matrix_channel;
639 for (ch = 0; ch <= max_chan; ch++) {
642 coeff_val = get_sbits(gbp, frac_bits + 2);
644 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
648 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
650 s->matrix_noise_shift[mat] = 0;
656 /** Read channel parameters. */
658 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
659 GetBitContext *gbp, unsigned int ch)
661 SubStream *s = &m->substream[substr];
662 ChannelParams *cp = &s->channel_params[ch];
663 FilterParams *fir = &cp->filter_params[FIR];
664 FilterParams *iir = &cp->filter_params[IIR];
667 if (s->param_presence_flags & PARAM_FIR)
669 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
672 if (s->param_presence_flags & PARAM_IIR)
674 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
677 if (fir->order + iir->order > 8) {
678 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
679 return AVERROR_INVALIDDATA;
682 if (fir->order && iir->order &&
683 fir->shift != iir->shift) {
684 av_log(m->avctx, AV_LOG_ERROR,
685 "FIR and IIR filters must use the same precision.\n");
686 return AVERROR_INVALIDDATA;
688 /* The FIR and IIR filters must have the same precision.
689 * To simplify the filtering code, only the precision of the
690 * FIR filter is considered. If only the IIR filter is employed,
691 * the FIR filter precision is set to that of the IIR filter, so
692 * that the filtering code can use it. */
693 if (!fir->order && iir->order)
694 fir->shift = iir->shift;
696 if (s->param_presence_flags & PARAM_HUFFOFFSET)
698 cp->huff_offset = get_sbits(gbp, 15);
700 cp->codebook = get_bits(gbp, 2);
701 cp->huff_lsbs = get_bits(gbp, 5);
703 if (cp->huff_lsbs > 24) {
704 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
705 return AVERROR_INVALIDDATA;
708 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
713 /** Read decoding parameters that change more often than those in the restart
716 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
719 SubStream *s = &m->substream[substr];
723 if (s->param_presence_flags & PARAM_PRESENCE)
725 s->param_presence_flags = get_bits(gbp, 8);
727 if (s->param_presence_flags & PARAM_BLOCKSIZE)
728 if (get_bits1(gbp)) {
729 s->blocksize = get_bits(gbp, 9);
730 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
731 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
733 return AVERROR_INVALIDDATA;
737 if (s->param_presence_flags & PARAM_MATRIX)
739 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
742 if (s->param_presence_flags & PARAM_OUTSHIFT)
744 for (ch = 0; ch <= s->max_matrix_channel; ch++)
745 s->output_shift[ch] = get_sbits(gbp, 4);
747 if (s->param_presence_flags & PARAM_QUANTSTEP)
749 for (ch = 0; ch <= s->max_channel; ch++) {
750 ChannelParams *cp = &s->channel_params[ch];
752 s->quant_step_size[ch] = get_bits(gbp, 4);
754 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
757 for (ch = s->min_channel; ch <= s->max_channel; ch++)
759 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
765 #define MSB_MASK(bits) (-1u << bits)
767 /** Generate PCM samples using the prediction filters and residual values
768 * read from the data stream, and update the filter state. */
770 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
771 unsigned int channel)
773 SubStream *s = &m->substream[substr];
774 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
775 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
776 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
777 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
778 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
779 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
780 unsigned int filter_shift = fir->shift;
781 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
783 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
784 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
786 m->dsp.mlp_filter_channel(firbuf, fircoeff,
787 fir->order, iir->order,
788 filter_shift, mask, s->blocksize,
789 &m->sample_buffer[s->blockpos][channel]);
791 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
792 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
795 /** Read a block of PCM residual data (or actual if no filtering active). */
797 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
800 SubStream *s = &m->substream[substr];
801 unsigned int i, ch, expected_stream_pos = 0;
804 if (s->data_check_present) {
805 expected_stream_pos = get_bits_count(gbp);
806 expected_stream_pos += get_bits(gbp, 16);
807 av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
808 "we have not tested yet. %s\n", sample_message);
811 if (s->blockpos + s->blocksize > m->access_unit_size) {
812 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
813 return AVERROR_INVALIDDATA;
816 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
817 s->blocksize * sizeof(m->bypassed_lsbs[0]));
819 for (i = 0; i < s->blocksize; i++)
820 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
823 for (ch = s->min_channel; ch <= s->max_channel; ch++)
824 filter_channel(m, substr, ch);
826 s->blockpos += s->blocksize;
828 if (s->data_check_present) {
829 if (get_bits_count(gbp) != expected_stream_pos)
830 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
837 /** Data table used for TrueHD noise generation function. */
839 static const int8_t noise_table[256] = {
840 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
841 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
842 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
843 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
844 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
845 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
846 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
847 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
848 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
849 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
850 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
851 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
852 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
853 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
854 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
855 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
858 /** Noise generation functions.
859 * I'm not sure what these are for - they seem to be some kind of pseudorandom
860 * sequence generators, used to generate noise data which is used when the
861 * channels are rematrixed. I'm not sure if they provide a practical benefit
862 * to compression, or just obfuscate the decoder. Are they for some kind of
865 /** Generate two channels of noise, used in the matrix when
866 * restart sync word == 0x31ea. */
868 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
870 SubStream *s = &m->substream[substr];
872 uint32_t seed = s->noisegen_seed;
873 unsigned int maxchan = s->max_matrix_channel;
875 for (i = 0; i < s->blockpos; i++) {
876 uint16_t seed_shr7 = seed >> 7;
877 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
878 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
880 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
883 s->noisegen_seed = seed;
886 /** Generate a block of noise, used when restart sync word == 0x31eb. */
888 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
890 SubStream *s = &m->substream[substr];
892 uint32_t seed = s->noisegen_seed;
894 for (i = 0; i < m->access_unit_size_pow2; i++) {
895 uint8_t seed_shr15 = seed >> 15;
896 m->noise_buffer[i] = noise_table[seed_shr15];
897 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
900 s->noisegen_seed = seed;
904 /** Apply the channel matrices in turn to reconstruct the original audio
907 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
909 SubStream *s = &m->substream[substr];
910 unsigned int mat, src_ch, i;
911 unsigned int maxchan;
913 maxchan = s->max_matrix_channel;
914 if (!s->noise_type) {
915 generate_2_noise_channels(m, substr);
918 fill_noise_buffer(m, substr);
921 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
922 int matrix_noise_shift = s->matrix_noise_shift[mat];
923 unsigned int dest_ch = s->matrix_out_ch[mat];
924 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
925 int32_t *coeffs = s->matrix_coeff[mat];
926 int index = s->num_primitive_matrices - mat;
927 int index2 = 2 * index + 1;
929 /* TODO: DSPContext? */
931 for (i = 0; i < s->blockpos; i++) {
932 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
933 int32_t *samples = m->sample_buffer[i];
936 for (src_ch = 0; src_ch <= maxchan; src_ch++)
937 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
939 if (matrix_noise_shift) {
940 index &= m->access_unit_size_pow2 - 1;
941 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
945 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
950 /** Write the audio data into the output buffer. */
952 static int output_data(MLPDecodeContext *m, unsigned int substr,
953 void *data, int *got_frame_ptr)
955 AVCodecContext *avctx = m->avctx;
956 SubStream *s = &m->substream[substr];
957 unsigned int i, out_ch = 0;
961 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
963 if (m->avctx->channels != s->max_matrix_channel + 1) {
964 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
965 return AVERROR_INVALIDDATA;
968 /* get output buffer */
969 m->frame.nb_samples = s->blockpos;
970 if ((ret = avctx->get_buffer(avctx, &m->frame)) < 0) {
971 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
974 data_32 = (int32_t *)m->frame.data[0];
975 data_16 = (int16_t *)m->frame.data[0];
977 for (i = 0; i < s->blockpos; i++) {
978 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
979 int mat_ch = s->ch_assign[out_ch];
980 int32_t sample = m->sample_buffer[i][mat_ch]
981 << s->output_shift[mat_ch];
982 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
983 if (is32) *data_32++ = sample << 8;
984 else *data_16++ = sample >> 8;
989 *(AVFrame *)data = m->frame;
994 /** Read an access unit from the stream.
995 * @return negative on error, 0 if not enough data is present in the input stream,
996 * otherwise the number of bytes consumed. */
998 static int read_access_unit(AVCodecContext *avctx, void* data,
999 int *got_frame_ptr, AVPacket *avpkt)
1001 const uint8_t *buf = avpkt->data;
1002 int buf_size = avpkt->size;
1003 MLPDecodeContext *m = avctx->priv_data;
1005 unsigned int length, substr;
1006 unsigned int substream_start;
1007 unsigned int header_size = 4;
1008 unsigned int substr_header_size = 0;
1009 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1010 uint16_t substream_data_len[MAX_SUBSTREAMS];
1011 uint8_t parity_bits;
1017 length = (AV_RB16(buf) & 0xfff) * 2;
1019 if (length < 4 || length > buf_size)
1020 return AVERROR_INVALIDDATA;
1022 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1024 m->is_major_sync_unit = 0;
1025 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1026 if (read_major_sync(m, &gb) < 0)
1028 m->is_major_sync_unit = 1;
1032 if (!m->params_valid) {
1033 av_log(m->avctx, AV_LOG_WARNING,
1034 "Stream parameters not seen; skipping frame.\n");
1039 substream_start = 0;
1041 for (substr = 0; substr < m->num_substreams; substr++) {
1042 int extraword_present, checkdata_present, end, nonrestart_substr;
1044 extraword_present = get_bits1(&gb);
1045 nonrestart_substr = get_bits1(&gb);
1046 checkdata_present = get_bits1(&gb);
1049 end = get_bits(&gb, 12) * 2;
1051 substr_header_size += 2;
1053 if (extraword_present) {
1054 if (m->avctx->codec_id == CODEC_ID_MLP) {
1055 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1059 substr_header_size += 2;
1062 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1063 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1067 if (end + header_size + substr_header_size > length) {
1068 av_log(m->avctx, AV_LOG_ERROR,
1069 "Indicated length of substream %d data goes off end of "
1070 "packet.\n", substr);
1071 end = length - header_size - substr_header_size;
1074 if (end < substream_start) {
1075 av_log(avctx, AV_LOG_ERROR,
1076 "Indicated end offset of substream %d data "
1077 "is smaller than calculated start offset.\n",
1082 if (substr > m->max_decoded_substream)
1085 substream_parity_present[substr] = checkdata_present;
1086 substream_data_len[substr] = end - substream_start;
1087 substream_start = end;
1090 parity_bits = ff_mlp_calculate_parity(buf, 4);
1091 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1093 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1094 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1098 buf += header_size + substr_header_size;
1100 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1101 SubStream *s = &m->substream[substr];
1102 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1104 m->matrix_changed = 0;
1105 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1109 if (get_bits1(&gb)) {
1110 if (get_bits1(&gb)) {
1111 /* A restart header should be present. */
1112 if (read_restart_header(m, &gb, buf, substr) < 0)
1114 s->restart_seen = 1;
1117 if (!s->restart_seen)
1119 if (read_decoding_params(m, &gb, substr) < 0)
1123 if (!s->restart_seen)
1126 if ((ret = read_block_data(m, &gb, substr)) < 0)
1129 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1130 goto substream_length_mismatch;
1132 } while (!get_bits1(&gb));
1134 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1136 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1139 if (get_bits(&gb, 16) != 0xD234)
1140 return AVERROR_INVALIDDATA;
1142 shorten_by = get_bits(&gb, 16);
1143 if (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by & 0x2000)
1144 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1145 else if (m->avctx->codec_id == CODEC_ID_MLP && shorten_by != 0xD234)
1146 return AVERROR_INVALIDDATA;
1148 if (substr == m->max_decoded_substream)
1149 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1152 if (substream_parity_present[substr]) {
1153 uint8_t parity, checksum;
1155 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1156 goto substream_length_mismatch;
1158 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1159 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1161 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1162 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1163 if ( get_bits(&gb, 8) != checksum)
1164 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1167 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1168 goto substream_length_mismatch;
1171 if (!s->restart_seen)
1172 av_log(m->avctx, AV_LOG_ERROR,
1173 "No restart header present in substream %d.\n", substr);
1175 buf += substream_data_len[substr];
1178 rematrix_channels(m, m->max_decoded_substream);
1180 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1185 substream_length_mismatch:
1186 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1187 return AVERROR_INVALIDDATA;
1190 m->params_valid = 0;
1191 return AVERROR_INVALIDDATA;
1194 AVCodec ff_mlp_decoder = {
1196 .type = AVMEDIA_TYPE_AUDIO,
1198 .priv_data_size = sizeof(MLPDecodeContext),
1199 .init = mlp_decode_init,
1200 .decode = read_access_unit,
1201 .capabilities = CODEC_CAP_DR1,
1202 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1205 #if CONFIG_TRUEHD_DECODER
1206 AVCodec ff_truehd_decoder = {
1208 .type = AVMEDIA_TYPE_AUDIO,
1209 .id = CODEC_ID_TRUEHD,
1210 .priv_data_size = sizeof(MLPDecodeContext),
1211 .init = mlp_decode_init,
1212 .decode = read_access_unit,
1213 .capabilities = CODEC_CAP_DR1,
1214 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1216 #endif /* CONFIG_TRUEHD_DECODER */