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"
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 DECLARE_ALIGNED(32, 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 /// Size of the major sync unit, in bytes
136 int major_sync_header_size;
138 /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
139 uint8_t params_valid;
141 /// Number of substreams contained within this stream.
142 uint8_t num_substreams;
144 /// Index of the last substream to decode - further substreams are skipped.
145 uint8_t max_decoded_substream;
147 /// Stream needs channel reordering to comply with FFmpeg's channel order
148 uint8_t needs_reordering;
150 /// number of PCM samples contained in each frame
151 int access_unit_size;
152 /// next power of two above the number of samples in each frame
153 int access_unit_size_pow2;
155 SubStream substream[MAX_SUBSTREAMS];
158 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
160 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
161 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
162 DECLARE_ALIGNED(32, int32_t, sample_buffer)[MAX_BLOCKSIZE][MAX_CHANNELS];
167 static const uint64_t thd_channel_order[] = {
168 AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT, // LR
169 AV_CH_FRONT_CENTER, // C
170 AV_CH_LOW_FREQUENCY, // LFE
171 AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT, // LRs
172 AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT, // LRvh
173 AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
174 AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT, // LRrs
175 AV_CH_BACK_CENTER, // Cs
176 AV_CH_TOP_CENTER, // Ts
177 AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
178 AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT, // LRw
179 AV_CH_TOP_FRONT_CENTER, // Cvh
180 AV_CH_LOW_FREQUENCY_2, // LFE2
183 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
188 if (av_get_channel_layout_nb_channels(channel_layout) <= index)
191 for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
192 if (channel_layout & thd_channel_order[i] && !index--)
193 return thd_channel_order[i];
197 static VLC huff_vlc[3];
199 /** Initialize static data, constant between all invocations of the codec. */
201 static av_cold void init_static(void)
203 if (!huff_vlc[0].bits) {
204 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
205 &ff_mlp_huffman_tables[0][0][1], 2, 1,
206 &ff_mlp_huffman_tables[0][0][0], 2, 1, VLC_STATIC_SIZE);
207 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
208 &ff_mlp_huffman_tables[1][0][1], 2, 1,
209 &ff_mlp_huffman_tables[1][0][0], 2, 1, VLC_STATIC_SIZE);
210 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
211 &ff_mlp_huffman_tables[2][0][1], 2, 1,
212 &ff_mlp_huffman_tables[2][0][0], 2, 1, VLC_STATIC_SIZE);
218 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
219 unsigned int substr, unsigned int ch)
221 SubStream *s = &m->substream[substr];
222 ChannelParams *cp = &s->channel_params[ch];
223 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
224 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
225 int32_t sign_huff_offset = cp->huff_offset;
227 if (cp->codebook > 0)
228 sign_huff_offset -= 7 << lsb_bits;
231 sign_huff_offset -= 1 << sign_shift;
233 return sign_huff_offset;
236 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
239 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
240 unsigned int substr, unsigned int pos)
242 SubStream *s = &m->substream[substr];
243 unsigned int mat, channel;
245 for (mat = 0; mat < s->num_primitive_matrices; mat++)
246 if (s->lsb_bypass[mat])
247 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
249 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
250 ChannelParams *cp = &s->channel_params[channel];
251 int codebook = cp->codebook;
252 int quant_step_size = s->quant_step_size[channel];
253 int lsb_bits = cp->huff_lsbs - quant_step_size;
257 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
258 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
261 return AVERROR_INVALIDDATA;
264 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
266 result += cp->sign_huff_offset;
267 result *= 1 << quant_step_size;
269 m->sample_buffer[pos + s->blockpos][channel] = result;
275 static av_cold int mlp_decode_init(AVCodecContext *avctx)
277 MLPDecodeContext *m = avctx->priv_data;
282 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
283 m->substream[substr].lossless_check_data = 0xffffffff;
284 ff_mlpdsp_init(&m->dsp);
289 /** Read a major sync info header - contains high level information about
290 * the stream - sample rate, channel arrangement etc. Most of this
291 * information is not actually necessary for decoding, only for playback.
294 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
299 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
302 if (mh.group1_bits == 0) {
303 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
304 return AVERROR_INVALIDDATA;
306 if (mh.group2_bits > mh.group1_bits) {
307 av_log(m->avctx, AV_LOG_ERROR,
308 "Channel group 2 cannot have more bits per sample than group 1.\n");
309 return AVERROR_INVALIDDATA;
312 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
313 av_log(m->avctx, AV_LOG_ERROR,
314 "Channel groups with differing sample rates are not currently supported.\n");
315 return AVERROR_INVALIDDATA;
318 if (mh.group1_samplerate == 0) {
319 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
320 return AVERROR_INVALIDDATA;
322 if (mh.group1_samplerate > MAX_SAMPLERATE) {
323 av_log(m->avctx, AV_LOG_ERROR,
324 "Sampling rate %d is greater than the supported maximum (%d).\n",
325 mh.group1_samplerate, MAX_SAMPLERATE);
326 return AVERROR_INVALIDDATA;
328 if (mh.access_unit_size > MAX_BLOCKSIZE) {
329 av_log(m->avctx, AV_LOG_ERROR,
330 "Block size %d is greater than the supported maximum (%d).\n",
331 mh.access_unit_size, MAX_BLOCKSIZE);
332 return AVERROR_INVALIDDATA;
334 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
335 av_log(m->avctx, AV_LOG_ERROR,
336 "Block size pow2 %d is greater than the supported maximum (%d).\n",
337 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
338 return AVERROR_INVALIDDATA;
341 if (mh.num_substreams == 0)
342 return AVERROR_INVALIDDATA;
343 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
344 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
345 return AVERROR_INVALIDDATA;
347 if (mh.num_substreams > MAX_SUBSTREAMS) {
348 avpriv_request_sample(m->avctx,
349 "%d substreams (more than the "
350 "maximum supported by the decoder)",
352 return AVERROR_PATCHWELCOME;
355 m->major_sync_header_size = mh.header_size;
357 m->access_unit_size = mh.access_unit_size;
358 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
360 m->num_substreams = mh.num_substreams;
362 /* limit to decoding 3 substreams, as the 4th is used by Dolby Atmos for non-audio data */
363 m->max_decoded_substream = FFMIN(m->num_substreams - 1, 2);
365 m->avctx->sample_rate = mh.group1_samplerate;
366 m->avctx->frame_size = mh.access_unit_size;
368 m->avctx->bits_per_raw_sample = mh.group1_bits;
369 if (mh.group1_bits > 16)
370 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
372 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
373 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(m->substream[m->max_decoded_substream].ch_assign,
374 m->substream[m->max_decoded_substream].output_shift,
375 m->substream[m->max_decoded_substream].max_matrix_channel,
376 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
379 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
380 m->substream[substr].restart_seen = 0;
382 /* Set the layout for each substream. When there's more than one, the first
383 * substream is Stereo. Subsequent substreams' layouts are indicated in the
385 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
386 if (mh.stream_type != 0xbb) {
387 avpriv_request_sample(m->avctx,
388 "unexpected stream_type %X in MLP",
390 return AVERROR_PATCHWELCOME;
392 if ((substr = (mh.num_substreams > 1)))
393 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
394 m->substream[substr].ch_layout = mh.channel_layout_mlp;
396 if (mh.stream_type != 0xba) {
397 avpriv_request_sample(m->avctx,
398 "unexpected stream_type %X in !MLP",
400 return AVERROR_PATCHWELCOME;
402 if ((substr = (mh.num_substreams > 1)))
403 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
404 if (mh.num_substreams > 2)
405 if (mh.channel_layout_thd_stream2)
406 m->substream[2].ch_layout = mh.channel_layout_thd_stream2;
408 m->substream[2].ch_layout = mh.channel_layout_thd_stream1;
409 m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;
411 if (m->avctx->channels<=2 && m->substream[substr].ch_layout == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
412 av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
413 m->max_decoded_substream = 0;
414 if (m->avctx->channels==2)
415 m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
419 m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
421 /* Parse the TrueHD decoder channel modifiers and set each substream's
422 * AVMatrixEncoding accordingly.
424 * The meaning of the modifiers depends on the channel layout:
426 * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
428 * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
430 * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
431 * layouts with an Ls/Rs channel pair
433 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
434 m->substream[substr].matrix_encoding = AV_MATRIX_ENCODING_NONE;
435 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
436 if (mh.num_substreams > 2 &&
437 mh.channel_layout_thd_stream2 & AV_CH_SIDE_LEFT &&
438 mh.channel_layout_thd_stream2 & AV_CH_SIDE_RIGHT &&
439 mh.channel_modifier_thd_stream2 == THD_CH_MODIFIER_SURROUNDEX)
440 m->substream[2].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
442 if (mh.num_substreams > 1 &&
443 mh.channel_layout_thd_stream1 & AV_CH_SIDE_LEFT &&
444 mh.channel_layout_thd_stream1 & AV_CH_SIDE_RIGHT &&
445 mh.channel_modifier_thd_stream1 == THD_CH_MODIFIER_SURROUNDEX)
446 m->substream[1].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
448 if (mh.num_substreams > 0)
449 switch (mh.channel_modifier_thd_stream0) {
450 case THD_CH_MODIFIER_LTRT:
451 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
453 case THD_CH_MODIFIER_LBINRBIN:
454 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
464 /** Read a restart header from a block in a substream. This contains parameters
465 * required to decode the audio that do not change very often. Generally
466 * (always) present only in blocks following a major sync. */
468 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
469 const uint8_t *buf, unsigned int substr)
471 SubStream *s = &m->substream[substr];
475 uint8_t lossless_check;
476 int start_count = get_bits_count(gbp);
477 int min_channel, max_channel, max_matrix_channel;
478 const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
479 ? MAX_MATRIX_CHANNEL_MLP
480 : MAX_MATRIX_CHANNEL_TRUEHD;
482 sync_word = get_bits(gbp, 13);
484 if (sync_word != 0x31ea >> 1) {
485 av_log(m->avctx, AV_LOG_ERROR,
486 "restart header sync incorrect (got 0x%04x)\n", sync_word);
487 return AVERROR_INVALIDDATA;
490 s->noise_type = get_bits1(gbp);
492 if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
493 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
494 return AVERROR_INVALIDDATA;
497 skip_bits(gbp, 16); /* Output timestamp */
499 min_channel = get_bits(gbp, 4);
500 max_channel = get_bits(gbp, 4);
501 max_matrix_channel = get_bits(gbp, 4);
503 if (max_matrix_channel > std_max_matrix_channel) {
504 av_log(m->avctx, AV_LOG_ERROR,
505 "Max matrix channel cannot be greater than %d.\n",
506 std_max_matrix_channel);
507 return AVERROR_INVALIDDATA;
510 if (max_channel != max_matrix_channel) {
511 av_log(m->avctx, AV_LOG_ERROR,
512 "Max channel must be equal max matrix channel.\n");
513 return AVERROR_INVALIDDATA;
516 /* This should happen for TrueHD streams with >6 channels and MLP's noise
517 * type. It is not yet known if this is allowed. */
518 if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
519 avpriv_request_sample(m->avctx,
520 "%d channels (more than the "
521 "maximum supported by the decoder)",
523 return AVERROR_PATCHWELCOME;
526 if (min_channel > max_channel) {
527 av_log(m->avctx, AV_LOG_ERROR,
528 "Substream min channel cannot be greater than max channel.\n");
529 return AVERROR_INVALIDDATA;
532 s->min_channel = min_channel;
533 s->max_channel = max_channel;
534 s->max_matrix_channel = max_matrix_channel;
536 if (m->avctx->request_channel_layout && (s->ch_layout & m->avctx->request_channel_layout) ==
537 m->avctx->request_channel_layout && m->max_decoded_substream > substr) {
538 av_log(m->avctx, AV_LOG_DEBUG,
539 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
540 "Further substreams will be skipped.\n",
541 s->max_channel + 1, s->ch_layout, substr);
542 m->max_decoded_substream = substr;
545 s->noise_shift = get_bits(gbp, 4);
546 s->noisegen_seed = get_bits(gbp, 23);
550 s->data_check_present = get_bits1(gbp);
551 lossless_check = get_bits(gbp, 8);
552 if (substr == m->max_decoded_substream
553 && s->lossless_check_data != 0xffffffff) {
554 tmp = xor_32_to_8(s->lossless_check_data);
555 if (tmp != lossless_check)
556 av_log(m->avctx, AV_LOG_WARNING,
557 "Lossless check failed - expected %02x, calculated %02x.\n",
558 lossless_check, tmp);
563 memset(s->ch_assign, 0, sizeof(s->ch_assign));
565 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
566 int ch_assign = get_bits(gbp, 6);
567 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
568 uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
570 ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
573 if (ch_assign < 0 || ch_assign > s->max_matrix_channel) {
574 avpriv_request_sample(m->avctx,
575 "Assignment of matrix channel %d to invalid output channel %d",
577 return AVERROR_PATCHWELCOME;
579 s->ch_assign[ch_assign] = ch;
582 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
584 if (checksum != get_bits(gbp, 8))
585 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
587 /* Set default decoding parameters. */
588 s->param_presence_flags = 0xff;
589 s->num_primitive_matrices = 0;
591 s->lossless_check_data = 0;
593 memset(s->output_shift , 0, sizeof(s->output_shift ));
594 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
596 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
597 ChannelParams *cp = &s->channel_params[ch];
598 cp->filter_params[FIR].order = 0;
599 cp->filter_params[IIR].order = 0;
600 cp->filter_params[FIR].shift = 0;
601 cp->filter_params[IIR].shift = 0;
603 /* Default audio coding is 24-bit raw PCM. */
605 cp->sign_huff_offset = -(1 << 23);
610 if (substr == m->max_decoded_substream) {
611 m->avctx->channels = s->max_matrix_channel + 1;
612 m->avctx->channel_layout = s->ch_layout;
613 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
615 s->max_matrix_channel,
616 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
618 if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
619 if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
620 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
621 int i = s->ch_assign[4];
622 s->ch_assign[4] = s->ch_assign[3];
623 s->ch_assign[3] = s->ch_assign[2];
625 } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
626 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
627 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
636 /** Read parameters for one of the prediction filters. */
638 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
639 unsigned int substr, unsigned int channel,
642 SubStream *s = &m->substream[substr];
643 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
644 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
645 const char fchar = filter ? 'I' : 'F';
648 // Filter is 0 for FIR, 1 for IIR.
649 av_assert0(filter < 2);
651 if (m->filter_changed[channel][filter]++ > 1) {
652 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
653 return AVERROR_INVALIDDATA;
656 order = get_bits(gbp, 4);
657 if (order > max_order) {
658 av_log(m->avctx, AV_LOG_ERROR,
659 "%cIR filter order %d is greater than maximum %d.\n",
660 fchar, order, max_order);
661 return AVERROR_INVALIDDATA;
666 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
667 int coeff_bits, coeff_shift;
669 fp->shift = get_bits(gbp, 4);
671 coeff_bits = get_bits(gbp, 5);
672 coeff_shift = get_bits(gbp, 3);
673 if (coeff_bits < 1 || coeff_bits > 16) {
674 av_log(m->avctx, AV_LOG_ERROR,
675 "%cIR filter coeff_bits must be between 1 and 16.\n",
677 return AVERROR_INVALIDDATA;
679 if (coeff_bits + coeff_shift > 16) {
680 av_log(m->avctx, AV_LOG_ERROR,
681 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
683 return AVERROR_INVALIDDATA;
686 for (i = 0; i < order; i++)
687 fcoeff[i] = get_sbits(gbp, coeff_bits) * (1 << coeff_shift);
689 if (get_bits1(gbp)) {
690 int state_bits, state_shift;
693 av_log(m->avctx, AV_LOG_ERROR,
694 "FIR filter has state data specified.\n");
695 return AVERROR_INVALIDDATA;
698 state_bits = get_bits(gbp, 4);
699 state_shift = get_bits(gbp, 4);
701 /* TODO: Check validity of state data. */
703 for (i = 0; i < order; i++)
704 fp->state[i] = state_bits ? get_sbits(gbp, state_bits) * (1 << state_shift) : 0;
711 /** Read parameters for primitive matrices. */
713 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
715 SubStream *s = &m->substream[substr];
716 unsigned int mat, ch;
717 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
719 : MAX_MATRICES_TRUEHD;
721 if (m->matrix_changed++ > 1) {
722 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
723 return AVERROR_INVALIDDATA;
726 s->num_primitive_matrices = get_bits(gbp, 4);
728 if (s->num_primitive_matrices > max_primitive_matrices) {
729 av_log(m->avctx, AV_LOG_ERROR,
730 "Number of primitive matrices cannot be greater than %d.\n",
731 max_primitive_matrices);
732 s->num_primitive_matrices = 0;
733 return AVERROR_INVALIDDATA;
736 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
737 int frac_bits, max_chan;
738 s->matrix_out_ch[mat] = get_bits(gbp, 4);
739 frac_bits = get_bits(gbp, 4);
740 s->lsb_bypass [mat] = get_bits1(gbp);
742 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
743 av_log(m->avctx, AV_LOG_ERROR,
744 "Invalid channel %d specified as output from matrix.\n",
745 s->matrix_out_ch[mat]);
746 return AVERROR_INVALIDDATA;
748 if (frac_bits > 14) {
749 av_log(m->avctx, AV_LOG_ERROR,
750 "Too many fractional bits specified.\n");
751 return AVERROR_INVALIDDATA;
754 max_chan = s->max_matrix_channel;
758 for (ch = 0; ch <= max_chan; ch++) {
761 coeff_val = get_sbits(gbp, frac_bits + 2);
763 s->matrix_coeff[mat][ch] = coeff_val * (1 << (14 - frac_bits));
767 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
769 s->matrix_noise_shift[mat] = 0;
775 /** Read channel parameters. */
777 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
778 GetBitContext *gbp, unsigned int ch)
780 SubStream *s = &m->substream[substr];
781 ChannelParams *cp = &s->channel_params[ch];
782 FilterParams *fir = &cp->filter_params[FIR];
783 FilterParams *iir = &cp->filter_params[IIR];
786 if (s->param_presence_flags & PARAM_FIR)
788 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
791 if (s->param_presence_flags & PARAM_IIR)
793 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
796 if (fir->order + iir->order > 8) {
797 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
798 return AVERROR_INVALIDDATA;
801 if (fir->order && iir->order &&
802 fir->shift != iir->shift) {
803 av_log(m->avctx, AV_LOG_ERROR,
804 "FIR and IIR filters must use the same precision.\n");
805 return AVERROR_INVALIDDATA;
807 /* The FIR and IIR filters must have the same precision.
808 * To simplify the filtering code, only the precision of the
809 * FIR filter is considered. If only the IIR filter is employed,
810 * the FIR filter precision is set to that of the IIR filter, so
811 * that the filtering code can use it. */
812 if (!fir->order && iir->order)
813 fir->shift = iir->shift;
815 if (s->param_presence_flags & PARAM_HUFFOFFSET)
817 cp->huff_offset = get_sbits(gbp, 15);
819 cp->codebook = get_bits(gbp, 2);
820 cp->huff_lsbs = get_bits(gbp, 5);
822 if (cp->huff_lsbs > 24) {
823 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
825 return AVERROR_INVALIDDATA;
828 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
833 /** Read decoding parameters that change more often than those in the restart
836 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
839 SubStream *s = &m->substream[substr];
843 if (s->param_presence_flags & PARAM_PRESENCE)
845 s->param_presence_flags = get_bits(gbp, 8);
847 if (s->param_presence_flags & PARAM_BLOCKSIZE)
848 if (get_bits1(gbp)) {
849 s->blocksize = get_bits(gbp, 9);
850 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
851 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
853 return AVERROR_INVALIDDATA;
857 if (s->param_presence_flags & PARAM_MATRIX)
859 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
862 if (s->param_presence_flags & PARAM_OUTSHIFT)
863 if (get_bits1(gbp)) {
864 for (ch = 0; ch <= s->max_matrix_channel; ch++)
865 s->output_shift[ch] = get_sbits(gbp, 4);
866 if (substr == m->max_decoded_substream)
867 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
869 s->max_matrix_channel,
870 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
873 if (s->param_presence_flags & PARAM_QUANTSTEP)
875 for (ch = 0; ch <= s->max_channel; ch++) {
876 ChannelParams *cp = &s->channel_params[ch];
878 s->quant_step_size[ch] = get_bits(gbp, 4);
880 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
883 for (ch = s->min_channel; ch <= s->max_channel; ch++)
885 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
891 #define MSB_MASK(bits) (-1u << (bits))
893 /** Generate PCM samples using the prediction filters and residual values
894 * read from the data stream, and update the filter state. */
896 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
897 unsigned int channel)
899 SubStream *s = &m->substream[substr];
900 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
901 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
902 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
903 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
904 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
905 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
906 unsigned int filter_shift = fir->shift;
907 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
909 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
910 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
912 m->dsp.mlp_filter_channel(firbuf, fircoeff,
913 fir->order, iir->order,
914 filter_shift, mask, s->blocksize,
915 &m->sample_buffer[s->blockpos][channel]);
917 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
918 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
921 /** Read a block of PCM residual data (or actual if no filtering active). */
923 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
926 SubStream *s = &m->substream[substr];
927 unsigned int i, ch, expected_stream_pos = 0;
930 if (s->data_check_present) {
931 expected_stream_pos = get_bits_count(gbp);
932 expected_stream_pos += get_bits(gbp, 16);
933 avpriv_request_sample(m->avctx,
934 "Substreams with VLC block size check info");
937 if (s->blockpos + s->blocksize > m->access_unit_size) {
938 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
939 return AVERROR_INVALIDDATA;
942 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
943 s->blocksize * sizeof(m->bypassed_lsbs[0]));
945 for (i = 0; i < s->blocksize; i++)
946 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
949 for (ch = s->min_channel; ch <= s->max_channel; ch++)
950 filter_channel(m, substr, ch);
952 s->blockpos += s->blocksize;
954 if (s->data_check_present) {
955 if (get_bits_count(gbp) != expected_stream_pos)
956 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
963 /** Data table used for TrueHD noise generation function. */
965 static const int8_t noise_table[256] = {
966 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
967 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
968 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
969 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
970 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
971 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
972 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
973 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
974 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
975 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
976 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
977 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
978 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
979 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
980 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
981 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
984 /** Noise generation functions.
985 * I'm not sure what these are for - they seem to be some kind of pseudorandom
986 * sequence generators, used to generate noise data which is used when the
987 * channels are rematrixed. I'm not sure if they provide a practical benefit
988 * to compression, or just obfuscate the decoder. Are they for some kind of
991 /** Generate two channels of noise, used in the matrix when
992 * restart sync word == 0x31ea. */
994 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
996 SubStream *s = &m->substream[substr];
998 uint32_t seed = s->noisegen_seed;
999 unsigned int maxchan = s->max_matrix_channel;
1001 for (i = 0; i < s->blockpos; i++) {
1002 uint16_t seed_shr7 = seed >> 7;
1003 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) * (1 << s->noise_shift);
1004 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) * (1 << s->noise_shift);
1006 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1009 s->noisegen_seed = seed;
1012 /** Generate a block of noise, used when restart sync word == 0x31eb. */
1014 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
1016 SubStream *s = &m->substream[substr];
1018 uint32_t seed = s->noisegen_seed;
1020 for (i = 0; i < m->access_unit_size_pow2; i++) {
1021 uint8_t seed_shr15 = seed >> 15;
1022 m->noise_buffer[i] = noise_table[seed_shr15];
1023 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
1026 s->noisegen_seed = seed;
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 unsigned int maxchan;
1039 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1041 if (m->avctx->channels != s->max_matrix_channel + 1) {
1042 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1043 return AVERROR_INVALIDDATA;
1047 av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1048 return AVERROR_INVALIDDATA;
1051 maxchan = s->max_matrix_channel;
1052 if (!s->noise_type) {
1053 generate_2_noise_channels(m, substr);
1056 fill_noise_buffer(m, substr);
1059 /* Apply the channel matrices in turn to reconstruct the original audio
1061 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1062 unsigned int dest_ch = s->matrix_out_ch[mat];
1063 m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1064 s->matrix_coeff[mat],
1065 &m->bypassed_lsbs[0][mat],
1067 s->num_primitive_matrices - mat,
1071 s->matrix_noise_shift[mat],
1072 m->access_unit_size_pow2,
1073 MSB_MASK(s->quant_step_size[dest_ch]));
1076 /* get output buffer */
1077 frame->nb_samples = s->blockpos;
1078 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1080 s->lossless_check_data = m->dsp.mlp_pack_output(s->lossless_check_data,
1086 s->max_matrix_channel,
1089 /* Update matrix encoding side data */
1090 if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1098 /** Read an access unit from the stream.
1099 * @return negative on error, 0 if not enough data is present in the input stream,
1100 * otherwise the number of bytes consumed. */
1102 static int read_access_unit(AVCodecContext *avctx, void* data,
1103 int *got_frame_ptr, AVPacket *avpkt)
1105 const uint8_t *buf = avpkt->data;
1106 int buf_size = avpkt->size;
1107 MLPDecodeContext *m = avctx->priv_data;
1109 unsigned int length, substr;
1110 unsigned int substream_start;
1111 unsigned int header_size = 4;
1112 unsigned int substr_header_size = 0;
1113 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1114 uint16_t substream_data_len[MAX_SUBSTREAMS];
1115 uint8_t parity_bits;
1119 return AVERROR_INVALIDDATA;
1121 length = (AV_RB16(buf) & 0xfff) * 2;
1123 if (length < 4 || length > buf_size)
1124 return AVERROR_INVALIDDATA;
1126 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1128 m->is_major_sync_unit = 0;
1129 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1130 if (read_major_sync(m, &gb) < 0)
1132 m->is_major_sync_unit = 1;
1133 header_size += m->major_sync_header_size;
1136 if (!m->params_valid) {
1137 av_log(m->avctx, AV_LOG_WARNING,
1138 "Stream parameters not seen; skipping frame.\n");
1143 substream_start = 0;
1145 for (substr = 0; substr < m->num_substreams; substr++) {
1146 int extraword_present, checkdata_present, end, nonrestart_substr;
1148 extraword_present = get_bits1(&gb);
1149 nonrestart_substr = get_bits1(&gb);
1150 checkdata_present = get_bits1(&gb);
1153 end = get_bits(&gb, 12) * 2;
1155 substr_header_size += 2;
1157 if (extraword_present) {
1158 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1159 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1163 substr_header_size += 2;
1166 if (length < header_size + substr_header_size) {
1167 av_log(m->avctx, AV_LOG_ERROR, "Insuffient data for headers\n");
1171 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1172 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1176 if (end + header_size + substr_header_size > length) {
1177 av_log(m->avctx, AV_LOG_ERROR,
1178 "Indicated length of substream %d data goes off end of "
1179 "packet.\n", substr);
1180 end = length - header_size - substr_header_size;
1183 if (end < substream_start) {
1184 av_log(avctx, AV_LOG_ERROR,
1185 "Indicated end offset of substream %d data "
1186 "is smaller than calculated start offset.\n",
1191 if (substr > m->max_decoded_substream)
1194 substream_parity_present[substr] = checkdata_present;
1195 substream_data_len[substr] = end - substream_start;
1196 substream_start = end;
1199 parity_bits = ff_mlp_calculate_parity(buf, 4);
1200 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1202 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1203 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1207 buf += header_size + substr_header_size;
1209 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1210 SubStream *s = &m->substream[substr];
1211 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1213 m->matrix_changed = 0;
1214 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1218 if (get_bits1(&gb)) {
1219 if (get_bits1(&gb)) {
1220 /* A restart header should be present. */
1221 if (read_restart_header(m, &gb, buf, substr) < 0)
1223 s->restart_seen = 1;
1226 if (!s->restart_seen)
1228 if (read_decoding_params(m, &gb, substr) < 0)
1232 if (!s->restart_seen)
1235 if ((ret = read_block_data(m, &gb, substr)) < 0)
1238 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1239 goto substream_length_mismatch;
1241 } while (!get_bits1(&gb));
1243 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1245 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1248 if (get_bits(&gb, 16) != 0xD234)
1249 return AVERROR_INVALIDDATA;
1251 shorten_by = get_bits(&gb, 16);
1252 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1253 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1254 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1255 return AVERROR_INVALIDDATA;
1257 if (substr == m->max_decoded_substream)
1258 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1261 if (substream_parity_present[substr]) {
1262 uint8_t parity, checksum;
1264 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1265 goto substream_length_mismatch;
1267 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1268 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1270 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1271 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1272 if ( get_bits(&gb, 8) != checksum)
1273 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1276 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1277 goto substream_length_mismatch;
1280 if (!s->restart_seen)
1281 av_log(m->avctx, AV_LOG_ERROR,
1282 "No restart header present in substream %d.\n", substr);
1284 buf += substream_data_len[substr];
1287 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1292 substream_length_mismatch:
1293 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1294 return AVERROR_INVALIDDATA;
1297 m->params_valid = 0;
1298 return AVERROR_INVALIDDATA;
1301 #if CONFIG_MLP_DECODER
1302 AVCodec ff_mlp_decoder = {
1304 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1305 .type = AVMEDIA_TYPE_AUDIO,
1306 .id = AV_CODEC_ID_MLP,
1307 .priv_data_size = sizeof(MLPDecodeContext),
1308 .init = mlp_decode_init,
1309 .decode = read_access_unit,
1310 .capabilities = AV_CODEC_CAP_DR1,
1313 #if CONFIG_TRUEHD_DECODER
1314 AVCodec ff_truehd_decoder = {
1316 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1317 .type = AVMEDIA_TYPE_AUDIO,
1318 .id = AV_CODEC_ID_TRUEHD,
1319 .priv_data_size = sizeof(MLPDecodeContext),
1320 .init = mlp_decode_init,
1321 .decode = read_access_unit,
1322 .capabilities = AV_CODEC_CAP_DR1,
1324 #endif /* CONFIG_TRUEHD_DECODER */