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
30 #include "libavutil/intreadwrite.h"
33 #include "libavutil/crc.h"
35 #include "mlp_parser.h"
39 /** number of bits used for VLC lookup - longest Huffman code is 9 */
42 typedef struct SubStream {
43 /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
47 /** restart header data */
48 /// The type of noise to be used in the rematrix stage.
51 /// The index of the first channel coded in this substream.
53 /// The index of the last channel coded in this substream.
55 /// The number of channels input into the rematrix stage.
56 uint8_t max_matrix_channel;
57 /// For each channel output by the matrix, the output channel to map it to
58 uint8_t ch_assign[MAX_CHANNELS];
60 /// Channel coding parameters for channels in the substream
61 ChannelParams channel_params[MAX_CHANNELS];
63 /// The left shift applied to random noise in 0x31ea substreams.
65 /// The current seed value for the pseudorandom noise generator(s).
66 uint32_t noisegen_seed;
68 /// Set if the substream contains extra info to check the size of VLC blocks.
69 uint8_t data_check_present;
71 /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
72 uint8_t param_presence_flags;
73 #define PARAM_BLOCKSIZE (1 << 7)
74 #define PARAM_MATRIX (1 << 6)
75 #define PARAM_OUTSHIFT (1 << 5)
76 #define PARAM_QUANTSTEP (1 << 4)
77 #define PARAM_FIR (1 << 3)
78 #define PARAM_IIR (1 << 2)
79 #define PARAM_HUFFOFFSET (1 << 1)
80 #define PARAM_PRESENCE (1 << 0)
86 /// Number of matrices to be applied.
87 uint8_t num_primitive_matrices;
89 /// matrix output channel
90 uint8_t matrix_out_ch[MAX_MATRICES];
92 /// Whether the LSBs of the matrix output are encoded in the bitstream.
93 uint8_t lsb_bypass[MAX_MATRICES];
94 /// Matrix coefficients, stored as 2.14 fixed point.
95 int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
96 /// Left shift to apply to noise values in 0x31eb substreams.
97 uint8_t matrix_noise_shift[MAX_MATRICES];
100 /// Left shift to apply to Huffman-decoded residuals.
101 uint8_t quant_step_size[MAX_CHANNELS];
103 /// number of PCM samples in current audio block
105 /// Number of PCM samples decoded so far in this frame.
108 /// Left shift to apply to decoded PCM values to get final 24-bit output.
109 int8_t output_shift[MAX_CHANNELS];
111 /// Running XOR of all output samples.
112 int32_t lossless_check_data;
116 typedef struct MLPDecodeContext {
117 AVCodecContext *avctx;
120 /// Current access unit being read has a major sync.
121 int is_major_sync_unit;
123 /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
124 uint8_t params_valid;
126 /// Number of substreams contained within this stream.
127 uint8_t num_substreams;
129 /// Index of the last substream to decode - further substreams are skipped.
130 uint8_t max_decoded_substream;
132 /// Stream needs channel reordering to comply with FFmpeg's channel order
133 uint8_t needs_reordering;
135 /// number of PCM samples contained in each frame
136 int access_unit_size;
137 /// next power of two above the number of samples in each frame
138 int access_unit_size_pow2;
140 SubStream substream[MAX_SUBSTREAMS];
143 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
145 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
146 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
147 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
152 static VLC huff_vlc[3];
154 /** Initialize static data, constant between all invocations of the codec. */
156 static av_cold void init_static(void)
158 if (!huff_vlc[0].bits) {
159 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
160 &ff_mlp_huffman_tables[0][0][1], 2, 1,
161 &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
162 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
163 &ff_mlp_huffman_tables[1][0][1], 2, 1,
164 &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
165 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
166 &ff_mlp_huffman_tables[2][0][1], 2, 1,
167 &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
173 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
174 unsigned int substr, unsigned int ch)
176 SubStream *s = &m->substream[substr];
177 ChannelParams *cp = &s->channel_params[ch];
178 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
179 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
180 int32_t sign_huff_offset = cp->huff_offset;
182 if (cp->codebook > 0)
183 sign_huff_offset -= 7 << lsb_bits;
186 sign_huff_offset -= 1 << sign_shift;
188 return sign_huff_offset;
191 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
194 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
195 unsigned int substr, unsigned int pos)
197 SubStream *s = &m->substream[substr];
198 unsigned int mat, channel;
200 for (mat = 0; mat < s->num_primitive_matrices; mat++)
201 if (s->lsb_bypass[mat])
202 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
204 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
205 ChannelParams *cp = &s->channel_params[channel];
206 int codebook = cp->codebook;
207 int quant_step_size = s->quant_step_size[channel];
208 int lsb_bits = cp->huff_lsbs - quant_step_size;
212 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
213 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
216 return AVERROR_INVALIDDATA;
219 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
221 result += cp->sign_huff_offset;
222 result <<= quant_step_size;
224 m->sample_buffer[pos + s->blockpos][channel] = result;
230 static av_cold int mlp_decode_init(AVCodecContext *avctx)
232 MLPDecodeContext *m = avctx->priv_data;
237 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
238 m->substream[substr].lossless_check_data = 0xffffffff;
239 ff_mlpdsp_init(&m->dsp);
241 avcodec_get_frame_defaults(&m->frame);
242 avctx->coded_frame = &m->frame;
247 /** Read a major sync info header - contains high level information about
248 * the stream - sample rate, channel arrangement etc. Most of this
249 * information is not actually necessary for decoding, only for playback.
252 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
257 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
260 if (mh.group1_bits == 0) {
261 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
262 return AVERROR_INVALIDDATA;
264 if (mh.group2_bits > mh.group1_bits) {
265 av_log(m->avctx, AV_LOG_ERROR,
266 "Channel group 2 cannot have more bits per sample than group 1.\n");
267 return AVERROR_INVALIDDATA;
270 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
271 av_log(m->avctx, AV_LOG_ERROR,
272 "Channel groups with differing sample rates are not currently supported.\n");
273 return AVERROR_INVALIDDATA;
276 if (mh.group1_samplerate == 0) {
277 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
278 return AVERROR_INVALIDDATA;
280 if (mh.group1_samplerate > MAX_SAMPLERATE) {
281 av_log(m->avctx, AV_LOG_ERROR,
282 "Sampling rate %d is greater than the supported maximum (%d).\n",
283 mh.group1_samplerate, MAX_SAMPLERATE);
284 return AVERROR_INVALIDDATA;
286 if (mh.access_unit_size > MAX_BLOCKSIZE) {
287 av_log(m->avctx, AV_LOG_ERROR,
288 "Block size %d is greater than the supported maximum (%d).\n",
289 mh.access_unit_size, MAX_BLOCKSIZE);
290 return AVERROR_INVALIDDATA;
292 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
293 av_log(m->avctx, AV_LOG_ERROR,
294 "Block size pow2 %d is greater than the supported maximum (%d).\n",
295 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
296 return AVERROR_INVALIDDATA;
299 if (mh.num_substreams == 0)
300 return AVERROR_INVALIDDATA;
301 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
302 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
303 return AVERROR_INVALIDDATA;
305 if (mh.num_substreams > MAX_SUBSTREAMS) {
306 av_log_ask_for_sample(m->avctx,
307 "Number of substreams %d is larger than the maximum supported "
308 "by the decoder.\n", mh.num_substreams);
309 return AVERROR_PATCHWELCOME;
312 m->access_unit_size = mh.access_unit_size;
313 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
315 m->num_substreams = mh.num_substreams;
316 m->max_decoded_substream = m->num_substreams - 1;
318 m->avctx->sample_rate = mh.group1_samplerate;
319 m->avctx->frame_size = mh.access_unit_size;
321 m->avctx->bits_per_raw_sample = mh.group1_bits;
322 if (mh.group1_bits > 16)
323 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
325 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
328 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
329 m->substream[substr].restart_seen = 0;
331 if (mh.stream_type == 0xbb) {
333 m->avctx->channel_layout = ff_mlp_layout[mh.channels_mlp];
334 } else { /* mh.stream_type == 0xba */
336 if (mh.channels_thd_stream2) {
337 m->avctx->channel_layout = ff_truehd_layout(mh.channels_thd_stream2);
339 m->avctx->channel_layout = ff_truehd_layout(mh.channels_thd_stream1);
341 if (m->avctx->channels<=2 && m->avctx->channel_layout == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
342 av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
343 m->max_decoded_substream = 0;
344 if (m->avctx->channels==2)
345 m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
347 if (m->avctx->channels &&
348 !m->avctx->request_channels && !m->avctx->request_channel_layout &&
349 av_get_channel_layout_nb_channels(m->avctx->channel_layout) != m->avctx->channels) {
350 m->avctx->channel_layout = 0;
351 av_log_ask_for_sample(m->avctx, "Unknown channel layout.");
355 m->needs_reordering = mh.channels_mlp >= 18 && mh.channels_mlp <= 20;
360 /** Read a restart header from a block in a substream. This contains parameters
361 * required to decode the audio that do not change very often. Generally
362 * (always) present only in blocks following a major sync. */
364 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
365 const uint8_t *buf, unsigned int substr)
367 SubStream *s = &m->substream[substr];
371 uint8_t lossless_check;
372 int start_count = get_bits_count(gbp);
373 const int max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
374 ? MAX_MATRIX_CHANNEL_MLP
375 : MAX_MATRIX_CHANNEL_TRUEHD;
376 int max_channel, min_channel, matrix_channel;
378 sync_word = get_bits(gbp, 13);
380 if (sync_word != 0x31ea >> 1) {
381 av_log(m->avctx, AV_LOG_ERROR,
382 "restart header sync incorrect (got 0x%04x)\n", sync_word);
383 return AVERROR_INVALIDDATA;
386 s->noise_type = get_bits1(gbp);
388 if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
389 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
390 return AVERROR_INVALIDDATA;
393 skip_bits(gbp, 16); /* Output timestamp */
395 min_channel = get_bits(gbp, 4);
396 max_channel = get_bits(gbp, 4);
397 matrix_channel = get_bits(gbp, 4);
399 if (matrix_channel > max_matrix_channel) {
400 av_log(m->avctx, AV_LOG_ERROR,
401 "Max matrix channel cannot be greater than %d.\n",
403 return AVERROR_INVALIDDATA;
406 if (max_channel != matrix_channel) {
407 av_log(m->avctx, AV_LOG_ERROR,
408 "Max channel must be equal max matrix channel.\n");
409 return AVERROR_INVALIDDATA;
412 /* This should happen for TrueHD streams with >6 channels and MLP's noise
413 * type. It is not yet known if this is allowed. */
414 if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
415 av_log_ask_for_sample(m->avctx,
416 "Number of channels %d is larger than the maximum supported "
417 "by the decoder.\n", max_channel + 2);
418 return AVERROR_PATCHWELCOME;
421 if (min_channel > max_channel) {
422 av_log(m->avctx, AV_LOG_ERROR,
423 "Substream min channel cannot be greater than max channel.\n");
424 return AVERROR_INVALIDDATA;
427 s->min_channel = min_channel;
428 s->max_channel = max_channel;
429 s->max_matrix_channel = matrix_channel;
431 if (m->avctx->request_channels > 0
432 && s->max_channel + 1 >= m->avctx->request_channels
433 && substr < m->max_decoded_substream) {
434 av_log(m->avctx, AV_LOG_DEBUG,
435 "Extracting %d channel downmix from substream %d. "
436 "Further substreams will be skipped.\n",
437 s->max_channel + 1, substr);
438 m->max_decoded_substream = substr;
441 s->noise_shift = get_bits(gbp, 4);
442 s->noisegen_seed = get_bits(gbp, 23);
446 s->data_check_present = get_bits1(gbp);
447 lossless_check = get_bits(gbp, 8);
448 if (substr == m->max_decoded_substream
449 && s->lossless_check_data != 0xffffffff) {
450 tmp = xor_32_to_8(s->lossless_check_data);
451 if (tmp != lossless_check)
452 av_log(m->avctx, AV_LOG_WARNING,
453 "Lossless check failed - expected %02x, calculated %02x.\n",
454 lossless_check, tmp);
459 memset(s->ch_assign, 0, sizeof(s->ch_assign));
461 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
462 int ch_assign = get_bits(gbp, 6);
463 if (ch_assign > s->max_matrix_channel) {
464 av_log_ask_for_sample(m->avctx,
465 "Assignment of matrix channel %d to invalid output channel %d.\n",
467 return AVERROR_PATCHWELCOME;
469 s->ch_assign[ch_assign] = ch;
472 if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
473 if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
474 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
475 int i = s->ch_assign[4];
476 s->ch_assign[4] = s->ch_assign[3];
477 s->ch_assign[3] = s->ch_assign[2];
479 } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
480 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
481 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
484 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD &&
485 (m->avctx->channel_layout == AV_CH_LAYOUT_7POINT1 ||
486 m->avctx->channel_layout == AV_CH_LAYOUT_7POINT1_WIDE)) {
487 FFSWAP(int, s->ch_assign[4], s->ch_assign[6]);
488 FFSWAP(int, s->ch_assign[5], s->ch_assign[7]);
489 } else if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD &&
490 (m->avctx->channel_layout == AV_CH_LAYOUT_6POINT1 ||
491 m->avctx->channel_layout == (AV_CH_LAYOUT_6POINT1 | AV_CH_TOP_CENTER) ||
492 m->avctx->channel_layout == (AV_CH_LAYOUT_6POINT1 | AV_CH_TOP_FRONT_CENTER))) {
493 int i = s->ch_assign[6];
494 s->ch_assign[6] = s->ch_assign[5];
495 s->ch_assign[5] = s->ch_assign[4];
499 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
501 if (checksum != get_bits(gbp, 8))
502 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
504 /* Set default decoding parameters. */
505 s->param_presence_flags = 0xff;
506 s->num_primitive_matrices = 0;
508 s->lossless_check_data = 0;
510 memset(s->output_shift , 0, sizeof(s->output_shift ));
511 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
513 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
514 ChannelParams *cp = &s->channel_params[ch];
515 cp->filter_params[FIR].order = 0;
516 cp->filter_params[IIR].order = 0;
517 cp->filter_params[FIR].shift = 0;
518 cp->filter_params[IIR].shift = 0;
520 /* Default audio coding is 24-bit raw PCM. */
522 cp->sign_huff_offset = (-1) << 23;
527 if (substr == m->max_decoded_substream &&
528 m->avctx->channels != s->max_matrix_channel + 1) {
529 m->avctx->channels = s->max_matrix_channel + 1;
530 m->avctx->channel_layout = 0;
536 /** Read parameters for one of the prediction filters. */
538 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
539 unsigned int substr, unsigned int channel,
542 SubStream *s = &m->substream[substr];
543 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
544 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
545 const char fchar = filter ? 'I' : 'F';
548 // Filter is 0 for FIR, 1 for IIR.
549 av_assert0(filter < 2);
551 if (m->filter_changed[channel][filter]++ > 1) {
552 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
553 return AVERROR_INVALIDDATA;
556 order = get_bits(gbp, 4);
557 if (order > max_order) {
558 av_log(m->avctx, AV_LOG_ERROR,
559 "%cIR filter order %d is greater than maximum %d.\n",
560 fchar, order, max_order);
561 return AVERROR_INVALIDDATA;
566 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
567 int coeff_bits, coeff_shift;
569 fp->shift = get_bits(gbp, 4);
571 coeff_bits = get_bits(gbp, 5);
572 coeff_shift = get_bits(gbp, 3);
573 if (coeff_bits < 1 || coeff_bits > 16) {
574 av_log(m->avctx, AV_LOG_ERROR,
575 "%cIR filter coeff_bits must be between 1 and 16.\n",
577 return AVERROR_INVALIDDATA;
579 if (coeff_bits + coeff_shift > 16) {
580 av_log(m->avctx, AV_LOG_ERROR,
581 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
583 return AVERROR_INVALIDDATA;
586 for (i = 0; i < order; i++)
587 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
589 if (get_bits1(gbp)) {
590 int state_bits, state_shift;
593 av_log(m->avctx, AV_LOG_ERROR,
594 "FIR filter has state data specified.\n");
595 return AVERROR_INVALIDDATA;
598 state_bits = get_bits(gbp, 4);
599 state_shift = get_bits(gbp, 4);
601 /* TODO: Check validity of state data. */
603 for (i = 0; i < order; i++)
604 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
611 /** Read parameters for primitive matrices. */
613 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
615 SubStream *s = &m->substream[substr];
616 unsigned int mat, ch;
617 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
619 : MAX_MATRICES_TRUEHD;
621 if (m->matrix_changed++ > 1) {
622 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
623 return AVERROR_INVALIDDATA;
626 s->num_primitive_matrices = get_bits(gbp, 4);
628 if (s->num_primitive_matrices > max_primitive_matrices) {
629 av_log(m->avctx, AV_LOG_ERROR,
630 "Number of primitive matrices cannot be greater than %d.\n",
631 max_primitive_matrices);
632 return AVERROR_INVALIDDATA;
635 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
636 int frac_bits, max_chan;
637 s->matrix_out_ch[mat] = get_bits(gbp, 4);
638 frac_bits = get_bits(gbp, 4);
639 s->lsb_bypass [mat] = get_bits1(gbp);
641 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
642 av_log(m->avctx, AV_LOG_ERROR,
643 "Invalid channel %d specified as output from matrix.\n",
644 s->matrix_out_ch[mat]);
645 return AVERROR_INVALIDDATA;
647 if (frac_bits > 14) {
648 av_log(m->avctx, AV_LOG_ERROR,
649 "Too many fractional bits specified.\n");
650 return AVERROR_INVALIDDATA;
653 max_chan = s->max_matrix_channel;
657 for (ch = 0; ch <= max_chan; ch++) {
660 coeff_val = get_sbits(gbp, frac_bits + 2);
662 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
666 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
668 s->matrix_noise_shift[mat] = 0;
674 /** Read channel parameters. */
676 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
677 GetBitContext *gbp, unsigned int ch)
679 SubStream *s = &m->substream[substr];
680 ChannelParams *cp = &s->channel_params[ch];
681 FilterParams *fir = &cp->filter_params[FIR];
682 FilterParams *iir = &cp->filter_params[IIR];
685 if (s->param_presence_flags & PARAM_FIR)
687 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
690 if (s->param_presence_flags & PARAM_IIR)
692 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
695 if (fir->order + iir->order > 8) {
696 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
697 return AVERROR_INVALIDDATA;
700 if (fir->order && iir->order &&
701 fir->shift != iir->shift) {
702 av_log(m->avctx, AV_LOG_ERROR,
703 "FIR and IIR filters must use the same precision.\n");
704 return AVERROR_INVALIDDATA;
706 /* The FIR and IIR filters must have the same precision.
707 * To simplify the filtering code, only the precision of the
708 * FIR filter is considered. If only the IIR filter is employed,
709 * the FIR filter precision is set to that of the IIR filter, so
710 * that the filtering code can use it. */
711 if (!fir->order && iir->order)
712 fir->shift = iir->shift;
714 if (s->param_presence_flags & PARAM_HUFFOFFSET)
716 cp->huff_offset = get_sbits(gbp, 15);
718 cp->codebook = get_bits(gbp, 2);
719 cp->huff_lsbs = get_bits(gbp, 5);
721 if (cp->huff_lsbs > 24) {
722 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
723 return AVERROR_INVALIDDATA;
726 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
731 /** Read decoding parameters that change more often than those in the restart
734 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
737 SubStream *s = &m->substream[substr];
741 if (s->param_presence_flags & PARAM_PRESENCE)
743 s->param_presence_flags = get_bits(gbp, 8);
745 if (s->param_presence_flags & PARAM_BLOCKSIZE)
746 if (get_bits1(gbp)) {
747 s->blocksize = get_bits(gbp, 9);
748 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
749 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
751 return AVERROR_INVALIDDATA;
755 if (s->param_presence_flags & PARAM_MATRIX)
757 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
760 if (s->param_presence_flags & PARAM_OUTSHIFT)
762 for (ch = 0; ch <= s->max_matrix_channel; ch++)
763 s->output_shift[ch] = get_sbits(gbp, 4);
765 if (s->param_presence_flags & PARAM_QUANTSTEP)
767 for (ch = 0; ch <= s->max_channel; ch++) {
768 ChannelParams *cp = &s->channel_params[ch];
770 s->quant_step_size[ch] = get_bits(gbp, 4);
772 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
775 for (ch = s->min_channel; ch <= s->max_channel; ch++)
777 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
783 #define MSB_MASK(bits) (-1u << bits)
785 /** Generate PCM samples using the prediction filters and residual values
786 * read from the data stream, and update the filter state. */
788 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
789 unsigned int channel)
791 SubStream *s = &m->substream[substr];
792 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
793 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
794 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
795 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
796 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
797 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
798 unsigned int filter_shift = fir->shift;
799 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
801 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
802 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
804 m->dsp.mlp_filter_channel(firbuf, fircoeff,
805 fir->order, iir->order,
806 filter_shift, mask, s->blocksize,
807 &m->sample_buffer[s->blockpos][channel]);
809 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
810 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
813 /** Read a block of PCM residual data (or actual if no filtering active). */
815 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
818 SubStream *s = &m->substream[substr];
819 unsigned int i, ch, expected_stream_pos = 0;
822 if (s->data_check_present) {
823 expected_stream_pos = get_bits_count(gbp);
824 expected_stream_pos += get_bits(gbp, 16);
825 av_log_ask_for_sample(m->avctx, "This file contains some features "
826 "we have not tested yet.\n");
829 if (s->blockpos + s->blocksize > m->access_unit_size) {
830 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
831 return AVERROR_INVALIDDATA;
834 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
835 s->blocksize * sizeof(m->bypassed_lsbs[0]));
837 for (i = 0; i < s->blocksize; i++)
838 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
841 for (ch = s->min_channel; ch <= s->max_channel; ch++)
842 filter_channel(m, substr, ch);
844 s->blockpos += s->blocksize;
846 if (s->data_check_present) {
847 if (get_bits_count(gbp) != expected_stream_pos)
848 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
855 /** Data table used for TrueHD noise generation function. */
857 static const int8_t noise_table[256] = {
858 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
859 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
860 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
861 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
862 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
863 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
864 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
865 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
866 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
867 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
868 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
869 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
870 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
871 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
872 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
873 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
876 /** Noise generation functions.
877 * I'm not sure what these are for - they seem to be some kind of pseudorandom
878 * sequence generators, used to generate noise data which is used when the
879 * channels are rematrixed. I'm not sure if they provide a practical benefit
880 * to compression, or just obfuscate the decoder. Are they for some kind of
883 /** Generate two channels of noise, used in the matrix when
884 * restart sync word == 0x31ea. */
886 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
888 SubStream *s = &m->substream[substr];
890 uint32_t seed = s->noisegen_seed;
891 unsigned int maxchan = s->max_matrix_channel;
893 for (i = 0; i < s->blockpos; i++) {
894 uint16_t seed_shr7 = seed >> 7;
895 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
896 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
898 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
901 s->noisegen_seed = seed;
904 /** Generate a block of noise, used when restart sync word == 0x31eb. */
906 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
908 SubStream *s = &m->substream[substr];
910 uint32_t seed = s->noisegen_seed;
912 for (i = 0; i < m->access_unit_size_pow2; i++) {
913 uint8_t seed_shr15 = seed >> 15;
914 m->noise_buffer[i] = noise_table[seed_shr15];
915 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
918 s->noisegen_seed = seed;
922 /** Apply the channel matrices in turn to reconstruct the original audio
925 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
927 SubStream *s = &m->substream[substr];
928 unsigned int mat, src_ch, i;
929 unsigned int maxchan;
931 maxchan = s->max_matrix_channel;
932 if (!s->noise_type) {
933 generate_2_noise_channels(m, substr);
936 fill_noise_buffer(m, substr);
939 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
940 int matrix_noise_shift = s->matrix_noise_shift[mat];
941 unsigned int dest_ch = s->matrix_out_ch[mat];
942 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
943 int32_t *coeffs = s->matrix_coeff[mat];
944 int index = s->num_primitive_matrices - mat;
945 int index2 = 2 * index + 1;
947 /* TODO: DSPContext? */
949 for (i = 0; i < s->blockpos; i++) {
950 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
951 int32_t *samples = m->sample_buffer[i];
954 for (src_ch = 0; src_ch <= maxchan; src_ch++)
955 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
957 if (matrix_noise_shift) {
958 index &= m->access_unit_size_pow2 - 1;
959 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
963 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
968 /** Write the audio data into the output buffer. */
970 static int output_data(MLPDecodeContext *m, unsigned int substr,
971 void *data, int *got_frame_ptr)
973 AVCodecContext *avctx = m->avctx;
974 SubStream *s = &m->substream[substr];
975 unsigned int i, out_ch = 0;
979 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
981 if (m->avctx->channels != s->max_matrix_channel + 1) {
982 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
983 return AVERROR_INVALIDDATA;
986 /* get output buffer */
987 m->frame.nb_samples = s->blockpos;
988 if ((ret = ff_get_buffer(avctx, &m->frame)) < 0) {
989 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
992 data_32 = (int32_t *)m->frame.data[0];
993 data_16 = (int16_t *)m->frame.data[0];
995 for (i = 0; i < s->blockpos; i++) {
996 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
997 int mat_ch = s->ch_assign[out_ch];
998 int32_t sample = m->sample_buffer[i][mat_ch]
999 << s->output_shift[mat_ch];
1000 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
1001 if (is32) *data_32++ = sample << 8;
1002 else *data_16++ = sample >> 8;
1007 *(AVFrame *)data = m->frame;
1012 /** Read an access unit from the stream.
1013 * @return negative on error, 0 if not enough data is present in the input stream,
1014 * otherwise the number of bytes consumed. */
1016 static int read_access_unit(AVCodecContext *avctx, void* data,
1017 int *got_frame_ptr, AVPacket *avpkt)
1019 const uint8_t *buf = avpkt->data;
1020 int buf_size = avpkt->size;
1021 MLPDecodeContext *m = avctx->priv_data;
1023 unsigned int length, substr;
1024 unsigned int substream_start;
1025 unsigned int header_size = 4;
1026 unsigned int substr_header_size = 0;
1027 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1028 uint16_t substream_data_len[MAX_SUBSTREAMS];
1029 uint8_t parity_bits;
1035 length = (AV_RB16(buf) & 0xfff) * 2;
1037 if (length < 4 || length > buf_size)
1038 return AVERROR_INVALIDDATA;
1040 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1042 m->is_major_sync_unit = 0;
1043 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1044 if (read_major_sync(m, &gb) < 0)
1046 m->is_major_sync_unit = 1;
1050 if (!m->params_valid) {
1051 av_log(m->avctx, AV_LOG_WARNING,
1052 "Stream parameters not seen; skipping frame.\n");
1057 substream_start = 0;
1059 for (substr = 0; substr < m->num_substreams; substr++) {
1060 int extraword_present, checkdata_present, end, nonrestart_substr;
1062 extraword_present = get_bits1(&gb);
1063 nonrestart_substr = get_bits1(&gb);
1064 checkdata_present = get_bits1(&gb);
1067 end = get_bits(&gb, 12) * 2;
1069 substr_header_size += 2;
1071 if (extraword_present) {
1072 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1073 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1077 substr_header_size += 2;
1080 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1081 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1085 if (end + header_size + substr_header_size > length) {
1086 av_log(m->avctx, AV_LOG_ERROR,
1087 "Indicated length of substream %d data goes off end of "
1088 "packet.\n", substr);
1089 end = length - header_size - substr_header_size;
1092 if (end < substream_start) {
1093 av_log(avctx, AV_LOG_ERROR,
1094 "Indicated end offset of substream %d data "
1095 "is smaller than calculated start offset.\n",
1100 if (substr > m->max_decoded_substream)
1103 substream_parity_present[substr] = checkdata_present;
1104 substream_data_len[substr] = end - substream_start;
1105 substream_start = end;
1108 parity_bits = ff_mlp_calculate_parity(buf, 4);
1109 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1111 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1112 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1116 buf += header_size + substr_header_size;
1118 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1119 SubStream *s = &m->substream[substr];
1120 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1122 m->matrix_changed = 0;
1123 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1127 if (get_bits1(&gb)) {
1128 if (get_bits1(&gb)) {
1129 /* A restart header should be present. */
1130 if (read_restart_header(m, &gb, buf, substr) < 0)
1132 s->restart_seen = 1;
1135 if (!s->restart_seen)
1137 if (read_decoding_params(m, &gb, substr) < 0)
1141 if (!s->restart_seen)
1144 if ((ret = read_block_data(m, &gb, substr)) < 0)
1147 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1148 goto substream_length_mismatch;
1150 } while (!get_bits1(&gb));
1152 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1154 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1157 if (get_bits(&gb, 16) != 0xD234)
1158 return AVERROR_INVALIDDATA;
1160 shorten_by = get_bits(&gb, 16);
1161 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1162 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1163 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1164 return AVERROR_INVALIDDATA;
1166 if (substr == m->max_decoded_substream)
1167 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1170 if (substream_parity_present[substr]) {
1171 uint8_t parity, checksum;
1173 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1174 goto substream_length_mismatch;
1176 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1177 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1179 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1180 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1181 if ( get_bits(&gb, 8) != checksum)
1182 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1185 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1186 goto substream_length_mismatch;
1189 if (!s->restart_seen)
1190 av_log(m->avctx, AV_LOG_ERROR,
1191 "No restart header present in substream %d.\n", substr);
1193 buf += substream_data_len[substr];
1196 rematrix_channels(m, m->max_decoded_substream);
1198 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1203 substream_length_mismatch:
1204 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1205 return AVERROR_INVALIDDATA;
1208 m->params_valid = 0;
1209 return AVERROR_INVALIDDATA;
1212 #if CONFIG_MLP_DECODER
1213 AVCodec ff_mlp_decoder = {
1215 .type = AVMEDIA_TYPE_AUDIO,
1216 .id = AV_CODEC_ID_MLP,
1217 .priv_data_size = sizeof(MLPDecodeContext),
1218 .init = mlp_decode_init,
1219 .decode = read_access_unit,
1220 .capabilities = CODEC_CAP_DR1,
1221 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1224 #if CONFIG_TRUEHD_DECODER
1225 AVCodec ff_truehd_decoder = {
1227 .type = AVMEDIA_TYPE_AUDIO,
1228 .id = AV_CODEC_ID_TRUEHD,
1229 .priv_data_size = sizeof(MLPDecodeContext),
1230 .init = mlp_decode_init,
1231 .decode = read_access_unit,
1232 .capabilities = CODEC_CAP_DR1,
1233 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1235 #endif /* CONFIG_TRUEHD_DECODER */