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"
41 /** number of bits used for VLC lookup - longest Huffman code is 9 */
44 typedef struct SubStream {
45 /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
49 /** restart header data */
50 /// The type of noise to be used in the rematrix stage.
53 /// The index of the first channel coded in this substream.
55 /// The index of the last channel coded in this substream.
57 /// The number of channels input into the rematrix stage.
58 uint8_t max_matrix_channel;
59 /// For each channel output by the matrix, the output channel to map it to
60 uint8_t ch_assign[MAX_CHANNELS];
61 /// The channel layout for this substream
63 /// The matrix encoding mode for this substream
64 enum AVMatrixEncoding matrix_encoding;
66 /// Channel coding parameters for channels in the substream
67 ChannelParams channel_params[MAX_CHANNELS];
69 /// The left shift applied to random noise in 0x31ea substreams.
71 /// The current seed value for the pseudorandom noise generator(s).
72 uint32_t noisegen_seed;
74 /// Set if the substream contains extra info to check the size of VLC blocks.
75 uint8_t data_check_present;
77 /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
78 uint8_t param_presence_flags;
79 #define PARAM_BLOCKSIZE (1 << 7)
80 #define PARAM_MATRIX (1 << 6)
81 #define PARAM_OUTSHIFT (1 << 5)
82 #define PARAM_QUANTSTEP (1 << 4)
83 #define PARAM_FIR (1 << 3)
84 #define PARAM_IIR (1 << 2)
85 #define PARAM_HUFFOFFSET (1 << 1)
86 #define PARAM_PRESENCE (1 << 0)
92 /// Number of matrices to be applied.
93 uint8_t num_primitive_matrices;
95 /// matrix output channel
96 uint8_t matrix_out_ch[MAX_MATRICES];
98 /// Whether the LSBs of the matrix output are encoded in the bitstream.
99 uint8_t lsb_bypass[MAX_MATRICES];
100 /// Matrix coefficients, stored as 2.14 fixed point.
101 int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
102 /// Left shift to apply to noise values in 0x31eb substreams.
103 uint8_t matrix_noise_shift[MAX_MATRICES];
106 /// Left shift to apply to Huffman-decoded residuals.
107 uint8_t quant_step_size[MAX_CHANNELS];
109 /// number of PCM samples in current audio block
111 /// Number of PCM samples decoded so far in this frame.
114 /// Left shift to apply to decoded PCM values to get final 24-bit output.
115 int8_t output_shift[MAX_CHANNELS];
117 /// Running XOR of all output samples.
118 int32_t lossless_check_data;
122 typedef struct MLPDecodeContext {
123 AVCodecContext *avctx;
125 /// Current access unit being read has a major sync.
126 int is_major_sync_unit;
128 /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
129 uint8_t params_valid;
131 /// Number of substreams contained within this stream.
132 uint8_t num_substreams;
134 /// Index of the last substream to decode - further substreams are skipped.
135 uint8_t max_decoded_substream;
137 /// number of PCM samples contained in each frame
138 int access_unit_size;
139 /// next power of two above the number of samples in each frame
140 int access_unit_size_pow2;
142 SubStream substream[MAX_SUBSTREAMS];
145 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
147 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
148 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
149 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
154 static const uint64_t thd_channel_order[] = {
155 AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT, // LR
156 AV_CH_FRONT_CENTER, // C
157 AV_CH_LOW_FREQUENCY, // LFE
158 AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT, // LRs
159 AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT, // LRvh
160 AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
161 AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT, // LRrs
162 AV_CH_BACK_CENTER, // Cs
163 AV_CH_TOP_CENTER, // Ts
164 AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
165 AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT, // LRw
166 AV_CH_TOP_FRONT_CENTER, // Cvh
167 AV_CH_LOW_FREQUENCY_2, // LFE2
170 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
175 if (av_get_channel_layout_nb_channels(channel_layout) <= index)
178 for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
179 if (channel_layout & thd_channel_order[i] && !index--)
180 return thd_channel_order[i];
184 static VLC huff_vlc[3];
186 /** Initialize static data, constant between all invocations of the codec. */
188 static av_cold void init_static(void)
190 if (!huff_vlc[0].bits) {
191 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
192 &ff_mlp_huffman_tables[0][0][1], 2, 1,
193 &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
194 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
195 &ff_mlp_huffman_tables[1][0][1], 2, 1,
196 &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
197 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
198 &ff_mlp_huffman_tables[2][0][1], 2, 1,
199 &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
205 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
206 unsigned int substr, unsigned int ch)
208 SubStream *s = &m->substream[substr];
209 ChannelParams *cp = &s->channel_params[ch];
210 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
211 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
212 int32_t sign_huff_offset = cp->huff_offset;
214 if (cp->codebook > 0)
215 sign_huff_offset -= 7 << lsb_bits;
218 sign_huff_offset -= 1 << sign_shift;
220 return sign_huff_offset;
223 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
226 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
227 unsigned int substr, unsigned int pos)
229 SubStream *s = &m->substream[substr];
230 unsigned int mat, channel;
232 for (mat = 0; mat < s->num_primitive_matrices; mat++)
233 if (s->lsb_bypass[mat])
234 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
236 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
237 ChannelParams *cp = &s->channel_params[channel];
238 int codebook = cp->codebook;
239 int quant_step_size = s->quant_step_size[channel];
240 int lsb_bits = cp->huff_lsbs - quant_step_size;
244 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
245 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
248 return AVERROR_INVALIDDATA;
251 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
253 result += cp->sign_huff_offset;
254 result <<= quant_step_size;
256 m->sample_buffer[pos + s->blockpos][channel] = result;
262 static av_cold int mlp_decode_init(AVCodecContext *avctx)
264 MLPDecodeContext *m = avctx->priv_data;
269 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
270 m->substream[substr].lossless_check_data = 0xffffffff;
271 ff_mlpdsp_init(&m->dsp);
276 /** Read a major sync info header - contains high level information about
277 * the stream - sample rate, channel arrangement etc. Most of this
278 * information is not actually necessary for decoding, only for playback.
281 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
286 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
289 if (mh.group1_bits == 0) {
290 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
291 return AVERROR_INVALIDDATA;
293 if (mh.group2_bits > mh.group1_bits) {
294 av_log(m->avctx, AV_LOG_ERROR,
295 "Channel group 2 cannot have more bits per sample than group 1.\n");
296 return AVERROR_INVALIDDATA;
299 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
300 av_log(m->avctx, AV_LOG_ERROR,
301 "Channel groups with differing sample rates are not currently supported.\n");
302 return AVERROR_INVALIDDATA;
305 if (mh.group1_samplerate == 0) {
306 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
307 return AVERROR_INVALIDDATA;
309 if (mh.group1_samplerate > MAX_SAMPLERATE) {
310 av_log(m->avctx, AV_LOG_ERROR,
311 "Sampling rate %d is greater than the supported maximum (%d).\n",
312 mh.group1_samplerate, MAX_SAMPLERATE);
313 return AVERROR_INVALIDDATA;
315 if (mh.access_unit_size > MAX_BLOCKSIZE) {
316 av_log(m->avctx, AV_LOG_ERROR,
317 "Block size %d is greater than the supported maximum (%d).\n",
318 mh.access_unit_size, MAX_BLOCKSIZE);
319 return AVERROR_INVALIDDATA;
321 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
322 av_log(m->avctx, AV_LOG_ERROR,
323 "Block size pow2 %d is greater than the supported maximum (%d).\n",
324 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
325 return AVERROR_INVALIDDATA;
328 if (mh.num_substreams == 0)
329 return AVERROR_INVALIDDATA;
330 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
331 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
332 return AVERROR_INVALIDDATA;
334 if (mh.num_substreams > MAX_SUBSTREAMS) {
335 avpriv_request_sample(m->avctx,
336 "%d substreams (more than the "
337 "maximum supported by the decoder)",
339 return AVERROR_PATCHWELCOME;
342 m->access_unit_size = mh.access_unit_size;
343 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
345 m->num_substreams = mh.num_substreams;
346 m->max_decoded_substream = m->num_substreams - 1;
348 m->avctx->sample_rate = mh.group1_samplerate;
349 m->avctx->frame_size = mh.access_unit_size;
351 m->avctx->bits_per_raw_sample = mh.group1_bits;
352 if (mh.group1_bits > 16)
353 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
355 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
358 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
359 m->substream[substr].restart_seen = 0;
361 /* Set the layout for each substream. When there's more than one, the first
362 * substream is Stereo. Subsequent substreams' layouts are indicated in the
364 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
365 if ((substr = (mh.num_substreams > 1)))
366 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
367 m->substream[substr].ch_layout = mh.channel_layout_mlp;
369 if ((substr = (mh.num_substreams > 1)))
370 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
371 if (mh.num_substreams > 2)
372 if (mh.channel_layout_thd_stream2)
373 m->substream[2].ch_layout = mh.channel_layout_thd_stream2;
375 m->substream[2].ch_layout = mh.channel_layout_thd_stream1;
376 m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;
379 /* Parse the TrueHD decoder channel modifiers and set each substream's
380 * AVMatrixEncoding accordingly.
382 * The meaning of the modifiers depends on the channel layout:
384 * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
386 * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
388 * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
389 * layouts with an Ls/Rs channel pair
391 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
392 m->substream[substr].matrix_encoding = AV_MATRIX_ENCODING_NONE;
393 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
394 if (mh.num_substreams > 2 &&
395 mh.channel_layout_thd_stream2 & AV_CH_SIDE_LEFT &&
396 mh.channel_layout_thd_stream2 & AV_CH_SIDE_RIGHT &&
397 mh.channel_modifier_thd_stream2 == THD_CH_MODIFIER_SURROUNDEX)
398 m->substream[2].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
400 if (mh.num_substreams > 1 &&
401 mh.channel_layout_thd_stream1 & AV_CH_SIDE_LEFT &&
402 mh.channel_layout_thd_stream1 & AV_CH_SIDE_RIGHT &&
403 mh.channel_modifier_thd_stream1 == THD_CH_MODIFIER_SURROUNDEX)
404 m->substream[1].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
406 if (mh.num_substreams > 0)
407 switch (mh.channel_modifier_thd_stream0) {
408 case THD_CH_MODIFIER_LTRT:
409 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
411 case THD_CH_MODIFIER_LBINRBIN:
412 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
422 /** Read a restart header from a block in a substream. This contains parameters
423 * required to decode the audio that do not change very often. Generally
424 * (always) present only in blocks following a major sync. */
426 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
427 const uint8_t *buf, unsigned int substr)
429 SubStream *s = &m->substream[substr];
433 uint8_t lossless_check;
434 int start_count = get_bits_count(gbp);
435 int min_channel, max_channel, max_matrix_channel;
436 const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
437 ? MAX_MATRIX_CHANNEL_MLP
438 : MAX_MATRIX_CHANNEL_TRUEHD;
440 sync_word = get_bits(gbp, 13);
442 if (sync_word != 0x31ea >> 1) {
443 av_log(m->avctx, AV_LOG_ERROR,
444 "restart header sync incorrect (got 0x%04x)\n", sync_word);
445 return AVERROR_INVALIDDATA;
448 s->noise_type = get_bits1(gbp);
450 if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
451 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
452 return AVERROR_INVALIDDATA;
455 skip_bits(gbp, 16); /* Output timestamp */
457 min_channel = get_bits(gbp, 4);
458 max_channel = get_bits(gbp, 4);
459 max_matrix_channel = get_bits(gbp, 4);
461 if (max_matrix_channel > std_max_matrix_channel) {
462 av_log(m->avctx, AV_LOG_ERROR,
463 "Max matrix channel cannot be greater than %d.\n",
465 return AVERROR_INVALIDDATA;
468 if (max_channel != max_matrix_channel) {
469 av_log(m->avctx, AV_LOG_ERROR,
470 "Max channel must be equal max matrix channel.\n");
471 return AVERROR_INVALIDDATA;
474 /* This should happen for TrueHD streams with >6 channels and MLP's noise
475 * type. It is not yet known if this is allowed. */
476 if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
477 avpriv_request_sample(m->avctx,
478 "%d channels (more than the "
479 "maximum supported by the decoder)",
481 return AVERROR_PATCHWELCOME;
484 if (min_channel > max_channel) {
485 av_log(m->avctx, AV_LOG_ERROR,
486 "Substream min channel cannot be greater than max channel.\n");
487 return AVERROR_INVALIDDATA;
490 s->min_channel = min_channel;
491 s->max_channel = max_channel;
492 s->max_matrix_channel = max_matrix_channel;
494 #if FF_API_REQUEST_CHANNELS
495 FF_DISABLE_DEPRECATION_WARNINGS
496 if (m->avctx->request_channels > 0 &&
497 m->avctx->request_channels <= s->max_channel + 1 &&
498 m->max_decoded_substream > substr) {
499 av_log(m->avctx, AV_LOG_DEBUG,
500 "Extracting %d-channel downmix from substream %d. "
501 "Further substreams will be skipped.\n",
502 s->max_channel + 1, substr);
503 m->max_decoded_substream = substr;
505 FF_ENABLE_DEPRECATION_WARNINGS
507 if (m->avctx->request_channel_layout == s->ch_layout &&
508 m->max_decoded_substream > substr) {
509 av_log(m->avctx, AV_LOG_DEBUG,
510 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
511 "Further substreams will be skipped.\n",
512 s->max_channel + 1, s->ch_layout, substr);
513 m->max_decoded_substream = substr;
516 s->noise_shift = get_bits(gbp, 4);
517 s->noisegen_seed = get_bits(gbp, 23);
521 s->data_check_present = get_bits1(gbp);
522 lossless_check = get_bits(gbp, 8);
523 if (substr == m->max_decoded_substream
524 && s->lossless_check_data != 0xffffffff) {
525 tmp = xor_32_to_8(s->lossless_check_data);
526 if (tmp != lossless_check)
527 av_log(m->avctx, AV_LOG_WARNING,
528 "Lossless check failed - expected %02x, calculated %02x.\n",
529 lossless_check, tmp);
534 memset(s->ch_assign, 0, sizeof(s->ch_assign));
536 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
537 int ch_assign = get_bits(gbp, 6);
538 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
539 uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
541 ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
544 if (ch_assign > s->max_matrix_channel) {
545 avpriv_request_sample(m->avctx,
546 "Assignment of matrix channel %d to invalid output channel %d",
548 return AVERROR_PATCHWELCOME;
550 s->ch_assign[ch_assign] = ch;
553 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
555 if (checksum != get_bits(gbp, 8))
556 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
558 /* Set default decoding parameters. */
559 s->param_presence_flags = 0xff;
560 s->num_primitive_matrices = 0;
562 s->lossless_check_data = 0;
564 memset(s->output_shift , 0, sizeof(s->output_shift ));
565 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
567 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
568 ChannelParams *cp = &s->channel_params[ch];
569 cp->filter_params[FIR].order = 0;
570 cp->filter_params[IIR].order = 0;
571 cp->filter_params[FIR].shift = 0;
572 cp->filter_params[IIR].shift = 0;
574 /* Default audio coding is 24-bit raw PCM. */
576 cp->sign_huff_offset = (-1) << 23;
581 if (substr == m->max_decoded_substream) {
582 m->avctx->channels = s->max_matrix_channel + 1;
583 m->avctx->channel_layout = s->ch_layout;
589 /** Read parameters for one of the prediction filters. */
591 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
592 unsigned int substr, unsigned int channel,
595 SubStream *s = &m->substream[substr];
596 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
597 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
598 const char fchar = filter ? 'I' : 'F';
601 // Filter is 0 for FIR, 1 for IIR.
604 if (m->filter_changed[channel][filter]++ > 1) {
605 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
606 return AVERROR_INVALIDDATA;
609 order = get_bits(gbp, 4);
610 if (order > max_order) {
611 av_log(m->avctx, AV_LOG_ERROR,
612 "%cIR filter order %d is greater than maximum %d.\n",
613 fchar, order, max_order);
614 return AVERROR_INVALIDDATA;
619 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
620 int coeff_bits, coeff_shift;
622 fp->shift = get_bits(gbp, 4);
624 coeff_bits = get_bits(gbp, 5);
625 coeff_shift = get_bits(gbp, 3);
626 if (coeff_bits < 1 || coeff_bits > 16) {
627 av_log(m->avctx, AV_LOG_ERROR,
628 "%cIR filter coeff_bits must be between 1 and 16.\n",
630 return AVERROR_INVALIDDATA;
632 if (coeff_bits + coeff_shift > 16) {
633 av_log(m->avctx, AV_LOG_ERROR,
634 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
636 return AVERROR_INVALIDDATA;
639 for (i = 0; i < order; i++)
640 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
642 if (get_bits1(gbp)) {
643 int state_bits, state_shift;
646 av_log(m->avctx, AV_LOG_ERROR,
647 "FIR filter has state data specified.\n");
648 return AVERROR_INVALIDDATA;
651 state_bits = get_bits(gbp, 4);
652 state_shift = get_bits(gbp, 4);
654 /* TODO: Check validity of state data. */
656 for (i = 0; i < order; i++)
657 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
664 /** Read parameters for primitive matrices. */
666 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
668 SubStream *s = &m->substream[substr];
669 unsigned int mat, ch;
670 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
672 : MAX_MATRICES_TRUEHD;
674 if (m->matrix_changed++ > 1) {
675 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
676 return AVERROR_INVALIDDATA;
679 s->num_primitive_matrices = get_bits(gbp, 4);
681 if (s->num_primitive_matrices > max_primitive_matrices) {
682 av_log(m->avctx, AV_LOG_ERROR,
683 "Number of primitive matrices cannot be greater than %d.\n",
684 max_primitive_matrices);
685 return AVERROR_INVALIDDATA;
688 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
689 int frac_bits, max_chan;
690 s->matrix_out_ch[mat] = get_bits(gbp, 4);
691 frac_bits = get_bits(gbp, 4);
692 s->lsb_bypass [mat] = get_bits1(gbp);
694 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
695 av_log(m->avctx, AV_LOG_ERROR,
696 "Invalid channel %d specified as output from matrix.\n",
697 s->matrix_out_ch[mat]);
698 return AVERROR_INVALIDDATA;
700 if (frac_bits > 14) {
701 av_log(m->avctx, AV_LOG_ERROR,
702 "Too many fractional bits specified.\n");
703 return AVERROR_INVALIDDATA;
706 max_chan = s->max_matrix_channel;
710 for (ch = 0; ch <= max_chan; ch++) {
713 coeff_val = get_sbits(gbp, frac_bits + 2);
715 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
719 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
721 s->matrix_noise_shift[mat] = 0;
727 /** Read channel parameters. */
729 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
730 GetBitContext *gbp, unsigned int ch)
732 SubStream *s = &m->substream[substr];
733 ChannelParams *cp = &s->channel_params[ch];
734 FilterParams *fir = &cp->filter_params[FIR];
735 FilterParams *iir = &cp->filter_params[IIR];
738 if (s->param_presence_flags & PARAM_FIR)
740 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
743 if (s->param_presence_flags & PARAM_IIR)
745 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
748 if (fir->order + iir->order > 8) {
749 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
750 return AVERROR_INVALIDDATA;
753 if (fir->order && iir->order &&
754 fir->shift != iir->shift) {
755 av_log(m->avctx, AV_LOG_ERROR,
756 "FIR and IIR filters must use the same precision.\n");
757 return AVERROR_INVALIDDATA;
759 /* The FIR and IIR filters must have the same precision.
760 * To simplify the filtering code, only the precision of the
761 * FIR filter is considered. If only the IIR filter is employed,
762 * the FIR filter precision is set to that of the IIR filter, so
763 * that the filtering code can use it. */
764 if (!fir->order && iir->order)
765 fir->shift = iir->shift;
767 if (s->param_presence_flags & PARAM_HUFFOFFSET)
769 cp->huff_offset = get_sbits(gbp, 15);
771 cp->codebook = get_bits(gbp, 2);
772 cp->huff_lsbs = get_bits(gbp, 5);
774 if (cp->huff_lsbs > 24) {
775 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
776 return AVERROR_INVALIDDATA;
779 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
784 /** Read decoding parameters that change more often than those in the restart
787 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
790 SubStream *s = &m->substream[substr];
794 if (s->param_presence_flags & PARAM_PRESENCE)
796 s->param_presence_flags = get_bits(gbp, 8);
798 if (s->param_presence_flags & PARAM_BLOCKSIZE)
799 if (get_bits1(gbp)) {
800 s->blocksize = get_bits(gbp, 9);
801 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
802 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
804 return AVERROR_INVALIDDATA;
808 if (s->param_presence_flags & PARAM_MATRIX)
810 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
813 if (s->param_presence_flags & PARAM_OUTSHIFT)
815 for (ch = 0; ch <= s->max_matrix_channel; ch++)
816 s->output_shift[ch] = get_sbits(gbp, 4);
818 if (s->param_presence_flags & PARAM_QUANTSTEP)
820 for (ch = 0; ch <= s->max_channel; ch++) {
821 ChannelParams *cp = &s->channel_params[ch];
823 s->quant_step_size[ch] = get_bits(gbp, 4);
825 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
828 for (ch = s->min_channel; ch <= s->max_channel; ch++)
830 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
836 #define MSB_MASK(bits) (-1u << bits)
838 /** Generate PCM samples using the prediction filters and residual values
839 * read from the data stream, and update the filter state. */
841 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
842 unsigned int channel)
844 SubStream *s = &m->substream[substr];
845 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
846 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
847 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
848 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
849 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
850 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
851 unsigned int filter_shift = fir->shift;
852 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
854 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
855 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
857 m->dsp.mlp_filter_channel(firbuf, fircoeff,
858 fir->order, iir->order,
859 filter_shift, mask, s->blocksize,
860 &m->sample_buffer[s->blockpos][channel]);
862 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
863 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
866 /** Read a block of PCM residual data (or actual if no filtering active). */
868 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
871 SubStream *s = &m->substream[substr];
872 unsigned int i, ch, expected_stream_pos = 0;
875 if (s->data_check_present) {
876 expected_stream_pos = get_bits_count(gbp);
877 expected_stream_pos += get_bits(gbp, 16);
878 avpriv_request_sample(m->avctx,
879 "Substreams with VLC block size check info");
882 if (s->blockpos + s->blocksize > m->access_unit_size) {
883 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
884 return AVERROR_INVALIDDATA;
887 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
888 s->blocksize * sizeof(m->bypassed_lsbs[0]));
890 for (i = 0; i < s->blocksize; i++)
891 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
894 for (ch = s->min_channel; ch <= s->max_channel; ch++)
895 filter_channel(m, substr, ch);
897 s->blockpos += s->blocksize;
899 if (s->data_check_present) {
900 if (get_bits_count(gbp) != expected_stream_pos)
901 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
908 /** Data table used for TrueHD noise generation function. */
910 static const int8_t noise_table[256] = {
911 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
912 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
913 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
914 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
915 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
916 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
917 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
918 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
919 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
920 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
921 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
922 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
923 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
924 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
925 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
926 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
929 /** Noise generation functions.
930 * I'm not sure what these are for - they seem to be some kind of pseudorandom
931 * sequence generators, used to generate noise data which is used when the
932 * channels are rematrixed. I'm not sure if they provide a practical benefit
933 * to compression, or just obfuscate the decoder. Are they for some kind of
936 /** Generate two channels of noise, used in the matrix when
937 * restart sync word == 0x31ea. */
939 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
941 SubStream *s = &m->substream[substr];
943 uint32_t seed = s->noisegen_seed;
944 unsigned int maxchan = s->max_matrix_channel;
946 for (i = 0; i < s->blockpos; i++) {
947 uint16_t seed_shr7 = seed >> 7;
948 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
949 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
951 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
954 s->noisegen_seed = seed;
957 /** Generate a block of noise, used when restart sync word == 0x31eb. */
959 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
961 SubStream *s = &m->substream[substr];
963 uint32_t seed = s->noisegen_seed;
965 for (i = 0; i < m->access_unit_size_pow2; i++) {
966 uint8_t seed_shr15 = seed >> 15;
967 m->noise_buffer[i] = noise_table[seed_shr15];
968 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
971 s->noisegen_seed = seed;
975 /** Apply the channel matrices in turn to reconstruct the original audio
978 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
980 SubStream *s = &m->substream[substr];
981 unsigned int mat, src_ch, i;
982 unsigned int maxchan;
984 maxchan = s->max_matrix_channel;
985 if (!s->noise_type) {
986 generate_2_noise_channels(m, substr);
989 fill_noise_buffer(m, substr);
992 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
993 int matrix_noise_shift = s->matrix_noise_shift[mat];
994 unsigned int dest_ch = s->matrix_out_ch[mat];
995 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
996 int32_t *coeffs = s->matrix_coeff[mat];
997 int index = s->num_primitive_matrices - mat;
998 int index2 = 2 * index + 1;
1000 /* TODO: DSPContext? */
1002 for (i = 0; i < s->blockpos; i++) {
1003 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
1004 int32_t *samples = m->sample_buffer[i];
1007 for (src_ch = 0; src_ch <= maxchan; src_ch++)
1008 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
1010 if (matrix_noise_shift) {
1011 index &= m->access_unit_size_pow2 - 1;
1012 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
1016 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
1021 /** Write the audio data into the output buffer. */
1023 static int output_data(MLPDecodeContext *m, unsigned int substr,
1024 AVFrame *frame, int *got_frame_ptr)
1026 AVCodecContext *avctx = m->avctx;
1027 SubStream *s = &m->substream[substr];
1028 unsigned int i, out_ch = 0;
1032 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1034 if (m->avctx->channels != s->max_matrix_channel + 1) {
1035 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1036 return AVERROR_INVALIDDATA;
1040 av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1041 return AVERROR_INVALIDDATA;
1044 /* get output buffer */
1045 frame->nb_samples = s->blockpos;
1046 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1047 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1050 data_32 = (int32_t *)frame->data[0];
1051 data_16 = (int16_t *)frame->data[0];
1053 for (i = 0; i < s->blockpos; i++) {
1054 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
1055 int mat_ch = s->ch_assign[out_ch];
1056 int32_t sample = m->sample_buffer[i][mat_ch]
1057 << s->output_shift[mat_ch];
1058 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
1059 if (is32) *data_32++ = sample << 8;
1060 else *data_16++ = sample >> 8;
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 */