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/internal.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/channel_layout.h"
35 #include "libavutil/crc.h"
37 #include "mlp_parser.h"
42 /** number of bits used for VLC lookup - longest Huffman code is 9 */
45 #define VLC_STATIC_SIZE 64
48 #define VLC_STATIC_SIZE 512
51 typedef struct SubStream {
52 /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
56 /** restart header data */
57 /// The type of noise to be used in the rematrix stage.
60 /// The index of the first channel coded in this substream.
62 /// The index of the last channel coded in this substream.
64 /// The number of channels input into the rematrix stage.
65 uint8_t max_matrix_channel;
66 /// For each channel output by the matrix, the output channel to map it to
67 uint8_t ch_assign[MAX_CHANNELS];
68 /// The channel layout for this substream
70 /// The matrix encoding mode for this substream
71 enum AVMatrixEncoding matrix_encoding;
73 /// Channel coding parameters for channels in the substream
74 ChannelParams channel_params[MAX_CHANNELS];
76 /// The left shift applied to random noise in 0x31ea substreams.
78 /// The current seed value for the pseudorandom noise generator(s).
79 uint32_t noisegen_seed;
81 /// Set if the substream contains extra info to check the size of VLC blocks.
82 uint8_t data_check_present;
84 /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
85 uint8_t param_presence_flags;
86 #define PARAM_BLOCKSIZE (1 << 7)
87 #define PARAM_MATRIX (1 << 6)
88 #define PARAM_OUTSHIFT (1 << 5)
89 #define PARAM_QUANTSTEP (1 << 4)
90 #define PARAM_FIR (1 << 3)
91 #define PARAM_IIR (1 << 2)
92 #define PARAM_HUFFOFFSET (1 << 1)
93 #define PARAM_PRESENCE (1 << 0)
99 /// Number of matrices to be applied.
100 uint8_t num_primitive_matrices;
102 /// matrix output channel
103 uint8_t matrix_out_ch[MAX_MATRICES];
105 /// Whether the LSBs of the matrix output are encoded in the bitstream.
106 uint8_t lsb_bypass[MAX_MATRICES];
107 /// Matrix coefficients, stored as 2.14 fixed point.
108 int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
109 /// Left shift to apply to noise values in 0x31eb substreams.
110 uint8_t matrix_noise_shift[MAX_MATRICES];
113 /// Left shift to apply to Huffman-decoded residuals.
114 uint8_t quant_step_size[MAX_CHANNELS];
116 /// number of PCM samples in current audio block
118 /// Number of PCM samples decoded so far in this frame.
121 /// Left shift to apply to decoded PCM values to get final 24-bit output.
122 int8_t output_shift[MAX_CHANNELS];
124 /// Running XOR of all output samples.
125 int32_t lossless_check_data;
129 typedef struct MLPDecodeContext {
130 AVCodecContext *avctx;
132 /// Current access unit being read has a major sync.
133 int is_major_sync_unit;
135 /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
136 uint8_t params_valid;
138 /// Number of substreams contained within this stream.
139 uint8_t num_substreams;
141 /// Index of the last substream to decode - further substreams are skipped.
142 uint8_t max_decoded_substream;
144 /// number of PCM samples contained in each frame
145 int access_unit_size;
146 /// next power of two above the number of samples in each frame
147 int access_unit_size_pow2;
149 SubStream substream[MAX_SUBSTREAMS];
152 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
154 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
155 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
156 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
161 static const uint64_t thd_channel_order[] = {
162 AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT, // LR
163 AV_CH_FRONT_CENTER, // C
164 AV_CH_LOW_FREQUENCY, // LFE
165 AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT, // LRs
166 AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT, // LRvh
167 AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
168 AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT, // LRrs
169 AV_CH_BACK_CENTER, // Cs
170 AV_CH_TOP_CENTER, // Ts
171 AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
172 AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT, // LRw
173 AV_CH_TOP_FRONT_CENTER, // Cvh
174 AV_CH_LOW_FREQUENCY_2, // LFE2
177 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
182 if (av_get_channel_layout_nb_channels(channel_layout) <= index)
185 for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
186 if (channel_layout & thd_channel_order[i] && !index--)
187 return thd_channel_order[i];
191 static VLC huff_vlc[3];
193 /** Initialize static data, constant between all invocations of the codec. */
195 static av_cold void init_static(void)
197 if (!huff_vlc[0].bits) {
198 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
199 &ff_mlp_huffman_tables[0][0][1], 2, 1,
200 &ff_mlp_huffman_tables[0][0][0], 2, 1, VLC_STATIC_SIZE);
201 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
202 &ff_mlp_huffman_tables[1][0][1], 2, 1,
203 &ff_mlp_huffman_tables[1][0][0], 2, 1, VLC_STATIC_SIZE);
204 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
205 &ff_mlp_huffman_tables[2][0][1], 2, 1,
206 &ff_mlp_huffman_tables[2][0][0], 2, 1, VLC_STATIC_SIZE);
212 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
213 unsigned int substr, unsigned int ch)
215 SubStream *s = &m->substream[substr];
216 ChannelParams *cp = &s->channel_params[ch];
217 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
218 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
219 int32_t sign_huff_offset = cp->huff_offset;
221 if (cp->codebook > 0)
222 sign_huff_offset -= 7 << lsb_bits;
225 sign_huff_offset -= 1 << sign_shift;
227 return sign_huff_offset;
230 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
233 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
234 unsigned int substr, unsigned int pos)
236 SubStream *s = &m->substream[substr];
237 unsigned int mat, channel;
239 for (mat = 0; mat < s->num_primitive_matrices; mat++)
240 if (s->lsb_bypass[mat])
241 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
243 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
244 ChannelParams *cp = &s->channel_params[channel];
245 int codebook = cp->codebook;
246 int quant_step_size = s->quant_step_size[channel];
247 int lsb_bits = cp->huff_lsbs - quant_step_size;
251 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
252 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
255 return AVERROR_INVALIDDATA;
258 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
260 result += cp->sign_huff_offset;
261 result <<= quant_step_size;
263 m->sample_buffer[pos + s->blockpos][channel] = result;
269 static av_cold int mlp_decode_init(AVCodecContext *avctx)
271 MLPDecodeContext *m = avctx->priv_data;
276 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
277 m->substream[substr].lossless_check_data = 0xffffffff;
278 ff_mlpdsp_init(&m->dsp);
283 /** Read a major sync info header - contains high level information about
284 * the stream - sample rate, channel arrangement etc. Most of this
285 * information is not actually necessary for decoding, only for playback.
288 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
293 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
296 if (mh.group1_bits == 0) {
297 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
298 return AVERROR_INVALIDDATA;
300 if (mh.group2_bits > mh.group1_bits) {
301 av_log(m->avctx, AV_LOG_ERROR,
302 "Channel group 2 cannot have more bits per sample than group 1.\n");
303 return AVERROR_INVALIDDATA;
306 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
307 av_log(m->avctx, AV_LOG_ERROR,
308 "Channel groups with differing sample rates are not currently supported.\n");
309 return AVERROR_INVALIDDATA;
312 if (mh.group1_samplerate == 0) {
313 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
314 return AVERROR_INVALIDDATA;
316 if (mh.group1_samplerate > MAX_SAMPLERATE) {
317 av_log(m->avctx, AV_LOG_ERROR,
318 "Sampling rate %d is greater than the supported maximum (%d).\n",
319 mh.group1_samplerate, MAX_SAMPLERATE);
320 return AVERROR_INVALIDDATA;
322 if (mh.access_unit_size > MAX_BLOCKSIZE) {
323 av_log(m->avctx, AV_LOG_ERROR,
324 "Block size %d is greater than the supported maximum (%d).\n",
325 mh.access_unit_size, MAX_BLOCKSIZE);
326 return AVERROR_INVALIDDATA;
328 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
329 av_log(m->avctx, AV_LOG_ERROR,
330 "Block size pow2 %d is greater than the supported maximum (%d).\n",
331 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
332 return AVERROR_INVALIDDATA;
335 if (mh.num_substreams == 0)
336 return AVERROR_INVALIDDATA;
337 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
338 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
339 return AVERROR_INVALIDDATA;
341 if (mh.num_substreams > MAX_SUBSTREAMS) {
342 avpriv_request_sample(m->avctx,
343 "%d substreams (more than the "
344 "maximum supported by the decoder)",
346 return AVERROR_PATCHWELCOME;
349 m->access_unit_size = mh.access_unit_size;
350 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
352 m->num_substreams = mh.num_substreams;
353 m->max_decoded_substream = m->num_substreams - 1;
355 m->avctx->sample_rate = mh.group1_samplerate;
356 m->avctx->frame_size = mh.access_unit_size;
358 m->avctx->bits_per_raw_sample = mh.group1_bits;
359 if (mh.group1_bits > 16)
360 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
362 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
363 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(m->substream[m->max_decoded_substream].ch_assign,
364 m->substream[m->max_decoded_substream].output_shift,
365 m->substream[m->max_decoded_substream].max_matrix_channel,
366 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
369 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
370 m->substream[substr].restart_seen = 0;
372 /* Set the layout for each substream. When there's more than one, the first
373 * substream is Stereo. Subsequent substreams' layouts are indicated in the
375 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
376 if ((substr = (mh.num_substreams > 1)))
377 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
378 m->substream[substr].ch_layout = mh.channel_layout_mlp;
380 if ((substr = (mh.num_substreams > 1)))
381 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
382 if (mh.num_substreams > 2)
383 if (mh.channel_layout_thd_stream2)
384 m->substream[2].ch_layout = mh.channel_layout_thd_stream2;
386 m->substream[2].ch_layout = mh.channel_layout_thd_stream1;
387 m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;
390 /* Parse the TrueHD decoder channel modifiers and set each substream's
391 * AVMatrixEncoding accordingly.
393 * The meaning of the modifiers depends on the channel layout:
395 * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
397 * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
399 * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
400 * layouts with an Ls/Rs channel pair
402 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
403 m->substream[substr].matrix_encoding = AV_MATRIX_ENCODING_NONE;
404 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
405 if (mh.num_substreams > 2 &&
406 mh.channel_layout_thd_stream2 & AV_CH_SIDE_LEFT &&
407 mh.channel_layout_thd_stream2 & AV_CH_SIDE_RIGHT &&
408 mh.channel_modifier_thd_stream2 == THD_CH_MODIFIER_SURROUNDEX)
409 m->substream[2].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
411 if (mh.num_substreams > 1 &&
412 mh.channel_layout_thd_stream1 & AV_CH_SIDE_LEFT &&
413 mh.channel_layout_thd_stream1 & AV_CH_SIDE_RIGHT &&
414 mh.channel_modifier_thd_stream1 == THD_CH_MODIFIER_SURROUNDEX)
415 m->substream[1].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
417 if (mh.num_substreams > 0)
418 switch (mh.channel_modifier_thd_stream0) {
419 case THD_CH_MODIFIER_LTRT:
420 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
422 case THD_CH_MODIFIER_LBINRBIN:
423 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
433 /** Read a restart header from a block in a substream. This contains parameters
434 * required to decode the audio that do not change very often. Generally
435 * (always) present only in blocks following a major sync. */
437 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
438 const uint8_t *buf, unsigned int substr)
440 SubStream *s = &m->substream[substr];
444 uint8_t lossless_check;
445 int start_count = get_bits_count(gbp);
446 int min_channel, max_channel, max_matrix_channel;
447 const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
448 ? MAX_MATRIX_CHANNEL_MLP
449 : MAX_MATRIX_CHANNEL_TRUEHD;
451 sync_word = get_bits(gbp, 13);
453 if (sync_word != 0x31ea >> 1) {
454 av_log(m->avctx, AV_LOG_ERROR,
455 "restart header sync incorrect (got 0x%04x)\n", sync_word);
456 return AVERROR_INVALIDDATA;
459 s->noise_type = get_bits1(gbp);
461 if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
462 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
463 return AVERROR_INVALIDDATA;
466 skip_bits(gbp, 16); /* Output timestamp */
468 min_channel = get_bits(gbp, 4);
469 max_channel = get_bits(gbp, 4);
470 max_matrix_channel = get_bits(gbp, 4);
472 if (max_matrix_channel > std_max_matrix_channel) {
473 av_log(m->avctx, AV_LOG_ERROR,
474 "Max matrix channel cannot be greater than %d.\n",
476 return AVERROR_INVALIDDATA;
479 if (max_channel != max_matrix_channel) {
480 av_log(m->avctx, AV_LOG_ERROR,
481 "Max channel must be equal max matrix channel.\n");
482 return AVERROR_INVALIDDATA;
485 /* This should happen for TrueHD streams with >6 channels and MLP's noise
486 * type. It is not yet known if this is allowed. */
487 if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
488 avpriv_request_sample(m->avctx,
489 "%d channels (more than the "
490 "maximum supported by the decoder)",
492 return AVERROR_PATCHWELCOME;
495 if (min_channel > max_channel) {
496 av_log(m->avctx, AV_LOG_ERROR,
497 "Substream min channel cannot be greater than max channel.\n");
498 return AVERROR_INVALIDDATA;
501 s->min_channel = min_channel;
502 s->max_channel = max_channel;
503 s->max_matrix_channel = max_matrix_channel;
505 #if FF_API_REQUEST_CHANNELS
506 FF_DISABLE_DEPRECATION_WARNINGS
507 if (m->avctx->request_channels > 0 &&
508 m->avctx->request_channels <= s->max_channel + 1 &&
509 m->max_decoded_substream > substr) {
510 av_log(m->avctx, AV_LOG_DEBUG,
511 "Extracting %d-channel downmix from substream %d. "
512 "Further substreams will be skipped.\n",
513 s->max_channel + 1, substr);
514 m->max_decoded_substream = substr;
516 FF_ENABLE_DEPRECATION_WARNINGS
518 if (m->avctx->request_channel_layout && (s->ch_layout & m->avctx->request_channel_layout) ==
519 m->avctx->request_channel_layout && m->max_decoded_substream > substr) {
520 av_log(m->avctx, AV_LOG_DEBUG,
521 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
522 "Further substreams will be skipped.\n",
523 s->max_channel + 1, s->ch_layout, substr);
524 m->max_decoded_substream = substr;
527 s->noise_shift = get_bits(gbp, 4);
528 s->noisegen_seed = get_bits(gbp, 23);
532 s->data_check_present = get_bits1(gbp);
533 lossless_check = get_bits(gbp, 8);
534 if (substr == m->max_decoded_substream
535 && s->lossless_check_data != 0xffffffff) {
536 tmp = xor_32_to_8(s->lossless_check_data);
537 if (tmp != lossless_check)
538 av_log(m->avctx, AV_LOG_WARNING,
539 "Lossless check failed - expected %02x, calculated %02x.\n",
540 lossless_check, tmp);
545 memset(s->ch_assign, 0, sizeof(s->ch_assign));
547 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
548 int ch_assign = get_bits(gbp, 6);
549 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
550 uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
552 ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
555 if (ch_assign > s->max_matrix_channel) {
556 avpriv_request_sample(m->avctx,
557 "Assignment of matrix channel %d to invalid output channel %d",
559 return AVERROR_PATCHWELCOME;
561 s->ch_assign[ch_assign] = ch;
564 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
566 if (checksum != get_bits(gbp, 8))
567 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
569 /* Set default decoding parameters. */
570 s->param_presence_flags = 0xff;
571 s->num_primitive_matrices = 0;
573 s->lossless_check_data = 0;
575 memset(s->output_shift , 0, sizeof(s->output_shift ));
576 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
578 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
579 ChannelParams *cp = &s->channel_params[ch];
580 cp->filter_params[FIR].order = 0;
581 cp->filter_params[IIR].order = 0;
582 cp->filter_params[FIR].shift = 0;
583 cp->filter_params[IIR].shift = 0;
585 /* Default audio coding is 24-bit raw PCM. */
587 cp->sign_huff_offset = (-1) << 23;
592 if (substr == m->max_decoded_substream) {
593 m->avctx->channels = s->max_matrix_channel + 1;
594 m->avctx->channel_layout = s->ch_layout;
595 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
597 s->max_matrix_channel,
598 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
604 /** Read parameters for one of the prediction filters. */
606 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
607 unsigned int substr, unsigned int channel,
610 SubStream *s = &m->substream[substr];
611 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
612 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
613 const char fchar = filter ? 'I' : 'F';
616 // Filter is 0 for FIR, 1 for IIR.
619 if (m->filter_changed[channel][filter]++ > 1) {
620 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
621 return AVERROR_INVALIDDATA;
624 order = get_bits(gbp, 4);
625 if (order > max_order) {
626 av_log(m->avctx, AV_LOG_ERROR,
627 "%cIR filter order %d is greater than maximum %d.\n",
628 fchar, order, max_order);
629 return AVERROR_INVALIDDATA;
634 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
635 int coeff_bits, coeff_shift;
637 fp->shift = get_bits(gbp, 4);
639 coeff_bits = get_bits(gbp, 5);
640 coeff_shift = get_bits(gbp, 3);
641 if (coeff_bits < 1 || coeff_bits > 16) {
642 av_log(m->avctx, AV_LOG_ERROR,
643 "%cIR filter coeff_bits must be between 1 and 16.\n",
645 return AVERROR_INVALIDDATA;
647 if (coeff_bits + coeff_shift > 16) {
648 av_log(m->avctx, AV_LOG_ERROR,
649 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
651 return AVERROR_INVALIDDATA;
654 for (i = 0; i < order; i++)
655 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
657 if (get_bits1(gbp)) {
658 int state_bits, state_shift;
661 av_log(m->avctx, AV_LOG_ERROR,
662 "FIR filter has state data specified.\n");
663 return AVERROR_INVALIDDATA;
666 state_bits = get_bits(gbp, 4);
667 state_shift = get_bits(gbp, 4);
669 /* TODO: Check validity of state data. */
671 for (i = 0; i < order; i++)
672 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
679 /** Read parameters for primitive matrices. */
681 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
683 SubStream *s = &m->substream[substr];
684 unsigned int mat, ch;
685 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
687 : MAX_MATRICES_TRUEHD;
689 if (m->matrix_changed++ > 1) {
690 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
691 return AVERROR_INVALIDDATA;
694 s->num_primitive_matrices = get_bits(gbp, 4);
696 if (s->num_primitive_matrices > max_primitive_matrices) {
697 av_log(m->avctx, AV_LOG_ERROR,
698 "Number of primitive matrices cannot be greater than %d.\n",
699 max_primitive_matrices);
700 return AVERROR_INVALIDDATA;
703 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
704 int frac_bits, max_chan;
705 s->matrix_out_ch[mat] = get_bits(gbp, 4);
706 frac_bits = get_bits(gbp, 4);
707 s->lsb_bypass [mat] = get_bits1(gbp);
709 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
710 av_log(m->avctx, AV_LOG_ERROR,
711 "Invalid channel %d specified as output from matrix.\n",
712 s->matrix_out_ch[mat]);
713 return AVERROR_INVALIDDATA;
715 if (frac_bits > 14) {
716 av_log(m->avctx, AV_LOG_ERROR,
717 "Too many fractional bits specified.\n");
718 return AVERROR_INVALIDDATA;
721 max_chan = s->max_matrix_channel;
725 for (ch = 0; ch <= max_chan; ch++) {
728 coeff_val = get_sbits(gbp, frac_bits + 2);
730 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
734 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
736 s->matrix_noise_shift[mat] = 0;
742 /** Read channel parameters. */
744 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
745 GetBitContext *gbp, unsigned int ch)
747 SubStream *s = &m->substream[substr];
748 ChannelParams *cp = &s->channel_params[ch];
749 FilterParams *fir = &cp->filter_params[FIR];
750 FilterParams *iir = &cp->filter_params[IIR];
753 if (s->param_presence_flags & PARAM_FIR)
755 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
758 if (s->param_presence_flags & PARAM_IIR)
760 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
763 if (fir->order + iir->order > 8) {
764 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
765 return AVERROR_INVALIDDATA;
768 if (fir->order && iir->order &&
769 fir->shift != iir->shift) {
770 av_log(m->avctx, AV_LOG_ERROR,
771 "FIR and IIR filters must use the same precision.\n");
772 return AVERROR_INVALIDDATA;
774 /* The FIR and IIR filters must have the same precision.
775 * To simplify the filtering code, only the precision of the
776 * FIR filter is considered. If only the IIR filter is employed,
777 * the FIR filter precision is set to that of the IIR filter, so
778 * that the filtering code can use it. */
779 if (!fir->order && iir->order)
780 fir->shift = iir->shift;
782 if (s->param_presence_flags & PARAM_HUFFOFFSET)
784 cp->huff_offset = get_sbits(gbp, 15);
786 cp->codebook = get_bits(gbp, 2);
787 cp->huff_lsbs = get_bits(gbp, 5);
789 if (cp->huff_lsbs > 24) {
790 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
791 return AVERROR_INVALIDDATA;
794 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
799 /** Read decoding parameters that change more often than those in the restart
802 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
805 SubStream *s = &m->substream[substr];
809 if (s->param_presence_flags & PARAM_PRESENCE)
811 s->param_presence_flags = get_bits(gbp, 8);
813 if (s->param_presence_flags & PARAM_BLOCKSIZE)
814 if (get_bits1(gbp)) {
815 s->blocksize = get_bits(gbp, 9);
816 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
817 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
819 return AVERROR_INVALIDDATA;
823 if (s->param_presence_flags & PARAM_MATRIX)
825 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
828 if (s->param_presence_flags & PARAM_OUTSHIFT)
829 if (get_bits1(gbp)) {
830 for (ch = 0; ch <= s->max_matrix_channel; ch++)
831 s->output_shift[ch] = get_sbits(gbp, 4);
832 if (substr == m->max_decoded_substream)
833 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
835 s->max_matrix_channel,
836 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
839 if (s->param_presence_flags & PARAM_QUANTSTEP)
841 for (ch = 0; ch <= s->max_channel; ch++) {
842 ChannelParams *cp = &s->channel_params[ch];
844 s->quant_step_size[ch] = get_bits(gbp, 4);
846 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
849 for (ch = s->min_channel; ch <= s->max_channel; ch++)
851 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
857 #define MSB_MASK(bits) (-1u << bits)
859 /** Generate PCM samples using the prediction filters and residual values
860 * read from the data stream, and update the filter state. */
862 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
863 unsigned int channel)
865 SubStream *s = &m->substream[substr];
866 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
867 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
868 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
869 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
870 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
871 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
872 unsigned int filter_shift = fir->shift;
873 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
875 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
876 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
878 m->dsp.mlp_filter_channel(firbuf, fircoeff,
879 fir->order, iir->order,
880 filter_shift, mask, s->blocksize,
881 &m->sample_buffer[s->blockpos][channel]);
883 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
884 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
887 /** Read a block of PCM residual data (or actual if no filtering active). */
889 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
892 SubStream *s = &m->substream[substr];
893 unsigned int i, ch, expected_stream_pos = 0;
896 if (s->data_check_present) {
897 expected_stream_pos = get_bits_count(gbp);
898 expected_stream_pos += get_bits(gbp, 16);
899 avpriv_request_sample(m->avctx,
900 "Substreams with VLC block size check info");
903 if (s->blockpos + s->blocksize > m->access_unit_size) {
904 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
905 return AVERROR_INVALIDDATA;
908 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
909 s->blocksize * sizeof(m->bypassed_lsbs[0]));
911 for (i = 0; i < s->blocksize; i++)
912 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
915 for (ch = s->min_channel; ch <= s->max_channel; ch++)
916 filter_channel(m, substr, ch);
918 s->blockpos += s->blocksize;
920 if (s->data_check_present) {
921 if (get_bits_count(gbp) != expected_stream_pos)
922 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
929 /** Data table used for TrueHD noise generation function. */
931 static const int8_t noise_table[256] = {
932 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
933 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
934 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
935 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
936 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
937 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
938 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
939 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
940 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
941 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
942 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
943 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
944 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
945 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
946 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
947 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
950 /** Noise generation functions.
951 * I'm not sure what these are for - they seem to be some kind of pseudorandom
952 * sequence generators, used to generate noise data which is used when the
953 * channels are rematrixed. I'm not sure if they provide a practical benefit
954 * to compression, or just obfuscate the decoder. Are they for some kind of
957 /** Generate two channels of noise, used in the matrix when
958 * restart sync word == 0x31ea. */
960 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
962 SubStream *s = &m->substream[substr];
964 uint32_t seed = s->noisegen_seed;
965 unsigned int maxchan = s->max_matrix_channel;
967 for (i = 0; i < s->blockpos; i++) {
968 uint16_t seed_shr7 = seed >> 7;
969 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
970 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
972 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
975 s->noisegen_seed = seed;
978 /** Generate a block of noise, used when restart sync word == 0x31eb. */
980 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
982 SubStream *s = &m->substream[substr];
984 uint32_t seed = s->noisegen_seed;
986 for (i = 0; i < m->access_unit_size_pow2; i++) {
987 uint8_t seed_shr15 = seed >> 15;
988 m->noise_buffer[i] = noise_table[seed_shr15];
989 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
992 s->noisegen_seed = seed;
996 /** Apply the channel matrices in turn to reconstruct the original audio
999 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
1001 SubStream *s = &m->substream[substr];
1003 unsigned int maxchan;
1005 maxchan = s->max_matrix_channel;
1006 if (!s->noise_type) {
1007 generate_2_noise_channels(m, substr);
1010 fill_noise_buffer(m, substr);
1013 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1014 unsigned int dest_ch = s->matrix_out_ch[mat];
1015 m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1016 s->matrix_coeff[mat],
1017 &m->bypassed_lsbs[0][mat],
1019 s->num_primitive_matrices - mat,
1023 s->matrix_noise_shift[mat],
1024 m->access_unit_size_pow2,
1025 MSB_MASK(s->quant_step_size[dest_ch]));
1029 /** Write the audio data into the output buffer. */
1031 static int output_data(MLPDecodeContext *m, unsigned int substr,
1032 AVFrame *frame, int *got_frame_ptr)
1034 AVCodecContext *avctx = m->avctx;
1035 SubStream *s = &m->substream[substr];
1037 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1039 if (m->avctx->channels != s->max_matrix_channel + 1) {
1040 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1041 return AVERROR_INVALIDDATA;
1045 av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1046 return AVERROR_INVALIDDATA;
1049 /* get output buffer */
1050 frame->nb_samples = s->blockpos;
1051 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1052 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1055 s->lossless_check_data = m->dsp.mlp_pack_output(s->lossless_check_data,
1061 s->max_matrix_channel,
1064 /* Update matrix encoding side data */
1065 if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1073 /** Read an access unit from the stream.
1074 * @return negative on error, 0 if not enough data is present in the input stream,
1075 * otherwise the number of bytes consumed. */
1077 static int read_access_unit(AVCodecContext *avctx, void* data,
1078 int *got_frame_ptr, AVPacket *avpkt)
1080 const uint8_t *buf = avpkt->data;
1081 int buf_size = avpkt->size;
1082 MLPDecodeContext *m = avctx->priv_data;
1084 unsigned int length, substr;
1085 unsigned int substream_start;
1086 unsigned int header_size = 4;
1087 unsigned int substr_header_size = 0;
1088 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1089 uint16_t substream_data_len[MAX_SUBSTREAMS];
1090 uint8_t parity_bits;
1096 length = (AV_RB16(buf) & 0xfff) * 2;
1098 if (length < 4 || length > buf_size)
1099 return AVERROR_INVALIDDATA;
1101 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1103 m->is_major_sync_unit = 0;
1104 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1105 if (read_major_sync(m, &gb) < 0)
1107 m->is_major_sync_unit = 1;
1111 if (!m->params_valid) {
1112 av_log(m->avctx, AV_LOG_WARNING,
1113 "Stream parameters not seen; skipping frame.\n");
1118 substream_start = 0;
1120 for (substr = 0; substr < m->num_substreams; substr++) {
1121 int extraword_present, checkdata_present, end, nonrestart_substr;
1123 extraword_present = get_bits1(&gb);
1124 nonrestart_substr = get_bits1(&gb);
1125 checkdata_present = get_bits1(&gb);
1128 end = get_bits(&gb, 12) * 2;
1130 substr_header_size += 2;
1132 if (extraword_present) {
1133 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1134 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1138 substr_header_size += 2;
1141 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1142 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1146 if (end + header_size + substr_header_size > length) {
1147 av_log(m->avctx, AV_LOG_ERROR,
1148 "Indicated length of substream %d data goes off end of "
1149 "packet.\n", substr);
1150 end = length - header_size - substr_header_size;
1153 if (end < substream_start) {
1154 av_log(avctx, AV_LOG_ERROR,
1155 "Indicated end offset of substream %d data "
1156 "is smaller than calculated start offset.\n",
1161 if (substr > m->max_decoded_substream)
1164 substream_parity_present[substr] = checkdata_present;
1165 substream_data_len[substr] = end - substream_start;
1166 substream_start = end;
1169 parity_bits = ff_mlp_calculate_parity(buf, 4);
1170 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1172 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1173 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1177 buf += header_size + substr_header_size;
1179 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1180 SubStream *s = &m->substream[substr];
1181 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1183 m->matrix_changed = 0;
1184 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1188 if (get_bits1(&gb)) {
1189 if (get_bits1(&gb)) {
1190 /* A restart header should be present. */
1191 if (read_restart_header(m, &gb, buf, substr) < 0)
1193 s->restart_seen = 1;
1196 if (!s->restart_seen)
1198 if (read_decoding_params(m, &gb, substr) < 0)
1202 if (!s->restart_seen)
1205 if ((ret = read_block_data(m, &gb, substr)) < 0)
1208 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1209 goto substream_length_mismatch;
1211 } while (!get_bits1(&gb));
1213 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1215 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1218 if (get_bits(&gb, 16) != 0xD234)
1219 return AVERROR_INVALIDDATA;
1221 shorten_by = get_bits(&gb, 16);
1222 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1223 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1224 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1225 return AVERROR_INVALIDDATA;
1227 if (substr == m->max_decoded_substream)
1228 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1231 if (substream_parity_present[substr]) {
1232 uint8_t parity, checksum;
1234 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1235 goto substream_length_mismatch;
1237 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1238 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1240 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1241 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1242 if ( get_bits(&gb, 8) != checksum)
1243 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1246 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1247 goto substream_length_mismatch;
1250 if (!s->restart_seen)
1251 av_log(m->avctx, AV_LOG_ERROR,
1252 "No restart header present in substream %d.\n", substr);
1254 buf += substream_data_len[substr];
1257 rematrix_channels(m, m->max_decoded_substream);
1259 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1264 substream_length_mismatch:
1265 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1266 return AVERROR_INVALIDDATA;
1269 m->params_valid = 0;
1270 return AVERROR_INVALIDDATA;
1273 AVCodec ff_mlp_decoder = {
1275 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1276 .type = AVMEDIA_TYPE_AUDIO,
1277 .id = AV_CODEC_ID_MLP,
1278 .priv_data_size = sizeof(MLPDecodeContext),
1279 .init = mlp_decode_init,
1280 .decode = read_access_unit,
1281 .capabilities = CODEC_CAP_DR1,
1284 #if CONFIG_TRUEHD_DECODER
1285 AVCodec ff_truehd_decoder = {
1287 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1288 .type = AVMEDIA_TYPE_AUDIO,
1289 .id = AV_CODEC_ID_TRUEHD,
1290 .priv_data_size = sizeof(MLPDecodeContext),
1291 .init = mlp_decode_init,
1292 .decode = read_access_unit,
1293 .capabilities = CODEC_CAP_DR1,
1295 #endif /* CONFIG_TRUEHD_DECODER */