3 * Copyright (c) 2007-2008 Ian Caulfield
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30 #include "libavutil/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 /// Stream needs channel reordering to comply with FFmpeg's channel order
138 uint8_t needs_reordering;
140 /// number of PCM samples contained in each frame
141 int access_unit_size;
142 /// next power of two above the number of samples in each frame
143 int access_unit_size_pow2;
145 SubStream substream[MAX_SUBSTREAMS];
148 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
150 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
151 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
152 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
157 static const uint64_t thd_channel_order[] = {
158 AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT, // LR
159 AV_CH_FRONT_CENTER, // C
160 AV_CH_LOW_FREQUENCY, // LFE
161 AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT, // LRs
162 AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT, // LRvh
163 AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
164 AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT, // LRrs
165 AV_CH_BACK_CENTER, // Cs
166 AV_CH_TOP_CENTER, // Ts
167 AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
168 AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT, // LRw
169 AV_CH_TOP_FRONT_CENTER, // Cvh
170 AV_CH_LOW_FREQUENCY_2, // LFE2
173 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
178 if (av_get_channel_layout_nb_channels(channel_layout) <= index)
181 for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
182 if (channel_layout & thd_channel_order[i] && !index--)
183 return thd_channel_order[i];
187 static VLC huff_vlc[3];
189 /** Initialize static data, constant between all invocations of the codec. */
191 static av_cold void init_static(void)
193 if (!huff_vlc[0].bits) {
194 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
195 &ff_mlp_huffman_tables[0][0][1], 2, 1,
196 &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
197 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
198 &ff_mlp_huffman_tables[1][0][1], 2, 1,
199 &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
200 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
201 &ff_mlp_huffman_tables[2][0][1], 2, 1,
202 &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
208 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
209 unsigned int substr, unsigned int ch)
211 SubStream *s = &m->substream[substr];
212 ChannelParams *cp = &s->channel_params[ch];
213 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
214 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
215 int32_t sign_huff_offset = cp->huff_offset;
217 if (cp->codebook > 0)
218 sign_huff_offset -= 7 << lsb_bits;
221 sign_huff_offset -= 1 << sign_shift;
223 return sign_huff_offset;
226 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
229 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
230 unsigned int substr, unsigned int pos)
232 SubStream *s = &m->substream[substr];
233 unsigned int mat, channel;
235 for (mat = 0; mat < s->num_primitive_matrices; mat++)
236 if (s->lsb_bypass[mat])
237 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
239 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
240 ChannelParams *cp = &s->channel_params[channel];
241 int codebook = cp->codebook;
242 int quant_step_size = s->quant_step_size[channel];
243 int lsb_bits = cp->huff_lsbs - quant_step_size;
247 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
248 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
251 return AVERROR_INVALIDDATA;
254 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
256 result += cp->sign_huff_offset;
257 result <<= quant_step_size;
259 m->sample_buffer[pos + s->blockpos][channel] = result;
265 static av_cold int mlp_decode_init(AVCodecContext *avctx)
267 MLPDecodeContext *m = avctx->priv_data;
272 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
273 m->substream[substr].lossless_check_data = 0xffffffff;
274 ff_mlpdsp_init(&m->dsp);
279 /** Read a major sync info header - contains high level information about
280 * the stream - sample rate, channel arrangement etc. Most of this
281 * information is not actually necessary for decoding, only for playback.
284 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
289 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
292 if (mh.group1_bits == 0) {
293 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
294 return AVERROR_INVALIDDATA;
296 if (mh.group2_bits > mh.group1_bits) {
297 av_log(m->avctx, AV_LOG_ERROR,
298 "Channel group 2 cannot have more bits per sample than group 1.\n");
299 return AVERROR_INVALIDDATA;
302 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
303 av_log(m->avctx, AV_LOG_ERROR,
304 "Channel groups with differing sample rates are not currently supported.\n");
305 return AVERROR_INVALIDDATA;
308 if (mh.group1_samplerate == 0) {
309 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
310 return AVERROR_INVALIDDATA;
312 if (mh.group1_samplerate > MAX_SAMPLERATE) {
313 av_log(m->avctx, AV_LOG_ERROR,
314 "Sampling rate %d is greater than the supported maximum (%d).\n",
315 mh.group1_samplerate, MAX_SAMPLERATE);
316 return AVERROR_INVALIDDATA;
318 if (mh.access_unit_size > MAX_BLOCKSIZE) {
319 av_log(m->avctx, AV_LOG_ERROR,
320 "Block size %d is greater than the supported maximum (%d).\n",
321 mh.access_unit_size, MAX_BLOCKSIZE);
322 return AVERROR_INVALIDDATA;
324 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
325 av_log(m->avctx, AV_LOG_ERROR,
326 "Block size pow2 %d is greater than the supported maximum (%d).\n",
327 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
328 return AVERROR_INVALIDDATA;
331 if (mh.num_substreams == 0)
332 return AVERROR_INVALIDDATA;
333 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
334 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
335 return AVERROR_INVALIDDATA;
337 if (mh.num_substreams > MAX_SUBSTREAMS) {
338 avpriv_request_sample(m->avctx,
339 "%d substreams (more than the "
340 "maximum supported by the decoder)",
342 return AVERROR_PATCHWELCOME;
345 m->access_unit_size = mh.access_unit_size;
346 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
348 m->num_substreams = mh.num_substreams;
349 m->max_decoded_substream = m->num_substreams - 1;
351 m->avctx->sample_rate = mh.group1_samplerate;
352 m->avctx->frame_size = mh.access_unit_size;
354 m->avctx->bits_per_raw_sample = mh.group1_bits;
355 if (mh.group1_bits > 16)
356 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
358 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
361 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
362 m->substream[substr].restart_seen = 0;
364 /* Set the layout for each substream. When there's more than one, the first
365 * substream is Stereo. Subsequent substreams' layouts are indicated in the
367 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
368 if (mh.stream_type != 0xbb) {
369 avpriv_request_sample(m->avctx,
370 "unexpected stream_type %X in MLP",
372 return AVERROR_PATCHWELCOME;
374 if ((substr = (mh.num_substreams > 1)))
375 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
376 m->substream[substr].ch_layout = mh.channel_layout_mlp;
378 if (mh.stream_type != 0xba) {
379 avpriv_request_sample(m->avctx,
380 "unexpected stream_type %X in !MLP",
382 return AVERROR_PATCHWELCOME;
384 if ((substr = (mh.num_substreams > 1)))
385 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
386 if (mh.num_substreams > 2)
387 if (mh.channel_layout_thd_stream2)
388 m->substream[2].ch_layout = mh.channel_layout_thd_stream2;
390 m->substream[2].ch_layout = mh.channel_layout_thd_stream1;
391 m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;
393 if (m->avctx->channels<=2 && m->substream[substr].ch_layout == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
394 av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
395 m->max_decoded_substream = 0;
396 if (m->avctx->channels==2)
397 m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
401 m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
403 /* Parse the TrueHD decoder channel modifiers and set each substream's
404 * AVMatrixEncoding accordingly.
406 * The meaning of the modifiers depends on the channel layout:
408 * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
410 * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
412 * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
413 * layouts with an Ls/Rs channel pair
415 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
416 m->substream[substr].matrix_encoding = AV_MATRIX_ENCODING_NONE;
417 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
418 if (mh.num_substreams > 2 &&
419 mh.channel_layout_thd_stream2 & AV_CH_SIDE_LEFT &&
420 mh.channel_layout_thd_stream2 & AV_CH_SIDE_RIGHT &&
421 mh.channel_modifier_thd_stream2 == THD_CH_MODIFIER_SURROUNDEX)
422 m->substream[2].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
424 if (mh.num_substreams > 1 &&
425 mh.channel_layout_thd_stream1 & AV_CH_SIDE_LEFT &&
426 mh.channel_layout_thd_stream1 & AV_CH_SIDE_RIGHT &&
427 mh.channel_modifier_thd_stream1 == THD_CH_MODIFIER_SURROUNDEX)
428 m->substream[1].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
430 if (mh.num_substreams > 0)
431 switch (mh.channel_modifier_thd_stream0) {
432 case THD_CH_MODIFIER_LTRT:
433 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
435 case THD_CH_MODIFIER_LBINRBIN:
436 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
446 /** Read a restart header from a block in a substream. This contains parameters
447 * required to decode the audio that do not change very often. Generally
448 * (always) present only in blocks following a major sync. */
450 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
451 const uint8_t *buf, unsigned int substr)
453 SubStream *s = &m->substream[substr];
457 uint8_t lossless_check;
458 int start_count = get_bits_count(gbp);
459 int min_channel, max_channel, max_matrix_channel;
460 const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
461 ? MAX_MATRIX_CHANNEL_MLP
462 : MAX_MATRIX_CHANNEL_TRUEHD;
464 sync_word = get_bits(gbp, 13);
466 if (sync_word != 0x31ea >> 1) {
467 av_log(m->avctx, AV_LOG_ERROR,
468 "restart header sync incorrect (got 0x%04x)\n", sync_word);
469 return AVERROR_INVALIDDATA;
472 s->noise_type = get_bits1(gbp);
474 if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
475 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
476 return AVERROR_INVALIDDATA;
479 skip_bits(gbp, 16); /* Output timestamp */
481 min_channel = get_bits(gbp, 4);
482 max_channel = get_bits(gbp, 4);
483 max_matrix_channel = get_bits(gbp, 4);
485 if (max_matrix_channel > std_max_matrix_channel) {
486 av_log(m->avctx, AV_LOG_ERROR,
487 "Max matrix channel cannot be greater than %d.\n",
488 std_max_matrix_channel);
489 return AVERROR_INVALIDDATA;
492 if (max_channel != max_matrix_channel) {
493 av_log(m->avctx, AV_LOG_ERROR,
494 "Max channel must be equal max matrix channel.\n");
495 return AVERROR_INVALIDDATA;
498 /* This should happen for TrueHD streams with >6 channels and MLP's noise
499 * type. It is not yet known if this is allowed. */
500 if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
501 avpriv_request_sample(m->avctx,
502 "%d channels (more than the "
503 "maximum supported by the decoder)",
505 return AVERROR_PATCHWELCOME;
508 if (min_channel > max_channel) {
509 av_log(m->avctx, AV_LOG_ERROR,
510 "Substream min channel cannot be greater than max channel.\n");
511 return AVERROR_INVALIDDATA;
514 s->min_channel = min_channel;
515 s->max_channel = max_channel;
516 s->max_matrix_channel = max_matrix_channel;
518 #if FF_API_REQUEST_CHANNELS
519 FF_DISABLE_DEPRECATION_WARNINGS
520 if (m->avctx->request_channels > 0 &&
521 m->avctx->request_channels <= s->max_channel + 1 &&
522 m->max_decoded_substream > substr) {
523 av_log(m->avctx, AV_LOG_DEBUG,
524 "Extracting %d-channel downmix from substream %d. "
525 "Further substreams will be skipped.\n",
526 s->max_channel + 1, substr);
527 m->max_decoded_substream = substr;
528 FF_ENABLE_DEPRECATION_WARNINGS
531 if (m->avctx->request_channel_layout && (s->ch_layout & m->avctx->request_channel_layout) ==
532 m->avctx->request_channel_layout && m->max_decoded_substream > substr) {
533 av_log(m->avctx, AV_LOG_DEBUG,
534 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
535 "Further substreams will be skipped.\n",
536 s->max_channel + 1, s->ch_layout, substr);
537 m->max_decoded_substream = substr;
540 s->noise_shift = get_bits(gbp, 4);
541 s->noisegen_seed = get_bits(gbp, 23);
545 s->data_check_present = get_bits1(gbp);
546 lossless_check = get_bits(gbp, 8);
547 if (substr == m->max_decoded_substream
548 && s->lossless_check_data != 0xffffffff) {
549 tmp = xor_32_to_8(s->lossless_check_data);
550 if (tmp != lossless_check)
551 av_log(m->avctx, AV_LOG_WARNING,
552 "Lossless check failed - expected %02x, calculated %02x.\n",
553 lossless_check, tmp);
558 memset(s->ch_assign, 0, sizeof(s->ch_assign));
560 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
561 int ch_assign = get_bits(gbp, 6);
562 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
563 uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
565 ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
568 if ((unsigned)ch_assign > s->max_matrix_channel) {
569 avpriv_request_sample(m->avctx,
570 "Assignment of matrix channel %d to invalid output channel %d",
572 return AVERROR_PATCHWELCOME;
574 s->ch_assign[ch_assign] = ch;
577 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
579 if (checksum != get_bits(gbp, 8))
580 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
582 /* Set default decoding parameters. */
583 s->param_presence_flags = 0xff;
584 s->num_primitive_matrices = 0;
586 s->lossless_check_data = 0;
588 memset(s->output_shift , 0, sizeof(s->output_shift ));
589 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
591 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
592 ChannelParams *cp = &s->channel_params[ch];
593 cp->filter_params[FIR].order = 0;
594 cp->filter_params[IIR].order = 0;
595 cp->filter_params[FIR].shift = 0;
596 cp->filter_params[IIR].shift = 0;
598 /* Default audio coding is 24-bit raw PCM. */
600 cp->sign_huff_offset = (-1) << 23;
605 if (substr == m->max_decoded_substream) {
606 m->avctx->channels = s->max_matrix_channel + 1;
607 m->avctx->channel_layout = s->ch_layout;
609 if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
610 if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
611 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
612 int i = s->ch_assign[4];
613 s->ch_assign[4] = s->ch_assign[3];
614 s->ch_assign[3] = s->ch_assign[2];
616 } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
617 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
618 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
627 /** Read parameters for one of the prediction filters. */
629 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
630 unsigned int substr, unsigned int channel,
633 SubStream *s = &m->substream[substr];
634 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
635 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
636 const char fchar = filter ? 'I' : 'F';
639 // Filter is 0 for FIR, 1 for IIR.
640 av_assert0(filter < 2);
642 if (m->filter_changed[channel][filter]++ > 1) {
643 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
644 return AVERROR_INVALIDDATA;
647 order = get_bits(gbp, 4);
648 if (order > max_order) {
649 av_log(m->avctx, AV_LOG_ERROR,
650 "%cIR filter order %d is greater than maximum %d.\n",
651 fchar, order, max_order);
652 return AVERROR_INVALIDDATA;
657 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
658 int coeff_bits, coeff_shift;
660 fp->shift = get_bits(gbp, 4);
662 coeff_bits = get_bits(gbp, 5);
663 coeff_shift = get_bits(gbp, 3);
664 if (coeff_bits < 1 || coeff_bits > 16) {
665 av_log(m->avctx, AV_LOG_ERROR,
666 "%cIR filter coeff_bits must be between 1 and 16.\n",
668 return AVERROR_INVALIDDATA;
670 if (coeff_bits + coeff_shift > 16) {
671 av_log(m->avctx, AV_LOG_ERROR,
672 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
674 return AVERROR_INVALIDDATA;
677 for (i = 0; i < order; i++)
678 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
680 if (get_bits1(gbp)) {
681 int state_bits, state_shift;
684 av_log(m->avctx, AV_LOG_ERROR,
685 "FIR filter has state data specified.\n");
686 return AVERROR_INVALIDDATA;
689 state_bits = get_bits(gbp, 4);
690 state_shift = get_bits(gbp, 4);
692 /* TODO: Check validity of state data. */
694 for (i = 0; i < order; i++)
695 fp->state[i] = state_bits ? get_sbits(gbp, state_bits) << state_shift : 0;
702 /** Read parameters for primitive matrices. */
704 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
706 SubStream *s = &m->substream[substr];
707 unsigned int mat, ch;
708 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
710 : MAX_MATRICES_TRUEHD;
712 if (m->matrix_changed++ > 1) {
713 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
714 return AVERROR_INVALIDDATA;
717 s->num_primitive_matrices = get_bits(gbp, 4);
719 if (s->num_primitive_matrices > max_primitive_matrices) {
720 av_log(m->avctx, AV_LOG_ERROR,
721 "Number of primitive matrices cannot be greater than %d.\n",
722 max_primitive_matrices);
723 return AVERROR_INVALIDDATA;
726 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
727 int frac_bits, max_chan;
728 s->matrix_out_ch[mat] = get_bits(gbp, 4);
729 frac_bits = get_bits(gbp, 4);
730 s->lsb_bypass [mat] = get_bits1(gbp);
732 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
733 av_log(m->avctx, AV_LOG_ERROR,
734 "Invalid channel %d specified as output from matrix.\n",
735 s->matrix_out_ch[mat]);
736 return AVERROR_INVALIDDATA;
738 if (frac_bits > 14) {
739 av_log(m->avctx, AV_LOG_ERROR,
740 "Too many fractional bits specified.\n");
741 return AVERROR_INVALIDDATA;
744 max_chan = s->max_matrix_channel;
748 for (ch = 0; ch <= max_chan; ch++) {
751 coeff_val = get_sbits(gbp, frac_bits + 2);
753 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
757 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
759 s->matrix_noise_shift[mat] = 0;
765 /** Read channel parameters. */
767 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
768 GetBitContext *gbp, unsigned int ch)
770 SubStream *s = &m->substream[substr];
771 ChannelParams *cp = &s->channel_params[ch];
772 FilterParams *fir = &cp->filter_params[FIR];
773 FilterParams *iir = &cp->filter_params[IIR];
776 if (s->param_presence_flags & PARAM_FIR)
778 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
781 if (s->param_presence_flags & PARAM_IIR)
783 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
786 if (fir->order + iir->order > 8) {
787 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
788 return AVERROR_INVALIDDATA;
791 if (fir->order && iir->order &&
792 fir->shift != iir->shift) {
793 av_log(m->avctx, AV_LOG_ERROR,
794 "FIR and IIR filters must use the same precision.\n");
795 return AVERROR_INVALIDDATA;
797 /* The FIR and IIR filters must have the same precision.
798 * To simplify the filtering code, only the precision of the
799 * FIR filter is considered. If only the IIR filter is employed,
800 * the FIR filter precision is set to that of the IIR filter, so
801 * that the filtering code can use it. */
802 if (!fir->order && iir->order)
803 fir->shift = iir->shift;
805 if (s->param_presence_flags & PARAM_HUFFOFFSET)
807 cp->huff_offset = get_sbits(gbp, 15);
809 cp->codebook = get_bits(gbp, 2);
810 cp->huff_lsbs = get_bits(gbp, 5);
812 if (cp->huff_lsbs > 24) {
813 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
815 return AVERROR_INVALIDDATA;
818 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
823 /** Read decoding parameters that change more often than those in the restart
826 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
829 SubStream *s = &m->substream[substr];
833 if (s->param_presence_flags & PARAM_PRESENCE)
835 s->param_presence_flags = get_bits(gbp, 8);
837 if (s->param_presence_flags & PARAM_BLOCKSIZE)
838 if (get_bits1(gbp)) {
839 s->blocksize = get_bits(gbp, 9);
840 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
841 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
843 return AVERROR_INVALIDDATA;
847 if (s->param_presence_flags & PARAM_MATRIX)
849 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
852 if (s->param_presence_flags & PARAM_OUTSHIFT)
854 for (ch = 0; ch <= s->max_matrix_channel; ch++)
855 s->output_shift[ch] = get_sbits(gbp, 4);
857 if (s->param_presence_flags & PARAM_QUANTSTEP)
859 for (ch = 0; ch <= s->max_channel; ch++) {
860 ChannelParams *cp = &s->channel_params[ch];
862 s->quant_step_size[ch] = get_bits(gbp, 4);
864 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
867 for (ch = s->min_channel; ch <= s->max_channel; ch++)
869 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
875 #define MSB_MASK(bits) (-1u << bits)
877 /** Generate PCM samples using the prediction filters and residual values
878 * read from the data stream, and update the filter state. */
880 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
881 unsigned int channel)
883 SubStream *s = &m->substream[substr];
884 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
885 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
886 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
887 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
888 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
889 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
890 unsigned int filter_shift = fir->shift;
891 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
893 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
894 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
896 m->dsp.mlp_filter_channel(firbuf, fircoeff,
897 fir->order, iir->order,
898 filter_shift, mask, s->blocksize,
899 &m->sample_buffer[s->blockpos][channel]);
901 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
902 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
905 /** Read a block of PCM residual data (or actual if no filtering active). */
907 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
910 SubStream *s = &m->substream[substr];
911 unsigned int i, ch, expected_stream_pos = 0;
914 if (s->data_check_present) {
915 expected_stream_pos = get_bits_count(gbp);
916 expected_stream_pos += get_bits(gbp, 16);
917 avpriv_request_sample(m->avctx,
918 "Substreams with VLC block size check info");
921 if (s->blockpos + s->blocksize > m->access_unit_size) {
922 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
923 return AVERROR_INVALIDDATA;
926 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
927 s->blocksize * sizeof(m->bypassed_lsbs[0]));
929 for (i = 0; i < s->blocksize; i++)
930 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
933 for (ch = s->min_channel; ch <= s->max_channel; ch++)
934 filter_channel(m, substr, ch);
936 s->blockpos += s->blocksize;
938 if (s->data_check_present) {
939 if (get_bits_count(gbp) != expected_stream_pos)
940 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
947 /** Data table used for TrueHD noise generation function. */
949 static const int8_t noise_table[256] = {
950 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
951 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
952 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
953 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
954 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
955 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
956 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
957 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
958 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
959 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
960 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
961 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
962 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
963 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
964 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
965 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
968 /** Noise generation functions.
969 * I'm not sure what these are for - they seem to be some kind of pseudorandom
970 * sequence generators, used to generate noise data which is used when the
971 * channels are rematrixed. I'm not sure if they provide a practical benefit
972 * to compression, or just obfuscate the decoder. Are they for some kind of
975 /** Generate two channels of noise, used in the matrix when
976 * restart sync word == 0x31ea. */
978 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
980 SubStream *s = &m->substream[substr];
982 uint32_t seed = s->noisegen_seed;
983 unsigned int maxchan = s->max_matrix_channel;
985 for (i = 0; i < s->blockpos; i++) {
986 uint16_t seed_shr7 = seed >> 7;
987 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
988 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
990 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
993 s->noisegen_seed = seed;
996 /** Generate a block of noise, used when restart sync word == 0x31eb. */
998 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
1000 SubStream *s = &m->substream[substr];
1002 uint32_t seed = s->noisegen_seed;
1004 for (i = 0; i < m->access_unit_size_pow2; i++) {
1005 uint8_t seed_shr15 = seed >> 15;
1006 m->noise_buffer[i] = noise_table[seed_shr15];
1007 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
1010 s->noisegen_seed = seed;
1014 /** Apply the channel matrices in turn to reconstruct the original audio
1017 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
1019 SubStream *s = &m->substream[substr];
1020 unsigned int mat, src_ch, i;
1021 unsigned int maxchan;
1023 maxchan = s->max_matrix_channel;
1024 if (!s->noise_type) {
1025 generate_2_noise_channels(m, substr);
1028 fill_noise_buffer(m, substr);
1031 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1032 int matrix_noise_shift = s->matrix_noise_shift[mat];
1033 unsigned int dest_ch = s->matrix_out_ch[mat];
1034 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
1035 int32_t *coeffs = s->matrix_coeff[mat];
1036 int index = s->num_primitive_matrices - mat;
1037 int index2 = 2 * index + 1;
1039 /* TODO: DSPContext? */
1041 for (i = 0; i < s->blockpos; i++) {
1042 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
1043 int32_t *samples = m->sample_buffer[i];
1046 for (src_ch = 0; src_ch <= maxchan; src_ch++)
1047 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
1049 if (matrix_noise_shift) {
1050 index &= m->access_unit_size_pow2 - 1;
1051 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
1055 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
1060 /** Write the audio data into the output buffer. */
1062 static int output_data(MLPDecodeContext *m, unsigned int substr,
1063 AVFrame *frame, int *got_frame_ptr)
1065 AVCodecContext *avctx = m->avctx;
1066 SubStream *s = &m->substream[substr];
1067 unsigned int i, out_ch = 0;
1071 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1073 if (m->avctx->channels != s->max_matrix_channel + 1) {
1074 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1075 return AVERROR_INVALIDDATA;
1079 av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1080 return AVERROR_INVALIDDATA;
1083 /* get output buffer */
1084 frame->nb_samples = s->blockpos;
1085 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1087 data_32 = (int32_t *)frame->data[0];
1088 data_16 = (int16_t *)frame->data[0];
1090 for (i = 0; i < s->blockpos; i++) {
1091 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
1092 int mat_ch = s->ch_assign[out_ch];
1093 int32_t sample = m->sample_buffer[i][mat_ch]
1094 << s->output_shift[mat_ch];
1095 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
1096 if (is32) *data_32++ = sample << 8;
1097 else *data_16++ = sample >> 8;
1101 /* Update matrix encoding side data */
1102 if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1110 /** Read an access unit from the stream.
1111 * @return negative on error, 0 if not enough data is present in the input stream,
1112 * otherwise the number of bytes consumed. */
1114 static int read_access_unit(AVCodecContext *avctx, void* data,
1115 int *got_frame_ptr, AVPacket *avpkt)
1117 const uint8_t *buf = avpkt->data;
1118 int buf_size = avpkt->size;
1119 MLPDecodeContext *m = avctx->priv_data;
1121 unsigned int length, substr;
1122 unsigned int substream_start;
1123 unsigned int header_size = 4;
1124 unsigned int substr_header_size = 0;
1125 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1126 uint16_t substream_data_len[MAX_SUBSTREAMS];
1127 uint8_t parity_bits;
1131 return AVERROR_INVALIDDATA;
1133 length = (AV_RB16(buf) & 0xfff) * 2;
1135 if (length < 4 || length > buf_size)
1136 return AVERROR_INVALIDDATA;
1138 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1140 m->is_major_sync_unit = 0;
1141 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1142 if (read_major_sync(m, &gb) < 0)
1144 m->is_major_sync_unit = 1;
1148 if (!m->params_valid) {
1149 av_log(m->avctx, AV_LOG_WARNING,
1150 "Stream parameters not seen; skipping frame.\n");
1155 substream_start = 0;
1157 for (substr = 0; substr < m->num_substreams; substr++) {
1158 int extraword_present, checkdata_present, end, nonrestart_substr;
1160 extraword_present = get_bits1(&gb);
1161 nonrestart_substr = get_bits1(&gb);
1162 checkdata_present = get_bits1(&gb);
1165 end = get_bits(&gb, 12) * 2;
1167 substr_header_size += 2;
1169 if (extraword_present) {
1170 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1171 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1175 substr_header_size += 2;
1178 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1179 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1183 if (end + header_size + substr_header_size > length) {
1184 av_log(m->avctx, AV_LOG_ERROR,
1185 "Indicated length of substream %d data goes off end of "
1186 "packet.\n", substr);
1187 end = length - header_size - substr_header_size;
1190 if (end < substream_start) {
1191 av_log(avctx, AV_LOG_ERROR,
1192 "Indicated end offset of substream %d data "
1193 "is smaller than calculated start offset.\n",
1198 if (substr > m->max_decoded_substream)
1201 substream_parity_present[substr] = checkdata_present;
1202 substream_data_len[substr] = end - substream_start;
1203 substream_start = end;
1206 parity_bits = ff_mlp_calculate_parity(buf, 4);
1207 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1209 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1210 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1214 buf += header_size + substr_header_size;
1216 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1217 SubStream *s = &m->substream[substr];
1218 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1220 m->matrix_changed = 0;
1221 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1225 if (get_bits1(&gb)) {
1226 if (get_bits1(&gb)) {
1227 /* A restart header should be present. */
1228 if (read_restart_header(m, &gb, buf, substr) < 0)
1230 s->restart_seen = 1;
1233 if (!s->restart_seen)
1235 if (read_decoding_params(m, &gb, substr) < 0)
1239 if (!s->restart_seen)
1242 if ((ret = read_block_data(m, &gb, substr)) < 0)
1245 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1246 goto substream_length_mismatch;
1248 } while (!get_bits1(&gb));
1250 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1252 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1255 if (get_bits(&gb, 16) != 0xD234)
1256 return AVERROR_INVALIDDATA;
1258 shorten_by = get_bits(&gb, 16);
1259 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1260 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1261 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1262 return AVERROR_INVALIDDATA;
1264 if (substr == m->max_decoded_substream)
1265 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1268 if (substream_parity_present[substr]) {
1269 uint8_t parity, checksum;
1271 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1272 goto substream_length_mismatch;
1274 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1275 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1277 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1278 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1279 if ( get_bits(&gb, 8) != checksum)
1280 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1283 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1284 goto substream_length_mismatch;
1287 if (!s->restart_seen)
1288 av_log(m->avctx, AV_LOG_ERROR,
1289 "No restart header present in substream %d.\n", substr);
1291 buf += substream_data_len[substr];
1294 rematrix_channels(m, m->max_decoded_substream);
1296 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1301 substream_length_mismatch:
1302 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1303 return AVERROR_INVALIDDATA;
1306 m->params_valid = 0;
1307 return AVERROR_INVALIDDATA;
1310 #if CONFIG_MLP_DECODER
1311 AVCodec ff_mlp_decoder = {
1313 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1314 .type = AVMEDIA_TYPE_AUDIO,
1315 .id = AV_CODEC_ID_MLP,
1316 .priv_data_size = sizeof(MLPDecodeContext),
1317 .init = mlp_decode_init,
1318 .decode = read_access_unit,
1319 .capabilities = CODEC_CAP_DR1,
1322 #if CONFIG_TRUEHD_DECODER
1323 AVCodec ff_truehd_decoder = {
1325 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1326 .type = AVMEDIA_TYPE_AUDIO,
1327 .id = AV_CODEC_ID_TRUEHD,
1328 .priv_data_size = sizeof(MLPDecodeContext),
1329 .init = mlp_decode_init,
1330 .decode = read_access_unit,
1331 .capabilities = CODEC_CAP_DR1,
1333 #endif /* CONFIG_TRUEHD_DECODER */