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 */
41 typedef struct SubStream {
42 /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
46 /** restart header data */
47 /// The type of noise to be used in the rematrix stage.
50 /// The index of the first channel coded in this substream.
52 /// The index of the last channel coded in this substream.
54 /// The number of channels input into the rematrix stage.
55 uint8_t max_matrix_channel;
56 /// For each channel output by the matrix, the output channel to map it to
57 uint8_t ch_assign[MAX_CHANNELS];
59 /// Channel coding parameters for channels in the substream
60 ChannelParams channel_params[MAX_CHANNELS];
62 /// The left shift applied to random noise in 0x31ea substreams.
64 /// The current seed value for the pseudorandom noise generator(s).
65 uint32_t noisegen_seed;
67 /// Set if the substream contains extra info to check the size of VLC blocks.
68 uint8_t data_check_present;
70 /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
71 uint8_t param_presence_flags;
72 #define PARAM_BLOCKSIZE (1 << 7)
73 #define PARAM_MATRIX (1 << 6)
74 #define PARAM_OUTSHIFT (1 << 5)
75 #define PARAM_QUANTSTEP (1 << 4)
76 #define PARAM_FIR (1 << 3)
77 #define PARAM_IIR (1 << 2)
78 #define PARAM_HUFFOFFSET (1 << 1)
79 #define PARAM_PRESENCE (1 << 0)
85 /// Number of matrices to be applied.
86 uint8_t num_primitive_matrices;
88 /// matrix output channel
89 uint8_t matrix_out_ch[MAX_MATRICES];
91 /// Whether the LSBs of the matrix output are encoded in the bitstream.
92 uint8_t lsb_bypass[MAX_MATRICES];
93 /// Matrix coefficients, stored as 2.14 fixed point.
94 int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
95 /// Left shift to apply to noise values in 0x31eb substreams.
96 uint8_t matrix_noise_shift[MAX_MATRICES];
99 /// Left shift to apply to Huffman-decoded residuals.
100 uint8_t quant_step_size[MAX_CHANNELS];
102 /// number of PCM samples in current audio block
104 /// Number of PCM samples decoded so far in this frame.
107 /// Left shift to apply to decoded PCM values to get final 24-bit output.
108 int8_t output_shift[MAX_CHANNELS];
110 /// Running XOR of all output samples.
111 int32_t lossless_check_data;
115 typedef struct MLPDecodeContext {
116 AVCodecContext *avctx;
119 /// Current access unit being read has a major sync.
120 int is_major_sync_unit;
122 /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
123 uint8_t params_valid;
125 /// Number of substreams contained within this stream.
126 uint8_t num_substreams;
128 /// Index of the last substream to decode - further substreams are skipped.
129 uint8_t max_decoded_substream;
131 /// Stream needs channel reordering to comply with FFmpeg's channel order
132 uint8_t needs_reordering;
134 /// number of PCM samples contained in each frame
135 int access_unit_size;
136 /// next power of two above the number of samples in each frame
137 int access_unit_size_pow2;
139 SubStream substream[MAX_SUBSTREAMS];
142 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
144 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
145 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
146 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
151 static VLC huff_vlc[3];
153 /** Initialize static data, constant between all invocations of the codec. */
155 static av_cold void init_static(void)
157 if (!huff_vlc[0].bits) {
158 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
159 &ff_mlp_huffman_tables[0][0][1], 2, 1,
160 &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
161 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
162 &ff_mlp_huffman_tables[1][0][1], 2, 1,
163 &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
164 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
165 &ff_mlp_huffman_tables[2][0][1], 2, 1,
166 &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
172 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
173 unsigned int substr, unsigned int ch)
175 SubStream *s = &m->substream[substr];
176 ChannelParams *cp = &s->channel_params[ch];
177 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
178 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
179 int32_t sign_huff_offset = cp->huff_offset;
181 if (cp->codebook > 0)
182 sign_huff_offset -= 7 << lsb_bits;
185 sign_huff_offset -= 1 << sign_shift;
187 return sign_huff_offset;
190 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
193 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
194 unsigned int substr, unsigned int pos)
196 SubStream *s = &m->substream[substr];
197 unsigned int mat, channel;
199 for (mat = 0; mat < s->num_primitive_matrices; mat++)
200 if (s->lsb_bypass[mat])
201 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
203 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
204 ChannelParams *cp = &s->channel_params[channel];
205 int codebook = cp->codebook;
206 int quant_step_size = s->quant_step_size[channel];
207 int lsb_bits = cp->huff_lsbs - quant_step_size;
211 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
212 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
215 return AVERROR_INVALIDDATA;
218 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
220 result += cp->sign_huff_offset;
221 result <<= quant_step_size;
223 m->sample_buffer[pos + s->blockpos][channel] = result;
229 static av_cold int mlp_decode_init(AVCodecContext *avctx)
231 MLPDecodeContext *m = avctx->priv_data;
236 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
237 m->substream[substr].lossless_check_data = 0xffffffff;
238 ff_dsputil_init(&m->dsp, avctx);
240 avcodec_get_frame_defaults(&m->frame);
241 avctx->coded_frame = &m->frame;
246 /** Read a major sync info header - contains high level information about
247 * the stream - sample rate, channel arrangement etc. Most of this
248 * information is not actually necessary for decoding, only for playback.
251 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
256 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
259 if (mh.group1_bits == 0) {
260 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
261 return AVERROR_INVALIDDATA;
263 if (mh.group2_bits > mh.group1_bits) {
264 av_log(m->avctx, AV_LOG_ERROR,
265 "Channel group 2 cannot have more bits per sample than group 1.\n");
266 return AVERROR_INVALIDDATA;
269 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
270 av_log(m->avctx, AV_LOG_ERROR,
271 "Channel groups with differing sample rates are not currently supported.\n");
272 return AVERROR_INVALIDDATA;
275 if (mh.group1_samplerate == 0) {
276 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
277 return AVERROR_INVALIDDATA;
279 if (mh.group1_samplerate > MAX_SAMPLERATE) {
280 av_log(m->avctx, AV_LOG_ERROR,
281 "Sampling rate %d is greater than the supported maximum (%d).\n",
282 mh.group1_samplerate, MAX_SAMPLERATE);
283 return AVERROR_INVALIDDATA;
285 if (mh.access_unit_size > MAX_BLOCKSIZE) {
286 av_log(m->avctx, AV_LOG_ERROR,
287 "Block size %d is greater than the supported maximum (%d).\n",
288 mh.access_unit_size, MAX_BLOCKSIZE);
289 return AVERROR_INVALIDDATA;
291 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
292 av_log(m->avctx, AV_LOG_ERROR,
293 "Block size pow2 %d is greater than the supported maximum (%d).\n",
294 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
295 return AVERROR_INVALIDDATA;
298 if (mh.num_substreams == 0)
299 return AVERROR_INVALIDDATA;
300 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
301 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
302 return AVERROR_INVALIDDATA;
304 if (mh.num_substreams > MAX_SUBSTREAMS) {
305 av_log_ask_for_sample(m->avctx,
306 "Number of substreams %d is larger than the maximum supported "
307 "by the decoder.\n", mh.num_substreams);
308 return AVERROR_PATCHWELCOME;
311 m->access_unit_size = mh.access_unit_size;
312 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
314 m->num_substreams = mh.num_substreams;
315 m->max_decoded_substream = m->num_substreams - 1;
317 m->avctx->sample_rate = mh.group1_samplerate;
318 m->avctx->frame_size = mh.access_unit_size;
320 m->avctx->bits_per_raw_sample = mh.group1_bits;
321 if (mh.group1_bits > 16)
322 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
324 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
327 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
328 m->substream[substr].restart_seen = 0;
330 if (mh.stream_type == 0xbb) {
332 m->avctx->channel_layout = ff_mlp_layout[mh.channels_mlp];
333 } else { /* mh.stream_type == 0xba */
335 if (mh.channels_thd_stream2) {
336 m->avctx->channel_layout = ff_truehd_layout(mh.channels_thd_stream2);
338 m->avctx->channel_layout = ff_truehd_layout(mh.channels_thd_stream1);
340 if (m->avctx->channels<=2 && m->avctx->channel_layout == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
341 av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
342 m->max_decoded_substream = 0;
343 if (m->avctx->channels==2)
344 m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
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 == AV_CODEC_ID_MLP
373 ? MAX_MATRIX_CHANNEL_MLP
374 : MAX_MATRIX_CHANNEL_TRUEHD;
375 int max_channel, min_channel, matrix_channel;
377 sync_word = get_bits(gbp, 13);
379 if (sync_word != 0x31ea >> 1) {
380 av_log(m->avctx, AV_LOG_ERROR,
381 "restart header sync incorrect (got 0x%04x)\n", sync_word);
382 return AVERROR_INVALIDDATA;
385 s->noise_type = get_bits1(gbp);
387 if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
388 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
389 return AVERROR_INVALIDDATA;
392 skip_bits(gbp, 16); /* Output timestamp */
394 min_channel = get_bits(gbp, 4);
395 max_channel = get_bits(gbp, 4);
396 matrix_channel = get_bits(gbp, 4);
398 if (matrix_channel > max_matrix_channel) {
399 av_log(m->avctx, AV_LOG_ERROR,
400 "Max matrix channel cannot be greater than %d.\n",
402 return AVERROR_INVALIDDATA;
405 if (max_channel != matrix_channel) {
406 av_log(m->avctx, AV_LOG_ERROR,
407 "Max channel must be equal max matrix channel.\n");
408 return AVERROR_INVALIDDATA;
411 /* This should happen for TrueHD streams with >6 channels and MLP's noise
412 * type. It is not yet known if this is allowed. */
413 if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
414 av_log_ask_for_sample(m->avctx,
415 "Number of channels %d is larger than the maximum supported "
416 "by the decoder.\n", max_channel + 2);
417 return AVERROR_PATCHWELCOME;
420 if (min_channel > max_channel) {
421 av_log(m->avctx, AV_LOG_ERROR,
422 "Substream min channel cannot be greater than max channel.\n");
423 return AVERROR_INVALIDDATA;
426 s->min_channel = min_channel;
427 s->max_channel = max_channel;
428 s->max_matrix_channel = matrix_channel;
430 if (m->avctx->request_channels > 0
431 && s->max_channel + 1 >= m->avctx->request_channels
432 && substr < m->max_decoded_substream) {
433 av_log(m->avctx, AV_LOG_DEBUG,
434 "Extracting %d channel downmix from substream %d. "
435 "Further substreams will be skipped.\n",
436 s->max_channel + 1, substr);
437 m->max_decoded_substream = substr;
440 s->noise_shift = get_bits(gbp, 4);
441 s->noisegen_seed = get_bits(gbp, 23);
445 s->data_check_present = get_bits1(gbp);
446 lossless_check = get_bits(gbp, 8);
447 if (substr == m->max_decoded_substream
448 && s->lossless_check_data != 0xffffffff) {
449 tmp = xor_32_to_8(s->lossless_check_data);
450 if (tmp != lossless_check)
451 av_log(m->avctx, AV_LOG_WARNING,
452 "Lossless check failed - expected %02x, calculated %02x.\n",
453 lossless_check, tmp);
458 memset(s->ch_assign, 0, sizeof(s->ch_assign));
460 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
461 int ch_assign = get_bits(gbp, 6);
462 if (ch_assign > s->max_matrix_channel) {
463 av_log_ask_for_sample(m->avctx,
464 "Assignment of matrix channel %d to invalid output channel %d.\n",
466 return AVERROR_PATCHWELCOME;
468 s->ch_assign[ch_assign] = ch;
471 if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
472 if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
473 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
474 int i = s->ch_assign[4];
475 s->ch_assign[4] = s->ch_assign[3];
476 s->ch_assign[3] = s->ch_assign[2];
478 } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
479 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
480 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
483 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD &&
484 (m->avctx->channel_layout == AV_CH_LAYOUT_7POINT1 ||
485 m->avctx->channel_layout == AV_CH_LAYOUT_7POINT1_WIDE)) {
486 FFSWAP(int, s->ch_assign[4], s->ch_assign[6]);
487 FFSWAP(int, s->ch_assign[5], s->ch_assign[7]);
488 } else if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD &&
489 (m->avctx->channel_layout == AV_CH_LAYOUT_6POINT1 ||
490 m->avctx->channel_layout == (AV_CH_LAYOUT_6POINT1 | AV_CH_TOP_CENTER) ||
491 m->avctx->channel_layout == (AV_CH_LAYOUT_6POINT1 | AV_CH_TOP_FRONT_CENTER))) {
492 int i = s->ch_assign[6];
493 s->ch_assign[6] = s->ch_assign[5];
494 s->ch_assign[5] = s->ch_assign[4];
498 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
500 if (checksum != get_bits(gbp, 8))
501 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
503 /* Set default decoding parameters. */
504 s->param_presence_flags = 0xff;
505 s->num_primitive_matrices = 0;
507 s->lossless_check_data = 0;
509 memset(s->output_shift , 0, sizeof(s->output_shift ));
510 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
512 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
513 ChannelParams *cp = &s->channel_params[ch];
514 cp->filter_params[FIR].order = 0;
515 cp->filter_params[IIR].order = 0;
516 cp->filter_params[FIR].shift = 0;
517 cp->filter_params[IIR].shift = 0;
519 /* Default audio coding is 24-bit raw PCM. */
521 cp->sign_huff_offset = (-1) << 23;
526 if (substr == m->max_decoded_substream)
527 m->avctx->channels = s->max_matrix_channel + 1;
532 /** Read parameters for one of the prediction filters. */
534 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
535 unsigned int substr, unsigned int channel,
538 SubStream *s = &m->substream[substr];
539 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
540 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
541 const char fchar = filter ? 'I' : 'F';
544 // Filter is 0 for FIR, 1 for IIR.
545 av_assert0(filter < 2);
547 if (m->filter_changed[channel][filter]++ > 1) {
548 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
549 return AVERROR_INVALIDDATA;
552 order = get_bits(gbp, 4);
553 if (order > max_order) {
554 av_log(m->avctx, AV_LOG_ERROR,
555 "%cIR filter order %d is greater than maximum %d.\n",
556 fchar, order, max_order);
557 return AVERROR_INVALIDDATA;
562 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
563 int coeff_bits, coeff_shift;
565 fp->shift = get_bits(gbp, 4);
567 coeff_bits = get_bits(gbp, 5);
568 coeff_shift = get_bits(gbp, 3);
569 if (coeff_bits < 1 || coeff_bits > 16) {
570 av_log(m->avctx, AV_LOG_ERROR,
571 "%cIR filter coeff_bits must be between 1 and 16.\n",
573 return AVERROR_INVALIDDATA;
575 if (coeff_bits + coeff_shift > 16) {
576 av_log(m->avctx, AV_LOG_ERROR,
577 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
579 return AVERROR_INVALIDDATA;
582 for (i = 0; i < order; i++)
583 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
585 if (get_bits1(gbp)) {
586 int state_bits, state_shift;
589 av_log(m->avctx, AV_LOG_ERROR,
590 "FIR filter has state data specified.\n");
591 return AVERROR_INVALIDDATA;
594 state_bits = get_bits(gbp, 4);
595 state_shift = get_bits(gbp, 4);
597 /* TODO: Check validity of state data. */
599 for (i = 0; i < order; i++)
600 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
607 /** Read parameters for primitive matrices. */
609 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
611 SubStream *s = &m->substream[substr];
612 unsigned int mat, ch;
613 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
615 : MAX_MATRICES_TRUEHD;
617 if (m->matrix_changed++ > 1) {
618 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
619 return AVERROR_INVALIDDATA;
622 s->num_primitive_matrices = get_bits(gbp, 4);
624 if (s->num_primitive_matrices > max_primitive_matrices) {
625 av_log(m->avctx, AV_LOG_ERROR,
626 "Number of primitive matrices cannot be greater than %d.\n",
627 max_primitive_matrices);
628 return AVERROR_INVALIDDATA;
631 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
632 int frac_bits, max_chan;
633 s->matrix_out_ch[mat] = get_bits(gbp, 4);
634 frac_bits = get_bits(gbp, 4);
635 s->lsb_bypass [mat] = get_bits1(gbp);
637 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
638 av_log(m->avctx, AV_LOG_ERROR,
639 "Invalid channel %d specified as output from matrix.\n",
640 s->matrix_out_ch[mat]);
641 return AVERROR_INVALIDDATA;
643 if (frac_bits > 14) {
644 av_log(m->avctx, AV_LOG_ERROR,
645 "Too many fractional bits specified.\n");
646 return AVERROR_INVALIDDATA;
649 max_chan = s->max_matrix_channel;
653 for (ch = 0; ch <= max_chan; ch++) {
656 coeff_val = get_sbits(gbp, frac_bits + 2);
658 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
662 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
664 s->matrix_noise_shift[mat] = 0;
670 /** Read channel parameters. */
672 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
673 GetBitContext *gbp, unsigned int ch)
675 SubStream *s = &m->substream[substr];
676 ChannelParams *cp = &s->channel_params[ch];
677 FilterParams *fir = &cp->filter_params[FIR];
678 FilterParams *iir = &cp->filter_params[IIR];
681 if (s->param_presence_flags & PARAM_FIR)
683 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
686 if (s->param_presence_flags & PARAM_IIR)
688 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
691 if (fir->order + iir->order > 8) {
692 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
693 return AVERROR_INVALIDDATA;
696 if (fir->order && iir->order &&
697 fir->shift != iir->shift) {
698 av_log(m->avctx, AV_LOG_ERROR,
699 "FIR and IIR filters must use the same precision.\n");
700 return AVERROR_INVALIDDATA;
702 /* The FIR and IIR filters must have the same precision.
703 * To simplify the filtering code, only the precision of the
704 * FIR filter is considered. If only the IIR filter is employed,
705 * the FIR filter precision is set to that of the IIR filter, so
706 * that the filtering code can use it. */
707 if (!fir->order && iir->order)
708 fir->shift = iir->shift;
710 if (s->param_presence_flags & PARAM_HUFFOFFSET)
712 cp->huff_offset = get_sbits(gbp, 15);
714 cp->codebook = get_bits(gbp, 2);
715 cp->huff_lsbs = get_bits(gbp, 5);
717 if (cp->huff_lsbs > 24) {
718 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
719 return AVERROR_INVALIDDATA;
722 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
727 /** Read decoding parameters that change more often than those in the restart
730 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
733 SubStream *s = &m->substream[substr];
737 if (s->param_presence_flags & PARAM_PRESENCE)
739 s->param_presence_flags = get_bits(gbp, 8);
741 if (s->param_presence_flags & PARAM_BLOCKSIZE)
742 if (get_bits1(gbp)) {
743 s->blocksize = get_bits(gbp, 9);
744 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
745 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
747 return AVERROR_INVALIDDATA;
751 if (s->param_presence_flags & PARAM_MATRIX)
753 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
756 if (s->param_presence_flags & PARAM_OUTSHIFT)
758 for (ch = 0; ch <= s->max_matrix_channel; ch++)
759 s->output_shift[ch] = get_sbits(gbp, 4);
761 if (s->param_presence_flags & PARAM_QUANTSTEP)
763 for (ch = 0; ch <= s->max_channel; ch++) {
764 ChannelParams *cp = &s->channel_params[ch];
766 s->quant_step_size[ch] = get_bits(gbp, 4);
768 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
771 for (ch = s->min_channel; ch <= s->max_channel; ch++)
773 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
779 #define MSB_MASK(bits) (-1u << bits)
781 /** Generate PCM samples using the prediction filters and residual values
782 * read from the data stream, and update the filter state. */
784 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
785 unsigned int channel)
787 SubStream *s = &m->substream[substr];
788 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
789 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
790 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
791 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
792 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
793 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
794 unsigned int filter_shift = fir->shift;
795 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
797 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
798 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
800 m->dsp.mlp_filter_channel(firbuf, fircoeff,
801 fir->order, iir->order,
802 filter_shift, mask, s->blocksize,
803 &m->sample_buffer[s->blockpos][channel]);
805 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
806 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
809 /** Read a block of PCM residual data (or actual if no filtering active). */
811 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
814 SubStream *s = &m->substream[substr];
815 unsigned int i, ch, expected_stream_pos = 0;
818 if (s->data_check_present) {
819 expected_stream_pos = get_bits_count(gbp);
820 expected_stream_pos += get_bits(gbp, 16);
821 av_log_ask_for_sample(m->avctx, "This file contains some features "
822 "we have not tested yet.\n");
825 if (s->blockpos + s->blocksize > m->access_unit_size) {
826 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
827 return AVERROR_INVALIDDATA;
830 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
831 s->blocksize * sizeof(m->bypassed_lsbs[0]));
833 for (i = 0; i < s->blocksize; i++)
834 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
837 for (ch = s->min_channel; ch <= s->max_channel; ch++)
838 filter_channel(m, substr, ch);
840 s->blockpos += s->blocksize;
842 if (s->data_check_present) {
843 if (get_bits_count(gbp) != expected_stream_pos)
844 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
851 /** Data table used for TrueHD noise generation function. */
853 static const int8_t noise_table[256] = {
854 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
855 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
856 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
857 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
858 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
859 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
860 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
861 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
862 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
863 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
864 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
865 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
866 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
867 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
868 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
869 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
872 /** Noise generation functions.
873 * I'm not sure what these are for - they seem to be some kind of pseudorandom
874 * sequence generators, used to generate noise data which is used when the
875 * channels are rematrixed. I'm not sure if they provide a practical benefit
876 * to compression, or just obfuscate the decoder. Are they for some kind of
879 /** Generate two channels of noise, used in the matrix when
880 * restart sync word == 0x31ea. */
882 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
884 SubStream *s = &m->substream[substr];
886 uint32_t seed = s->noisegen_seed;
887 unsigned int maxchan = s->max_matrix_channel;
889 for (i = 0; i < s->blockpos; i++) {
890 uint16_t seed_shr7 = seed >> 7;
891 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
892 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
894 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
897 s->noisegen_seed = seed;
900 /** Generate a block of noise, used when restart sync word == 0x31eb. */
902 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
904 SubStream *s = &m->substream[substr];
906 uint32_t seed = s->noisegen_seed;
908 for (i = 0; i < m->access_unit_size_pow2; i++) {
909 uint8_t seed_shr15 = seed >> 15;
910 m->noise_buffer[i] = noise_table[seed_shr15];
911 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
914 s->noisegen_seed = seed;
918 /** Apply the channel matrices in turn to reconstruct the original audio
921 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
923 SubStream *s = &m->substream[substr];
924 unsigned int mat, src_ch, i;
925 unsigned int maxchan;
927 maxchan = s->max_matrix_channel;
928 if (!s->noise_type) {
929 generate_2_noise_channels(m, substr);
932 fill_noise_buffer(m, substr);
935 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
936 int matrix_noise_shift = s->matrix_noise_shift[mat];
937 unsigned int dest_ch = s->matrix_out_ch[mat];
938 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
939 int32_t *coeffs = s->matrix_coeff[mat];
940 int index = s->num_primitive_matrices - mat;
941 int index2 = 2 * index + 1;
943 /* TODO: DSPContext? */
945 for (i = 0; i < s->blockpos; i++) {
946 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
947 int32_t *samples = m->sample_buffer[i];
950 for (src_ch = 0; src_ch <= maxchan; src_ch++)
951 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
953 if (matrix_noise_shift) {
954 index &= m->access_unit_size_pow2 - 1;
955 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
959 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
964 /** Write the audio data into the output buffer. */
966 static int output_data(MLPDecodeContext *m, unsigned int substr,
967 void *data, int *got_frame_ptr)
969 AVCodecContext *avctx = m->avctx;
970 SubStream *s = &m->substream[substr];
971 unsigned int i, out_ch = 0;
975 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
977 if (m->avctx->channels != s->max_matrix_channel + 1) {
978 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
979 return AVERROR_INVALIDDATA;
982 /* get output buffer */
983 m->frame.nb_samples = s->blockpos;
984 if ((ret = avctx->get_buffer(avctx, &m->frame)) < 0) {
985 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
988 data_32 = (int32_t *)m->frame.data[0];
989 data_16 = (int16_t *)m->frame.data[0];
991 for (i = 0; i < s->blockpos; i++) {
992 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
993 int mat_ch = s->ch_assign[out_ch];
994 int32_t sample = m->sample_buffer[i][mat_ch]
995 << s->output_shift[mat_ch];
996 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
997 if (is32) *data_32++ = sample << 8;
998 else *data_16++ = sample >> 8;
1003 *(AVFrame *)data = m->frame;
1008 /** Read an access unit from the stream.
1009 * @return negative on error, 0 if not enough data is present in the input stream,
1010 * otherwise the number of bytes consumed. */
1012 static int read_access_unit(AVCodecContext *avctx, void* data,
1013 int *got_frame_ptr, AVPacket *avpkt)
1015 const uint8_t *buf = avpkt->data;
1016 int buf_size = avpkt->size;
1017 MLPDecodeContext *m = avctx->priv_data;
1019 unsigned int length, substr;
1020 unsigned int substream_start;
1021 unsigned int header_size = 4;
1022 unsigned int substr_header_size = 0;
1023 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1024 uint16_t substream_data_len[MAX_SUBSTREAMS];
1025 uint8_t parity_bits;
1031 length = (AV_RB16(buf) & 0xfff) * 2;
1033 if (length < 4 || length > buf_size)
1034 return AVERROR_INVALIDDATA;
1036 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1038 m->is_major_sync_unit = 0;
1039 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1040 if (read_major_sync(m, &gb) < 0)
1042 m->is_major_sync_unit = 1;
1046 if (!m->params_valid) {
1047 av_log(m->avctx, AV_LOG_WARNING,
1048 "Stream parameters not seen; skipping frame.\n");
1053 substream_start = 0;
1055 for (substr = 0; substr < m->num_substreams; substr++) {
1056 int extraword_present, checkdata_present, end, nonrestart_substr;
1058 extraword_present = get_bits1(&gb);
1059 nonrestart_substr = get_bits1(&gb);
1060 checkdata_present = get_bits1(&gb);
1063 end = get_bits(&gb, 12) * 2;
1065 substr_header_size += 2;
1067 if (extraword_present) {
1068 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1069 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1073 substr_header_size += 2;
1076 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1077 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1081 if (end + header_size + substr_header_size > length) {
1082 av_log(m->avctx, AV_LOG_ERROR,
1083 "Indicated length of substream %d data goes off end of "
1084 "packet.\n", substr);
1085 end = length - header_size - substr_header_size;
1088 if (end < substream_start) {
1089 av_log(avctx, AV_LOG_ERROR,
1090 "Indicated end offset of substream %d data "
1091 "is smaller than calculated start offset.\n",
1096 if (substr > m->max_decoded_substream)
1099 substream_parity_present[substr] = checkdata_present;
1100 substream_data_len[substr] = end - substream_start;
1101 substream_start = end;
1104 parity_bits = ff_mlp_calculate_parity(buf, 4);
1105 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1107 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1108 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1112 buf += header_size + substr_header_size;
1114 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1115 SubStream *s = &m->substream[substr];
1116 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1118 m->matrix_changed = 0;
1119 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1123 if (get_bits1(&gb)) {
1124 if (get_bits1(&gb)) {
1125 /* A restart header should be present. */
1126 if (read_restart_header(m, &gb, buf, substr) < 0)
1128 s->restart_seen = 1;
1131 if (!s->restart_seen)
1133 if (read_decoding_params(m, &gb, substr) < 0)
1137 if (!s->restart_seen)
1140 if ((ret = read_block_data(m, &gb, substr)) < 0)
1143 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1144 goto substream_length_mismatch;
1146 } while (!get_bits1(&gb));
1148 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1150 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1153 if (get_bits(&gb, 16) != 0xD234)
1154 return AVERROR_INVALIDDATA;
1156 shorten_by = get_bits(&gb, 16);
1157 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1158 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1159 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1160 return AVERROR_INVALIDDATA;
1162 if (substr == m->max_decoded_substream)
1163 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1166 if (substream_parity_present[substr]) {
1167 uint8_t parity, checksum;
1169 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1170 goto substream_length_mismatch;
1172 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1173 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1175 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1176 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1177 if ( get_bits(&gb, 8) != checksum)
1178 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1181 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1182 goto substream_length_mismatch;
1185 if (!s->restart_seen)
1186 av_log(m->avctx, AV_LOG_ERROR,
1187 "No restart header present in substream %d.\n", substr);
1189 buf += substream_data_len[substr];
1192 rematrix_channels(m, m->max_decoded_substream);
1194 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1199 substream_length_mismatch:
1200 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1201 return AVERROR_INVALIDDATA;
1204 m->params_valid = 0;
1205 return AVERROR_INVALIDDATA;
1208 #if CONFIG_MLP_DECODER
1209 AVCodec ff_mlp_decoder = {
1211 .type = AVMEDIA_TYPE_AUDIO,
1212 .id = AV_CODEC_ID_MLP,
1213 .priv_data_size = sizeof(MLPDecodeContext),
1214 .init = mlp_decode_init,
1215 .decode = read_access_unit,
1216 .capabilities = CODEC_CAP_DR1,
1217 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1220 #if CONFIG_TRUEHD_DECODER
1221 AVCodec ff_truehd_decoder = {
1223 .type = AVMEDIA_TYPE_AUDIO,
1224 .id = AV_CODEC_ID_TRUEHD,
1225 .priv_data_size = sizeof(MLPDecodeContext),
1226 .init = mlp_decode_init,
1227 .decode = read_access_unit,
1228 .capabilities = CODEC_CAP_DR1,
1229 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1231 #endif /* CONFIG_TRUEHD_DECODER */