3 * Copyright (c) 2007-2008 Ian Caulfield
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; 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 /// number of PCM samples contained in each frame
133 int access_unit_size;
134 /// next power of two above the number of samples in each frame
135 int access_unit_size_pow2;
137 SubStream substream[MAX_SUBSTREAMS];
140 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
142 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
143 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
144 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
149 static VLC huff_vlc[3];
151 /** Initialize static data, constant between all invocations of the codec. */
153 static av_cold void init_static(void)
155 if (!huff_vlc[0].bits) {
156 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
157 &ff_mlp_huffman_tables[0][0][1], 2, 1,
158 &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
159 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
160 &ff_mlp_huffman_tables[1][0][1], 2, 1,
161 &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
162 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
163 &ff_mlp_huffman_tables[2][0][1], 2, 1,
164 &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
170 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
171 unsigned int substr, unsigned int ch)
173 SubStream *s = &m->substream[substr];
174 ChannelParams *cp = &s->channel_params[ch];
175 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
176 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
177 int32_t sign_huff_offset = cp->huff_offset;
179 if (cp->codebook > 0)
180 sign_huff_offset -= 7 << lsb_bits;
183 sign_huff_offset -= 1 << sign_shift;
185 return sign_huff_offset;
188 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
191 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
192 unsigned int substr, unsigned int pos)
194 SubStream *s = &m->substream[substr];
195 unsigned int mat, channel;
197 for (mat = 0; mat < s->num_primitive_matrices; mat++)
198 if (s->lsb_bypass[mat])
199 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
201 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
202 ChannelParams *cp = &s->channel_params[channel];
203 int codebook = cp->codebook;
204 int quant_step_size = s->quant_step_size[channel];
205 int lsb_bits = cp->huff_lsbs - quant_step_size;
209 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
210 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
213 return AVERROR_INVALIDDATA;
216 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
218 result += cp->sign_huff_offset;
219 result <<= quant_step_size;
221 m->sample_buffer[pos + s->blockpos][channel] = result;
227 static av_cold int mlp_decode_init(AVCodecContext *avctx)
229 MLPDecodeContext *m = avctx->priv_data;
234 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
235 m->substream[substr].lossless_check_data = 0xffffffff;
236 ff_mlpdsp_init(&m->dsp);
238 avcodec_get_frame_defaults(&m->frame);
239 avctx->coded_frame = &m->frame;
244 /** Read a major sync info header - contains high level information about
245 * the stream - sample rate, channel arrangement etc. Most of this
246 * information is not actually necessary for decoding, only for playback.
249 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
254 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
257 if (mh.group1_bits == 0) {
258 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
259 return AVERROR_INVALIDDATA;
261 if (mh.group2_bits > mh.group1_bits) {
262 av_log(m->avctx, AV_LOG_ERROR,
263 "Channel group 2 cannot have more bits per sample than group 1.\n");
264 return AVERROR_INVALIDDATA;
267 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
268 av_log(m->avctx, AV_LOG_ERROR,
269 "Channel groups with differing sample rates are not currently supported.\n");
270 return AVERROR_INVALIDDATA;
273 if (mh.group1_samplerate == 0) {
274 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
275 return AVERROR_INVALIDDATA;
277 if (mh.group1_samplerate > MAX_SAMPLERATE) {
278 av_log(m->avctx, AV_LOG_ERROR,
279 "Sampling rate %d is greater than the supported maximum (%d).\n",
280 mh.group1_samplerate, MAX_SAMPLERATE);
281 return AVERROR_INVALIDDATA;
283 if (mh.access_unit_size > MAX_BLOCKSIZE) {
284 av_log(m->avctx, AV_LOG_ERROR,
285 "Block size %d is greater than the supported maximum (%d).\n",
286 mh.access_unit_size, MAX_BLOCKSIZE);
287 return AVERROR_INVALIDDATA;
289 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
290 av_log(m->avctx, AV_LOG_ERROR,
291 "Block size pow2 %d is greater than the supported maximum (%d).\n",
292 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
293 return AVERROR_INVALIDDATA;
296 if (mh.num_substreams == 0)
297 return AVERROR_INVALIDDATA;
298 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
299 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
300 return AVERROR_INVALIDDATA;
302 if (mh.num_substreams > MAX_SUBSTREAMS) {
303 av_log_ask_for_sample(m->avctx,
304 "Number of substreams %d is larger than the maximum supported "
305 "by the decoder.\n", mh.num_substreams);
306 return AVERROR_PATCHWELCOME;
309 m->access_unit_size = mh.access_unit_size;
310 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
312 m->num_substreams = mh.num_substreams;
313 m->max_decoded_substream = m->num_substreams - 1;
315 m->avctx->sample_rate = mh.group1_samplerate;
316 m->avctx->frame_size = mh.access_unit_size;
318 m->avctx->bits_per_raw_sample = mh.group1_bits;
319 if (mh.group1_bits > 16)
320 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
322 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
325 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
326 m->substream[substr].restart_seen = 0;
331 /** Read a restart header from a block in a substream. This contains parameters
332 * required to decode the audio that do not change very often. Generally
333 * (always) present only in blocks following a major sync. */
335 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
336 const uint8_t *buf, unsigned int substr)
338 SubStream *s = &m->substream[substr];
342 uint8_t lossless_check;
343 int start_count = get_bits_count(gbp);
344 const int max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
345 ? MAX_MATRIX_CHANNEL_MLP
346 : MAX_MATRIX_CHANNEL_TRUEHD;
348 sync_word = get_bits(gbp, 13);
350 if (sync_word != 0x31ea >> 1) {
351 av_log(m->avctx, AV_LOG_ERROR,
352 "restart header sync incorrect (got 0x%04x)\n", sync_word);
353 return AVERROR_INVALIDDATA;
356 s->noise_type = get_bits1(gbp);
358 if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
359 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
360 return AVERROR_INVALIDDATA;
363 skip_bits(gbp, 16); /* Output timestamp */
365 s->min_channel = get_bits(gbp, 4);
366 s->max_channel = get_bits(gbp, 4);
367 s->max_matrix_channel = get_bits(gbp, 4);
369 if (s->max_matrix_channel > max_matrix_channel) {
370 av_log(m->avctx, AV_LOG_ERROR,
371 "Max matrix channel cannot be greater than %d.\n",
373 return AVERROR_INVALIDDATA;
376 if (s->max_channel != s->max_matrix_channel) {
377 av_log(m->avctx, AV_LOG_ERROR,
378 "Max channel must be equal max matrix channel.\n");
379 return AVERROR_INVALIDDATA;
382 /* This should happen for TrueHD streams with >6 channels and MLP's noise
383 * type. It is not yet known if this is allowed. */
384 if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
385 av_log_ask_for_sample(m->avctx,
386 "Number of channels %d is larger than the maximum supported "
387 "by the decoder.\n", s->max_channel + 2);
388 return AVERROR_PATCHWELCOME;
391 if (s->min_channel > s->max_channel) {
392 av_log(m->avctx, AV_LOG_ERROR,
393 "Substream min channel cannot be greater than max channel.\n");
394 return AVERROR_INVALIDDATA;
397 if (m->avctx->request_channels > 0
398 && s->max_channel + 1 >= m->avctx->request_channels
399 && substr < m->max_decoded_substream) {
400 av_log(m->avctx, AV_LOG_DEBUG,
401 "Extracting %d channel downmix from substream %d. "
402 "Further substreams will be skipped.\n",
403 s->max_channel + 1, substr);
404 m->max_decoded_substream = substr;
407 s->noise_shift = get_bits(gbp, 4);
408 s->noisegen_seed = get_bits(gbp, 23);
412 s->data_check_present = get_bits1(gbp);
413 lossless_check = get_bits(gbp, 8);
414 if (substr == m->max_decoded_substream
415 && s->lossless_check_data != 0xffffffff) {
416 tmp = xor_32_to_8(s->lossless_check_data);
417 if (tmp != lossless_check)
418 av_log(m->avctx, AV_LOG_WARNING,
419 "Lossless check failed - expected %02x, calculated %02x.\n",
420 lossless_check, tmp);
425 memset(s->ch_assign, 0, sizeof(s->ch_assign));
427 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
428 int ch_assign = get_bits(gbp, 6);
429 if (ch_assign > s->max_matrix_channel) {
430 av_log_ask_for_sample(m->avctx,
431 "Assignment of matrix channel %d to invalid output channel %d.\n",
433 return AVERROR_PATCHWELCOME;
435 s->ch_assign[ch_assign] = ch;
438 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
440 if (checksum != get_bits(gbp, 8))
441 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
443 /* Set default decoding parameters. */
444 s->param_presence_flags = 0xff;
445 s->num_primitive_matrices = 0;
447 s->lossless_check_data = 0;
449 memset(s->output_shift , 0, sizeof(s->output_shift ));
450 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
452 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
453 ChannelParams *cp = &s->channel_params[ch];
454 cp->filter_params[FIR].order = 0;
455 cp->filter_params[IIR].order = 0;
456 cp->filter_params[FIR].shift = 0;
457 cp->filter_params[IIR].shift = 0;
459 /* Default audio coding is 24-bit raw PCM. */
461 cp->sign_huff_offset = (-1) << 23;
466 if (substr == m->max_decoded_substream)
467 m->avctx->channels = s->max_matrix_channel + 1;
472 /** Read parameters for one of the prediction filters. */
474 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
475 unsigned int substr, unsigned int channel,
478 SubStream *s = &m->substream[substr];
479 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
480 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
481 const char fchar = filter ? 'I' : 'F';
484 // Filter is 0 for FIR, 1 for IIR.
487 if (m->filter_changed[channel][filter]++ > 1) {
488 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
489 return AVERROR_INVALIDDATA;
492 order = get_bits(gbp, 4);
493 if (order > max_order) {
494 av_log(m->avctx, AV_LOG_ERROR,
495 "%cIR filter order %d is greater than maximum %d.\n",
496 fchar, order, max_order);
497 return AVERROR_INVALIDDATA;
502 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
503 int coeff_bits, coeff_shift;
505 fp->shift = get_bits(gbp, 4);
507 coeff_bits = get_bits(gbp, 5);
508 coeff_shift = get_bits(gbp, 3);
509 if (coeff_bits < 1 || coeff_bits > 16) {
510 av_log(m->avctx, AV_LOG_ERROR,
511 "%cIR filter coeff_bits must be between 1 and 16.\n",
513 return AVERROR_INVALIDDATA;
515 if (coeff_bits + coeff_shift > 16) {
516 av_log(m->avctx, AV_LOG_ERROR,
517 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
519 return AVERROR_INVALIDDATA;
522 for (i = 0; i < order; i++)
523 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
525 if (get_bits1(gbp)) {
526 int state_bits, state_shift;
529 av_log(m->avctx, AV_LOG_ERROR,
530 "FIR filter has state data specified.\n");
531 return AVERROR_INVALIDDATA;
534 state_bits = get_bits(gbp, 4);
535 state_shift = get_bits(gbp, 4);
537 /* TODO: Check validity of state data. */
539 for (i = 0; i < order; i++)
540 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
547 /** Read parameters for primitive matrices. */
549 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
551 SubStream *s = &m->substream[substr];
552 unsigned int mat, ch;
553 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
555 : MAX_MATRICES_TRUEHD;
557 if (m->matrix_changed++ > 1) {
558 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
559 return AVERROR_INVALIDDATA;
562 s->num_primitive_matrices = get_bits(gbp, 4);
564 if (s->num_primitive_matrices > max_primitive_matrices) {
565 av_log(m->avctx, AV_LOG_ERROR,
566 "Number of primitive matrices cannot be greater than %d.\n",
567 max_primitive_matrices);
568 return AVERROR_INVALIDDATA;
571 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
572 int frac_bits, max_chan;
573 s->matrix_out_ch[mat] = get_bits(gbp, 4);
574 frac_bits = get_bits(gbp, 4);
575 s->lsb_bypass [mat] = get_bits1(gbp);
577 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
578 av_log(m->avctx, AV_LOG_ERROR,
579 "Invalid channel %d specified as output from matrix.\n",
580 s->matrix_out_ch[mat]);
581 return AVERROR_INVALIDDATA;
583 if (frac_bits > 14) {
584 av_log(m->avctx, AV_LOG_ERROR,
585 "Too many fractional bits specified.\n");
586 return AVERROR_INVALIDDATA;
589 max_chan = s->max_matrix_channel;
593 for (ch = 0; ch <= max_chan; ch++) {
596 coeff_val = get_sbits(gbp, frac_bits + 2);
598 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
602 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
604 s->matrix_noise_shift[mat] = 0;
610 /** Read channel parameters. */
612 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
613 GetBitContext *gbp, unsigned int ch)
615 SubStream *s = &m->substream[substr];
616 ChannelParams *cp = &s->channel_params[ch];
617 FilterParams *fir = &cp->filter_params[FIR];
618 FilterParams *iir = &cp->filter_params[IIR];
621 if (s->param_presence_flags & PARAM_FIR)
623 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
626 if (s->param_presence_flags & PARAM_IIR)
628 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
631 if (fir->order + iir->order > 8) {
632 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
633 return AVERROR_INVALIDDATA;
636 if (fir->order && iir->order &&
637 fir->shift != iir->shift) {
638 av_log(m->avctx, AV_LOG_ERROR,
639 "FIR and IIR filters must use the same precision.\n");
640 return AVERROR_INVALIDDATA;
642 /* The FIR and IIR filters must have the same precision.
643 * To simplify the filtering code, only the precision of the
644 * FIR filter is considered. If only the IIR filter is employed,
645 * the FIR filter precision is set to that of the IIR filter, so
646 * that the filtering code can use it. */
647 if (!fir->order && iir->order)
648 fir->shift = iir->shift;
650 if (s->param_presence_flags & PARAM_HUFFOFFSET)
652 cp->huff_offset = get_sbits(gbp, 15);
654 cp->codebook = get_bits(gbp, 2);
655 cp->huff_lsbs = get_bits(gbp, 5);
657 if (cp->huff_lsbs > 24) {
658 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
659 return AVERROR_INVALIDDATA;
662 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
667 /** Read decoding parameters that change more often than those in the restart
670 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
673 SubStream *s = &m->substream[substr];
677 if (s->param_presence_flags & PARAM_PRESENCE)
679 s->param_presence_flags = get_bits(gbp, 8);
681 if (s->param_presence_flags & PARAM_BLOCKSIZE)
682 if (get_bits1(gbp)) {
683 s->blocksize = get_bits(gbp, 9);
684 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
685 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
687 return AVERROR_INVALIDDATA;
691 if (s->param_presence_flags & PARAM_MATRIX)
693 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
696 if (s->param_presence_flags & PARAM_OUTSHIFT)
698 for (ch = 0; ch <= s->max_matrix_channel; ch++)
699 s->output_shift[ch] = get_sbits(gbp, 4);
701 if (s->param_presence_flags & PARAM_QUANTSTEP)
703 for (ch = 0; ch <= s->max_channel; ch++) {
704 ChannelParams *cp = &s->channel_params[ch];
706 s->quant_step_size[ch] = get_bits(gbp, 4);
708 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
711 for (ch = s->min_channel; ch <= s->max_channel; ch++)
713 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
719 #define MSB_MASK(bits) (-1u << bits)
721 /** Generate PCM samples using the prediction filters and residual values
722 * read from the data stream, and update the filter state. */
724 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
725 unsigned int channel)
727 SubStream *s = &m->substream[substr];
728 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
729 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
730 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
731 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
732 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
733 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
734 unsigned int filter_shift = fir->shift;
735 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
737 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
738 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
740 m->dsp.mlp_filter_channel(firbuf, fircoeff,
741 fir->order, iir->order,
742 filter_shift, mask, s->blocksize,
743 &m->sample_buffer[s->blockpos][channel]);
745 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
746 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
749 /** Read a block of PCM residual data (or actual if no filtering active). */
751 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
754 SubStream *s = &m->substream[substr];
755 unsigned int i, ch, expected_stream_pos = 0;
758 if (s->data_check_present) {
759 expected_stream_pos = get_bits_count(gbp);
760 expected_stream_pos += get_bits(gbp, 16);
761 av_log_ask_for_sample(m->avctx, "This file contains some features "
762 "we have not tested yet.\n");
765 if (s->blockpos + s->blocksize > m->access_unit_size) {
766 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
767 return AVERROR_INVALIDDATA;
770 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
771 s->blocksize * sizeof(m->bypassed_lsbs[0]));
773 for (i = 0; i < s->blocksize; i++)
774 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
777 for (ch = s->min_channel; ch <= s->max_channel; ch++)
778 filter_channel(m, substr, ch);
780 s->blockpos += s->blocksize;
782 if (s->data_check_present) {
783 if (get_bits_count(gbp) != expected_stream_pos)
784 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
791 /** Data table used for TrueHD noise generation function. */
793 static const int8_t noise_table[256] = {
794 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
795 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
796 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
797 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
798 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
799 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
800 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
801 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
802 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
803 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
804 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
805 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
806 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
807 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
808 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
809 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
812 /** Noise generation functions.
813 * I'm not sure what these are for - they seem to be some kind of pseudorandom
814 * sequence generators, used to generate noise data which is used when the
815 * channels are rematrixed. I'm not sure if they provide a practical benefit
816 * to compression, or just obfuscate the decoder. Are they for some kind of
819 /** Generate two channels of noise, used in the matrix when
820 * restart sync word == 0x31ea. */
822 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
824 SubStream *s = &m->substream[substr];
826 uint32_t seed = s->noisegen_seed;
827 unsigned int maxchan = s->max_matrix_channel;
829 for (i = 0; i < s->blockpos; i++) {
830 uint16_t seed_shr7 = seed >> 7;
831 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
832 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
834 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
837 s->noisegen_seed = seed;
840 /** Generate a block of noise, used when restart sync word == 0x31eb. */
842 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
844 SubStream *s = &m->substream[substr];
846 uint32_t seed = s->noisegen_seed;
848 for (i = 0; i < m->access_unit_size_pow2; i++) {
849 uint8_t seed_shr15 = seed >> 15;
850 m->noise_buffer[i] = noise_table[seed_shr15];
851 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
854 s->noisegen_seed = seed;
858 /** Apply the channel matrices in turn to reconstruct the original audio
861 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
863 SubStream *s = &m->substream[substr];
864 unsigned int mat, src_ch, i;
865 unsigned int maxchan;
867 maxchan = s->max_matrix_channel;
868 if (!s->noise_type) {
869 generate_2_noise_channels(m, substr);
872 fill_noise_buffer(m, substr);
875 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
876 int matrix_noise_shift = s->matrix_noise_shift[mat];
877 unsigned int dest_ch = s->matrix_out_ch[mat];
878 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
879 int32_t *coeffs = s->matrix_coeff[mat];
880 int index = s->num_primitive_matrices - mat;
881 int index2 = 2 * index + 1;
883 /* TODO: DSPContext? */
885 for (i = 0; i < s->blockpos; i++) {
886 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
887 int32_t *samples = m->sample_buffer[i];
890 for (src_ch = 0; src_ch <= maxchan; src_ch++)
891 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
893 if (matrix_noise_shift) {
894 index &= m->access_unit_size_pow2 - 1;
895 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
899 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
904 /** Write the audio data into the output buffer. */
906 static int output_data(MLPDecodeContext *m, unsigned int substr,
907 void *data, int *got_frame_ptr)
909 AVCodecContext *avctx = m->avctx;
910 SubStream *s = &m->substream[substr];
911 unsigned int i, out_ch = 0;
915 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
917 if (m->avctx->channels != s->max_matrix_channel + 1) {
918 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
919 return AVERROR_INVALIDDATA;
922 /* get output buffer */
923 m->frame.nb_samples = s->blockpos;
924 if ((ret = ff_get_buffer(avctx, &m->frame)) < 0) {
925 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
928 data_32 = (int32_t *)m->frame.data[0];
929 data_16 = (int16_t *)m->frame.data[0];
931 for (i = 0; i < s->blockpos; i++) {
932 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
933 int mat_ch = s->ch_assign[out_ch];
934 int32_t sample = m->sample_buffer[i][mat_ch]
935 << s->output_shift[mat_ch];
936 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
937 if (is32) *data_32++ = sample << 8;
938 else *data_16++ = sample >> 8;
943 *(AVFrame *)data = m->frame;
948 /** Read an access unit from the stream.
949 * @return negative on error, 0 if not enough data is present in the input stream,
950 * otherwise the number of bytes consumed. */
952 static int read_access_unit(AVCodecContext *avctx, void* data,
953 int *got_frame_ptr, AVPacket *avpkt)
955 const uint8_t *buf = avpkt->data;
956 int buf_size = avpkt->size;
957 MLPDecodeContext *m = avctx->priv_data;
959 unsigned int length, substr;
960 unsigned int substream_start;
961 unsigned int header_size = 4;
962 unsigned int substr_header_size = 0;
963 uint8_t substream_parity_present[MAX_SUBSTREAMS];
964 uint16_t substream_data_len[MAX_SUBSTREAMS];
971 length = (AV_RB16(buf) & 0xfff) * 2;
973 if (length < 4 || length > buf_size)
974 return AVERROR_INVALIDDATA;
976 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
978 m->is_major_sync_unit = 0;
979 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
980 if (read_major_sync(m, &gb) < 0)
982 m->is_major_sync_unit = 1;
986 if (!m->params_valid) {
987 av_log(m->avctx, AV_LOG_WARNING,
988 "Stream parameters not seen; skipping frame.\n");
995 for (substr = 0; substr < m->num_substreams; substr++) {
996 int extraword_present, checkdata_present, end, nonrestart_substr;
998 extraword_present = get_bits1(&gb);
999 nonrestart_substr = get_bits1(&gb);
1000 checkdata_present = get_bits1(&gb);
1003 end = get_bits(&gb, 12) * 2;
1005 substr_header_size += 2;
1007 if (extraword_present) {
1008 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1009 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1013 substr_header_size += 2;
1016 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1017 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1021 if (end + header_size + substr_header_size > length) {
1022 av_log(m->avctx, AV_LOG_ERROR,
1023 "Indicated length of substream %d data goes off end of "
1024 "packet.\n", substr);
1025 end = length - header_size - substr_header_size;
1028 if (end < substream_start) {
1029 av_log(avctx, AV_LOG_ERROR,
1030 "Indicated end offset of substream %d data "
1031 "is smaller than calculated start offset.\n",
1036 if (substr > m->max_decoded_substream)
1039 substream_parity_present[substr] = checkdata_present;
1040 substream_data_len[substr] = end - substream_start;
1041 substream_start = end;
1044 parity_bits = ff_mlp_calculate_parity(buf, 4);
1045 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1047 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1048 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1052 buf += header_size + substr_header_size;
1054 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1055 SubStream *s = &m->substream[substr];
1056 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1058 m->matrix_changed = 0;
1059 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1063 if (get_bits1(&gb)) {
1064 if (get_bits1(&gb)) {
1065 /* A restart header should be present. */
1066 if (read_restart_header(m, &gb, buf, substr) < 0)
1068 s->restart_seen = 1;
1071 if (!s->restart_seen)
1073 if (read_decoding_params(m, &gb, substr) < 0)
1077 if (!s->restart_seen)
1080 if ((ret = read_block_data(m, &gb, substr)) < 0)
1083 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1084 goto substream_length_mismatch;
1086 } while (!get_bits1(&gb));
1088 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1090 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1093 if (get_bits(&gb, 16) != 0xD234)
1094 return AVERROR_INVALIDDATA;
1096 shorten_by = get_bits(&gb, 16);
1097 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1098 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1099 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1100 return AVERROR_INVALIDDATA;
1102 if (substr == m->max_decoded_substream)
1103 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1106 if (substream_parity_present[substr]) {
1107 uint8_t parity, checksum;
1109 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1110 goto substream_length_mismatch;
1112 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1113 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1115 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1116 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1117 if ( get_bits(&gb, 8) != checksum)
1118 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1121 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1122 goto substream_length_mismatch;
1125 if (!s->restart_seen)
1126 av_log(m->avctx, AV_LOG_ERROR,
1127 "No restart header present in substream %d.\n", substr);
1129 buf += substream_data_len[substr];
1132 rematrix_channels(m, m->max_decoded_substream);
1134 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1139 substream_length_mismatch:
1140 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1141 return AVERROR_INVALIDDATA;
1144 m->params_valid = 0;
1145 return AVERROR_INVALIDDATA;
1148 AVCodec ff_mlp_decoder = {
1150 .type = AVMEDIA_TYPE_AUDIO,
1151 .id = AV_CODEC_ID_MLP,
1152 .priv_data_size = sizeof(MLPDecodeContext),
1153 .init = mlp_decode_init,
1154 .decode = read_access_unit,
1155 .capabilities = CODEC_CAP_DR1,
1156 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1159 #if CONFIG_TRUEHD_DECODER
1160 AVCodec ff_truehd_decoder = {
1162 .type = AVMEDIA_TYPE_AUDIO,
1163 .id = AV_CODEC_ID_TRUEHD,
1164 .priv_data_size = sizeof(MLPDecodeContext),
1165 .init = mlp_decode_init,
1166 .decode = read_access_unit,
1167 .capabilities = CODEC_CAP_DR1,
1168 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1170 #endif /* CONFIG_TRUEHD_DECODER */