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;
533 /** Read parameters for one of the prediction filters. */
535 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
536 unsigned int substr, unsigned int channel,
539 SubStream *s = &m->substream[substr];
540 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
541 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
542 const char fchar = filter ? 'I' : 'F';
545 // Filter is 0 for FIR, 1 for IIR.
546 av_assert0(filter < 2);
548 if (m->filter_changed[channel][filter]++ > 1) {
549 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
550 return AVERROR_INVALIDDATA;
553 order = get_bits(gbp, 4);
554 if (order > max_order) {
555 av_log(m->avctx, AV_LOG_ERROR,
556 "%cIR filter order %d is greater than maximum %d.\n",
557 fchar, order, max_order);
558 return AVERROR_INVALIDDATA;
563 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
564 int coeff_bits, coeff_shift;
566 fp->shift = get_bits(gbp, 4);
568 coeff_bits = get_bits(gbp, 5);
569 coeff_shift = get_bits(gbp, 3);
570 if (coeff_bits < 1 || coeff_bits > 16) {
571 av_log(m->avctx, AV_LOG_ERROR,
572 "%cIR filter coeff_bits must be between 1 and 16.\n",
574 return AVERROR_INVALIDDATA;
576 if (coeff_bits + coeff_shift > 16) {
577 av_log(m->avctx, AV_LOG_ERROR,
578 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
580 return AVERROR_INVALIDDATA;
583 for (i = 0; i < order; i++)
584 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
586 if (get_bits1(gbp)) {
587 int state_bits, state_shift;
590 av_log(m->avctx, AV_LOG_ERROR,
591 "FIR filter has state data specified.\n");
592 return AVERROR_INVALIDDATA;
595 state_bits = get_bits(gbp, 4);
596 state_shift = get_bits(gbp, 4);
598 /* TODO: Check validity of state data. */
600 for (i = 0; i < order; i++)
601 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
608 /** Read parameters for primitive matrices. */
610 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
612 SubStream *s = &m->substream[substr];
613 unsigned int mat, ch;
614 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
616 : MAX_MATRICES_TRUEHD;
618 if (m->matrix_changed++ > 1) {
619 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
620 return AVERROR_INVALIDDATA;
623 s->num_primitive_matrices = get_bits(gbp, 4);
625 if (s->num_primitive_matrices > max_primitive_matrices) {
626 av_log(m->avctx, AV_LOG_ERROR,
627 "Number of primitive matrices cannot be greater than %d.\n",
628 max_primitive_matrices);
629 return AVERROR_INVALIDDATA;
632 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
633 int frac_bits, max_chan;
634 s->matrix_out_ch[mat] = get_bits(gbp, 4);
635 frac_bits = get_bits(gbp, 4);
636 s->lsb_bypass [mat] = get_bits1(gbp);
638 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
639 av_log(m->avctx, AV_LOG_ERROR,
640 "Invalid channel %d specified as output from matrix.\n",
641 s->matrix_out_ch[mat]);
642 return AVERROR_INVALIDDATA;
644 if (frac_bits > 14) {
645 av_log(m->avctx, AV_LOG_ERROR,
646 "Too many fractional bits specified.\n");
647 return AVERROR_INVALIDDATA;
650 max_chan = s->max_matrix_channel;
654 for (ch = 0; ch <= max_chan; ch++) {
657 coeff_val = get_sbits(gbp, frac_bits + 2);
659 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
663 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
665 s->matrix_noise_shift[mat] = 0;
671 /** Read channel parameters. */
673 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
674 GetBitContext *gbp, unsigned int ch)
676 SubStream *s = &m->substream[substr];
677 ChannelParams *cp = &s->channel_params[ch];
678 FilterParams *fir = &cp->filter_params[FIR];
679 FilterParams *iir = &cp->filter_params[IIR];
682 if (s->param_presence_flags & PARAM_FIR)
684 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
687 if (s->param_presence_flags & PARAM_IIR)
689 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
692 if (fir->order + iir->order > 8) {
693 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
694 return AVERROR_INVALIDDATA;
697 if (fir->order && iir->order &&
698 fir->shift != iir->shift) {
699 av_log(m->avctx, AV_LOG_ERROR,
700 "FIR and IIR filters must use the same precision.\n");
701 return AVERROR_INVALIDDATA;
703 /* The FIR and IIR filters must have the same precision.
704 * To simplify the filtering code, only the precision of the
705 * FIR filter is considered. If only the IIR filter is employed,
706 * the FIR filter precision is set to that of the IIR filter, so
707 * that the filtering code can use it. */
708 if (!fir->order && iir->order)
709 fir->shift = iir->shift;
711 if (s->param_presence_flags & PARAM_HUFFOFFSET)
713 cp->huff_offset = get_sbits(gbp, 15);
715 cp->codebook = get_bits(gbp, 2);
716 cp->huff_lsbs = get_bits(gbp, 5);
718 if (cp->huff_lsbs > 24) {
719 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
720 return AVERROR_INVALIDDATA;
723 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
728 /** Read decoding parameters that change more often than those in the restart
731 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
734 SubStream *s = &m->substream[substr];
738 if (s->param_presence_flags & PARAM_PRESENCE)
740 s->param_presence_flags = get_bits(gbp, 8);
742 if (s->param_presence_flags & PARAM_BLOCKSIZE)
743 if (get_bits1(gbp)) {
744 s->blocksize = get_bits(gbp, 9);
745 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
746 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
748 return AVERROR_INVALIDDATA;
752 if (s->param_presence_flags & PARAM_MATRIX)
754 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
757 if (s->param_presence_flags & PARAM_OUTSHIFT)
759 for (ch = 0; ch <= s->max_matrix_channel; ch++)
760 s->output_shift[ch] = get_sbits(gbp, 4);
762 if (s->param_presence_flags & PARAM_QUANTSTEP)
764 for (ch = 0; ch <= s->max_channel; ch++) {
765 ChannelParams *cp = &s->channel_params[ch];
767 s->quant_step_size[ch] = get_bits(gbp, 4);
769 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
772 for (ch = s->min_channel; ch <= s->max_channel; ch++)
774 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
780 #define MSB_MASK(bits) (-1u << bits)
782 /** Generate PCM samples using the prediction filters and residual values
783 * read from the data stream, and update the filter state. */
785 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
786 unsigned int channel)
788 SubStream *s = &m->substream[substr];
789 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
790 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
791 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
792 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
793 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
794 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
795 unsigned int filter_shift = fir->shift;
796 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
798 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
799 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
801 m->dsp.mlp_filter_channel(firbuf, fircoeff,
802 fir->order, iir->order,
803 filter_shift, mask, s->blocksize,
804 &m->sample_buffer[s->blockpos][channel]);
806 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
807 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
810 /** Read a block of PCM residual data (or actual if no filtering active). */
812 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
815 SubStream *s = &m->substream[substr];
816 unsigned int i, ch, expected_stream_pos = 0;
819 if (s->data_check_present) {
820 expected_stream_pos = get_bits_count(gbp);
821 expected_stream_pos += get_bits(gbp, 16);
822 av_log_ask_for_sample(m->avctx, "This file contains some features "
823 "we have not tested yet.\n");
826 if (s->blockpos + s->blocksize > m->access_unit_size) {
827 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
828 return AVERROR_INVALIDDATA;
831 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
832 s->blocksize * sizeof(m->bypassed_lsbs[0]));
834 for (i = 0; i < s->blocksize; i++)
835 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
838 for (ch = s->min_channel; ch <= s->max_channel; ch++)
839 filter_channel(m, substr, ch);
841 s->blockpos += s->blocksize;
843 if (s->data_check_present) {
844 if (get_bits_count(gbp) != expected_stream_pos)
845 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
852 /** Data table used for TrueHD noise generation function. */
854 static const int8_t noise_table[256] = {
855 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
856 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
857 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
858 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
859 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
860 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
861 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
862 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
863 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
864 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
865 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
866 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
867 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
868 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
869 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
870 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
873 /** Noise generation functions.
874 * I'm not sure what these are for - they seem to be some kind of pseudorandom
875 * sequence generators, used to generate noise data which is used when the
876 * channels are rematrixed. I'm not sure if they provide a practical benefit
877 * to compression, or just obfuscate the decoder. Are they for some kind of
880 /** Generate two channels of noise, used in the matrix when
881 * restart sync word == 0x31ea. */
883 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
885 SubStream *s = &m->substream[substr];
887 uint32_t seed = s->noisegen_seed;
888 unsigned int maxchan = s->max_matrix_channel;
890 for (i = 0; i < s->blockpos; i++) {
891 uint16_t seed_shr7 = seed >> 7;
892 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
893 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
895 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
898 s->noisegen_seed = seed;
901 /** Generate a block of noise, used when restart sync word == 0x31eb. */
903 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
905 SubStream *s = &m->substream[substr];
907 uint32_t seed = s->noisegen_seed;
909 for (i = 0; i < m->access_unit_size_pow2; i++) {
910 uint8_t seed_shr15 = seed >> 15;
911 m->noise_buffer[i] = noise_table[seed_shr15];
912 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
915 s->noisegen_seed = seed;
919 /** Apply the channel matrices in turn to reconstruct the original audio
922 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
924 SubStream *s = &m->substream[substr];
925 unsigned int mat, src_ch, i;
926 unsigned int maxchan;
928 maxchan = s->max_matrix_channel;
929 if (!s->noise_type) {
930 generate_2_noise_channels(m, substr);
933 fill_noise_buffer(m, substr);
936 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
937 int matrix_noise_shift = s->matrix_noise_shift[mat];
938 unsigned int dest_ch = s->matrix_out_ch[mat];
939 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
940 int32_t *coeffs = s->matrix_coeff[mat];
941 int index = s->num_primitive_matrices - mat;
942 int index2 = 2 * index + 1;
944 /* TODO: DSPContext? */
946 for (i = 0; i < s->blockpos; i++) {
947 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
948 int32_t *samples = m->sample_buffer[i];
951 for (src_ch = 0; src_ch <= maxchan; src_ch++)
952 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
954 if (matrix_noise_shift) {
955 index &= m->access_unit_size_pow2 - 1;
956 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
960 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
965 /** Write the audio data into the output buffer. */
967 static int output_data(MLPDecodeContext *m, unsigned int substr,
968 void *data, int *got_frame_ptr)
970 AVCodecContext *avctx = m->avctx;
971 SubStream *s = &m->substream[substr];
972 unsigned int i, out_ch = 0;
976 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
978 if (m->avctx->channels != s->max_matrix_channel + 1) {
979 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
980 return AVERROR_INVALIDDATA;
983 /* get output buffer */
984 m->frame.nb_samples = s->blockpos;
985 if ((ret = ff_get_buffer(avctx, &m->frame)) < 0) {
986 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
989 data_32 = (int32_t *)m->frame.data[0];
990 data_16 = (int16_t *)m->frame.data[0];
992 for (i = 0; i < s->blockpos; i++) {
993 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
994 int mat_ch = s->ch_assign[out_ch];
995 int32_t sample = m->sample_buffer[i][mat_ch]
996 << s->output_shift[mat_ch];
997 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
998 if (is32) *data_32++ = sample << 8;
999 else *data_16++ = sample >> 8;
1004 *(AVFrame *)data = m->frame;
1009 /** Read an access unit from the stream.
1010 * @return negative on error, 0 if not enough data is present in the input stream,
1011 * otherwise the number of bytes consumed. */
1013 static int read_access_unit(AVCodecContext *avctx, void* data,
1014 int *got_frame_ptr, AVPacket *avpkt)
1016 const uint8_t *buf = avpkt->data;
1017 int buf_size = avpkt->size;
1018 MLPDecodeContext *m = avctx->priv_data;
1020 unsigned int length, substr;
1021 unsigned int substream_start;
1022 unsigned int header_size = 4;
1023 unsigned int substr_header_size = 0;
1024 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1025 uint16_t substream_data_len[MAX_SUBSTREAMS];
1026 uint8_t parity_bits;
1032 length = (AV_RB16(buf) & 0xfff) * 2;
1034 if (length < 4 || length > buf_size)
1035 return AVERROR_INVALIDDATA;
1037 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1039 m->is_major_sync_unit = 0;
1040 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1041 if (read_major_sync(m, &gb) < 0)
1043 m->is_major_sync_unit = 1;
1047 if (!m->params_valid) {
1048 av_log(m->avctx, AV_LOG_WARNING,
1049 "Stream parameters not seen; skipping frame.\n");
1054 substream_start = 0;
1056 for (substr = 0; substr < m->num_substreams; substr++) {
1057 int extraword_present, checkdata_present, end, nonrestart_substr;
1059 extraword_present = get_bits1(&gb);
1060 nonrestart_substr = get_bits1(&gb);
1061 checkdata_present = get_bits1(&gb);
1064 end = get_bits(&gb, 12) * 2;
1066 substr_header_size += 2;
1068 if (extraword_present) {
1069 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1070 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1074 substr_header_size += 2;
1077 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1078 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1082 if (end + header_size + substr_header_size > length) {
1083 av_log(m->avctx, AV_LOG_ERROR,
1084 "Indicated length of substream %d data goes off end of "
1085 "packet.\n", substr);
1086 end = length - header_size - substr_header_size;
1089 if (end < substream_start) {
1090 av_log(avctx, AV_LOG_ERROR,
1091 "Indicated end offset of substream %d data "
1092 "is smaller than calculated start offset.\n",
1097 if (substr > m->max_decoded_substream)
1100 substream_parity_present[substr] = checkdata_present;
1101 substream_data_len[substr] = end - substream_start;
1102 substream_start = end;
1105 parity_bits = ff_mlp_calculate_parity(buf, 4);
1106 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1108 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1109 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1113 buf += header_size + substr_header_size;
1115 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1116 SubStream *s = &m->substream[substr];
1117 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1119 m->matrix_changed = 0;
1120 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1124 if (get_bits1(&gb)) {
1125 if (get_bits1(&gb)) {
1126 /* A restart header should be present. */
1127 if (read_restart_header(m, &gb, buf, substr) < 0)
1129 s->restart_seen = 1;
1132 if (!s->restart_seen)
1134 if (read_decoding_params(m, &gb, substr) < 0)
1138 if (!s->restart_seen)
1141 if ((ret = read_block_data(m, &gb, substr)) < 0)
1144 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1145 goto substream_length_mismatch;
1147 } while (!get_bits1(&gb));
1149 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1151 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1154 if (get_bits(&gb, 16) != 0xD234)
1155 return AVERROR_INVALIDDATA;
1157 shorten_by = get_bits(&gb, 16);
1158 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1159 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1160 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1161 return AVERROR_INVALIDDATA;
1163 if (substr == m->max_decoded_substream)
1164 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1167 if (substream_parity_present[substr]) {
1168 uint8_t parity, checksum;
1170 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1171 goto substream_length_mismatch;
1173 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1174 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1176 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1177 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1178 if ( get_bits(&gb, 8) != checksum)
1179 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1182 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1183 goto substream_length_mismatch;
1186 if (!s->restart_seen)
1187 av_log(m->avctx, AV_LOG_ERROR,
1188 "No restart header present in substream %d.\n", substr);
1190 buf += substream_data_len[substr];
1193 rematrix_channels(m, m->max_decoded_substream);
1195 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1200 substream_length_mismatch:
1201 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1202 return AVERROR_INVALIDDATA;
1205 m->params_valid = 0;
1206 return AVERROR_INVALIDDATA;
1209 #if CONFIG_MLP_DECODER
1210 AVCodec ff_mlp_decoder = {
1212 .type = AVMEDIA_TYPE_AUDIO,
1213 .id = AV_CODEC_ID_MLP,
1214 .priv_data_size = sizeof(MLPDecodeContext),
1215 .init = mlp_decode_init,
1216 .decode = read_access_unit,
1217 .capabilities = CODEC_CAP_DR1,
1218 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1221 #if CONFIG_TRUEHD_DECODER
1222 AVCodec ff_truehd_decoder = {
1224 .type = AVMEDIA_TYPE_AUDIO,
1225 .id = AV_CODEC_ID_TRUEHD,
1226 .priv_data_size = sizeof(MLPDecodeContext),
1227 .init = mlp_decode_init,
1228 .decode = read_access_unit,
1229 .capabilities = CODEC_CAP_DR1,
1230 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1232 #endif /* CONFIG_TRUEHD_DECODER */