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);
735 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
736 int frac_bits, max_chan;
737 s->matrix_out_ch[mat] = get_bits(gbp, 4);
738 frac_bits = get_bits(gbp, 4);
739 s->lsb_bypass [mat] = get_bits1(gbp);
741 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
742 av_log(m->avctx, AV_LOG_ERROR,
743 "Invalid channel %d specified as output from matrix.\n",
744 s->matrix_out_ch[mat]);
747 if (frac_bits > 14) {
748 av_log(m->avctx, AV_LOG_ERROR,
749 "Too many fractional bits specified.\n");
753 max_chan = s->max_matrix_channel;
757 for (ch = 0; ch <= max_chan; ch++) {
760 coeff_val = get_sbits(gbp, frac_bits + 2);
762 s->matrix_coeff[mat][ch] = coeff_val * (1 << (14 - frac_bits));
766 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
768 s->matrix_noise_shift[mat] = 0;
773 s->num_primitive_matrices = 0;
774 memset(s->matrix_out_ch, 0, sizeof(s->matrix_out_ch));
776 return AVERROR_INVALIDDATA;
779 /** Read channel parameters. */
781 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
782 GetBitContext *gbp, unsigned int ch)
784 SubStream *s = &m->substream[substr];
785 ChannelParams *cp = &s->channel_params[ch];
786 FilterParams *fir = &cp->filter_params[FIR];
787 FilterParams *iir = &cp->filter_params[IIR];
790 if (s->param_presence_flags & PARAM_FIR)
792 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
795 if (s->param_presence_flags & PARAM_IIR)
797 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
800 if (fir->order + iir->order > 8) {
801 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
802 return AVERROR_INVALIDDATA;
805 if (fir->order && iir->order &&
806 fir->shift != iir->shift) {
807 av_log(m->avctx, AV_LOG_ERROR,
808 "FIR and IIR filters must use the same precision.\n");
809 return AVERROR_INVALIDDATA;
811 /* The FIR and IIR filters must have the same precision.
812 * To simplify the filtering code, only the precision of the
813 * FIR filter is considered. If only the IIR filter is employed,
814 * the FIR filter precision is set to that of the IIR filter, so
815 * that the filtering code can use it. */
816 if (!fir->order && iir->order)
817 fir->shift = iir->shift;
819 if (s->param_presence_flags & PARAM_HUFFOFFSET)
821 cp->huff_offset = get_sbits(gbp, 15);
823 cp->codebook = get_bits(gbp, 2);
824 cp->huff_lsbs = get_bits(gbp, 5);
826 if (cp->huff_lsbs > 24) {
827 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
829 return AVERROR_INVALIDDATA;
835 /** Read decoding parameters that change more often than those in the restart
838 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
841 SubStream *s = &m->substream[substr];
844 unsigned recompute_sho = 0;
846 if (s->param_presence_flags & PARAM_PRESENCE)
848 s->param_presence_flags = get_bits(gbp, 8);
850 if (s->param_presence_flags & PARAM_BLOCKSIZE)
851 if (get_bits1(gbp)) {
852 s->blocksize = get_bits(gbp, 9);
853 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
854 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
856 return AVERROR_INVALIDDATA;
860 if (s->param_presence_flags & PARAM_MATRIX)
862 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
865 if (s->param_presence_flags & PARAM_OUTSHIFT)
866 if (get_bits1(gbp)) {
867 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
868 s->output_shift[ch] = get_sbits(gbp, 4);
869 if (s->output_shift[ch] < 0) {
870 avpriv_request_sample(m->avctx, "Negative output_shift");
871 s->output_shift[ch] = 0;
874 if (substr == m->max_decoded_substream)
875 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
877 s->max_matrix_channel,
878 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
881 if (s->param_presence_flags & PARAM_QUANTSTEP)
883 for (ch = 0; ch <= s->max_channel; ch++) {
884 s->quant_step_size[ch] = get_bits(gbp, 4);
886 recompute_sho |= 1<<ch;
889 for (ch = s->min_channel; ch <= s->max_channel; ch++)
890 if (get_bits1(gbp)) {
891 recompute_sho |= 1<<ch;
892 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
898 for (ch = 0; ch <= s->max_channel; ch++) {
899 if (recompute_sho & (1<<ch)) {
900 ChannelParams *cp = &s->channel_params[ch];
902 if (cp->codebook > 0 && cp->huff_lsbs < s->quant_step_size[ch]) {
904 av_log(m->avctx, AV_LOG_ERROR, "quant_step_size larger than huff_lsbs\n");
905 ret = AVERROR_INVALIDDATA;
907 s->quant_step_size[ch] = 0;
910 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
916 #define MSB_MASK(bits) (-1u << (bits))
918 /** Generate PCM samples using the prediction filters and residual values
919 * read from the data stream, and update the filter state. */
921 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
922 unsigned int channel)
924 SubStream *s = &m->substream[substr];
925 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
926 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
927 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
928 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
929 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
930 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
931 unsigned int filter_shift = fir->shift;
932 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
934 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
935 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
937 m->dsp.mlp_filter_channel(firbuf, fircoeff,
938 fir->order, iir->order,
939 filter_shift, mask, s->blocksize,
940 &m->sample_buffer[s->blockpos][channel]);
942 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
943 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
946 /** Read a block of PCM residual data (or actual if no filtering active). */
948 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
951 SubStream *s = &m->substream[substr];
952 unsigned int i, ch, expected_stream_pos = 0;
955 if (s->data_check_present) {
956 expected_stream_pos = get_bits_count(gbp);
957 expected_stream_pos += get_bits(gbp, 16);
958 avpriv_request_sample(m->avctx,
959 "Substreams with VLC block size check info");
962 if (s->blockpos + s->blocksize > m->access_unit_size) {
963 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
964 return AVERROR_INVALIDDATA;
967 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
968 s->blocksize * sizeof(m->bypassed_lsbs[0]));
970 for (i = 0; i < s->blocksize; i++)
971 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
974 for (ch = s->min_channel; ch <= s->max_channel; ch++)
975 filter_channel(m, substr, ch);
977 s->blockpos += s->blocksize;
979 if (s->data_check_present) {
980 if (get_bits_count(gbp) != expected_stream_pos)
981 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
988 /** Data table used for TrueHD noise generation function. */
990 static const int8_t noise_table[256] = {
991 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
992 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
993 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
994 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
995 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
996 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
997 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
998 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
999 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
1000 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
1001 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
1002 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
1003 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
1004 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
1005 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
1006 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
1009 /** Noise generation functions.
1010 * I'm not sure what these are for - they seem to be some kind of pseudorandom
1011 * sequence generators, used to generate noise data which is used when the
1012 * channels are rematrixed. I'm not sure if they provide a practical benefit
1013 * to compression, or just obfuscate the decoder. Are they for some kind of
1016 /** Generate two channels of noise, used in the matrix when
1017 * restart sync word == 0x31ea. */
1019 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
1021 SubStream *s = &m->substream[substr];
1023 uint32_t seed = s->noisegen_seed;
1024 unsigned int maxchan = s->max_matrix_channel;
1026 for (i = 0; i < s->blockpos; i++) {
1027 uint16_t seed_shr7 = seed >> 7;
1028 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) * (1 << s->noise_shift);
1029 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) * (1 << s->noise_shift);
1031 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1034 s->noisegen_seed = seed;
1037 /** Generate a block of noise, used when restart sync word == 0x31eb. */
1039 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
1041 SubStream *s = &m->substream[substr];
1043 uint32_t seed = s->noisegen_seed;
1045 for (i = 0; i < m->access_unit_size_pow2; i++) {
1046 uint8_t seed_shr15 = seed >> 15;
1047 m->noise_buffer[i] = noise_table[seed_shr15];
1048 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
1051 s->noisegen_seed = seed;
1054 /** Write the audio data into the output buffer. */
1056 static int output_data(MLPDecodeContext *m, unsigned int substr,
1057 AVFrame *frame, int *got_frame_ptr)
1059 AVCodecContext *avctx = m->avctx;
1060 SubStream *s = &m->substream[substr];
1062 unsigned int maxchan;
1064 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1066 if (m->avctx->channels != s->max_matrix_channel + 1) {
1067 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1068 return AVERROR_INVALIDDATA;
1072 av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1073 return AVERROR_INVALIDDATA;
1076 maxchan = s->max_matrix_channel;
1077 if (!s->noise_type) {
1078 generate_2_noise_channels(m, substr);
1081 fill_noise_buffer(m, substr);
1084 /* Apply the channel matrices in turn to reconstruct the original audio
1086 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1087 unsigned int dest_ch = s->matrix_out_ch[mat];
1088 m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1089 s->matrix_coeff[mat],
1090 &m->bypassed_lsbs[0][mat],
1092 s->num_primitive_matrices - mat,
1096 s->matrix_noise_shift[mat],
1097 m->access_unit_size_pow2,
1098 MSB_MASK(s->quant_step_size[dest_ch]));
1101 /* get output buffer */
1102 frame->nb_samples = s->blockpos;
1103 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1105 s->lossless_check_data = m->dsp.mlp_pack_output(s->lossless_check_data,
1111 s->max_matrix_channel,
1114 /* Update matrix encoding side data */
1115 if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1123 /** Read an access unit from the stream.
1124 * @return negative on error, 0 if not enough data is present in the input stream,
1125 * otherwise the number of bytes consumed. */
1127 static int read_access_unit(AVCodecContext *avctx, void* data,
1128 int *got_frame_ptr, AVPacket *avpkt)
1130 const uint8_t *buf = avpkt->data;
1131 int buf_size = avpkt->size;
1132 MLPDecodeContext *m = avctx->priv_data;
1134 unsigned int length, substr;
1135 unsigned int substream_start;
1136 unsigned int header_size = 4;
1137 unsigned int substr_header_size = 0;
1138 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1139 uint16_t substream_data_len[MAX_SUBSTREAMS];
1140 uint8_t parity_bits;
1144 return AVERROR_INVALIDDATA;
1146 length = (AV_RB16(buf) & 0xfff) * 2;
1148 if (length < 4 || length > buf_size)
1149 return AVERROR_INVALIDDATA;
1151 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1153 m->is_major_sync_unit = 0;
1154 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1155 if (read_major_sync(m, &gb) < 0)
1157 m->is_major_sync_unit = 1;
1158 header_size += m->major_sync_header_size;
1161 if (!m->params_valid) {
1162 av_log(m->avctx, AV_LOG_WARNING,
1163 "Stream parameters not seen; skipping frame.\n");
1168 substream_start = 0;
1170 for (substr = 0; substr < m->num_substreams; substr++) {
1171 int extraword_present, checkdata_present, end, nonrestart_substr;
1173 extraword_present = get_bits1(&gb);
1174 nonrestart_substr = get_bits1(&gb);
1175 checkdata_present = get_bits1(&gb);
1178 end = get_bits(&gb, 12) * 2;
1180 substr_header_size += 2;
1182 if (extraword_present) {
1183 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1184 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1188 substr_header_size += 2;
1191 if (length < header_size + substr_header_size) {
1192 av_log(m->avctx, AV_LOG_ERROR, "Insuffient data for headers\n");
1196 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1197 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1201 if (end + header_size + substr_header_size > length) {
1202 av_log(m->avctx, AV_LOG_ERROR,
1203 "Indicated length of substream %d data goes off end of "
1204 "packet.\n", substr);
1205 end = length - header_size - substr_header_size;
1208 if (end < substream_start) {
1209 av_log(avctx, AV_LOG_ERROR,
1210 "Indicated end offset of substream %d data "
1211 "is smaller than calculated start offset.\n",
1216 if (substr > m->max_decoded_substream)
1219 substream_parity_present[substr] = checkdata_present;
1220 substream_data_len[substr] = end - substream_start;
1221 substream_start = end;
1224 parity_bits = ff_mlp_calculate_parity(buf, 4);
1225 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1227 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1228 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1232 buf += header_size + substr_header_size;
1234 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1235 SubStream *s = &m->substream[substr];
1236 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1238 m->matrix_changed = 0;
1239 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1243 if (get_bits1(&gb)) {
1244 if (get_bits1(&gb)) {
1245 /* A restart header should be present. */
1246 if (read_restart_header(m, &gb, buf, substr) < 0)
1248 s->restart_seen = 1;
1251 if (!s->restart_seen)
1253 if (read_decoding_params(m, &gb, substr) < 0)
1257 if (!s->restart_seen)
1260 if ((ret = read_block_data(m, &gb, substr)) < 0)
1263 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1264 goto substream_length_mismatch;
1266 } while (!get_bits1(&gb));
1268 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1270 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1273 if (get_bits(&gb, 16) != 0xD234)
1274 return AVERROR_INVALIDDATA;
1276 shorten_by = get_bits(&gb, 16);
1277 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1278 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1279 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1280 return AVERROR_INVALIDDATA;
1282 if (substr == m->max_decoded_substream)
1283 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1286 if (substream_parity_present[substr]) {
1287 uint8_t parity, checksum;
1289 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1290 goto substream_length_mismatch;
1292 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1293 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1295 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1296 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1297 if ( get_bits(&gb, 8) != checksum)
1298 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1301 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1302 goto substream_length_mismatch;
1305 if (!s->restart_seen)
1306 av_log(m->avctx, AV_LOG_ERROR,
1307 "No restart header present in substream %d.\n", substr);
1309 buf += substream_data_len[substr];
1312 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1317 substream_length_mismatch:
1318 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1319 return AVERROR_INVALIDDATA;
1322 m->params_valid = 0;
1323 return AVERROR_INVALIDDATA;
1326 #if CONFIG_MLP_DECODER
1327 AVCodec ff_mlp_decoder = {
1329 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1330 .type = AVMEDIA_TYPE_AUDIO,
1331 .id = AV_CODEC_ID_MLP,
1332 .priv_data_size = sizeof(MLPDecodeContext),
1333 .init = mlp_decode_init,
1334 .decode = read_access_unit,
1335 .capabilities = AV_CODEC_CAP_DR1,
1338 #if CONFIG_TRUEHD_DECODER
1339 AVCodec ff_truehd_decoder = {
1341 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1342 .type = AVMEDIA_TYPE_AUDIO,
1343 .id = AV_CODEC_ID_TRUEHD,
1344 .priv_data_size = sizeof(MLPDecodeContext),
1345 .init = mlp_decode_init,
1346 .decode = read_access_unit,
1347 .capabilities = AV_CODEC_CAP_DR1,
1349 #endif /* CONFIG_TRUEHD_DECODER */