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"
33 #include "libavutil/mem_internal.h"
34 #include "libavutil/thread.h"
37 #include "libavutil/crc.h"
39 #include "mlp_parse.h"
44 /** number of bits used for VLC lookup - longest Huffman code is 9 */
47 #define VLC_STATIC_SIZE 64
50 #define VLC_STATIC_SIZE 512
53 typedef struct SubStream {
54 /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
58 /** restart header data */
59 /// The type of noise to be used in the rematrix stage.
62 /// The index of the first channel coded in this substream.
64 /// The index of the last channel coded in this substream.
66 /// The number of channels input into the rematrix stage.
67 uint8_t max_matrix_channel;
68 /// For each channel output by the matrix, the output channel to map it to
69 uint8_t ch_assign[MAX_CHANNELS];
70 /// The channel layout for this substream
72 /// The matrix encoding mode for this substream
73 enum AVMatrixEncoding matrix_encoding;
75 /// Channel coding parameters for channels in the substream
76 ChannelParams channel_params[MAX_CHANNELS];
78 /// The left shift applied to random noise in 0x31ea substreams.
80 /// The current seed value for the pseudorandom noise generator(s).
81 uint32_t noisegen_seed;
83 /// Set if the substream contains extra info to check the size of VLC blocks.
84 uint8_t data_check_present;
86 /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
87 uint8_t param_presence_flags;
88 #define PARAM_BLOCKSIZE (1 << 7)
89 #define PARAM_MATRIX (1 << 6)
90 #define PARAM_OUTSHIFT (1 << 5)
91 #define PARAM_QUANTSTEP (1 << 4)
92 #define PARAM_FIR (1 << 3)
93 #define PARAM_IIR (1 << 2)
94 #define PARAM_HUFFOFFSET (1 << 1)
95 #define PARAM_PRESENCE (1 << 0)
101 /// Number of matrices to be applied.
102 uint8_t num_primitive_matrices;
104 /// matrix output channel
105 uint8_t matrix_out_ch[MAX_MATRICES];
107 /// Whether the LSBs of the matrix output are encoded in the bitstream.
108 uint8_t lsb_bypass[MAX_MATRICES];
109 /// Matrix coefficients, stored as 2.14 fixed point.
110 DECLARE_ALIGNED(32, int32_t, matrix_coeff)[MAX_MATRICES][MAX_CHANNELS];
111 /// Left shift to apply to noise values in 0x31eb substreams.
112 uint8_t matrix_noise_shift[MAX_MATRICES];
115 /// Left shift to apply to Huffman-decoded residuals.
116 uint8_t quant_step_size[MAX_CHANNELS];
118 /// number of PCM samples in current audio block
120 /// Number of PCM samples decoded so far in this frame.
123 /// Left shift to apply to decoded PCM values to get final 24-bit output.
124 int8_t output_shift[MAX_CHANNELS];
126 /// Running XOR of all output samples.
127 int32_t lossless_check_data;
131 typedef struct MLPDecodeContext {
132 AVCodecContext *avctx;
134 /// Current access unit being read has a major sync.
135 int is_major_sync_unit;
137 /// Size of the major sync unit, in bytes
138 int major_sync_header_size;
140 /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
141 uint8_t params_valid;
143 /// Number of substreams contained within this stream.
144 uint8_t num_substreams;
146 /// Index of the last substream to decode - further substreams are skipped.
147 uint8_t max_decoded_substream;
149 /// Stream needs channel reordering to comply with FFmpeg's channel order
150 uint8_t needs_reordering;
152 /// number of PCM samples contained in each frame
153 int access_unit_size;
154 /// next power of two above the number of samples in each frame
155 int access_unit_size_pow2;
157 SubStream substream[MAX_SUBSTREAMS];
160 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
162 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
163 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
164 DECLARE_ALIGNED(32, int32_t, sample_buffer)[MAX_BLOCKSIZE][MAX_CHANNELS];
169 static const uint64_t thd_channel_order[] = {
170 AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT, // LR
171 AV_CH_FRONT_CENTER, // C
172 AV_CH_LOW_FREQUENCY, // LFE
173 AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT, // LRs
174 AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT, // LRvh
175 AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
176 AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT, // LRrs
177 AV_CH_BACK_CENTER, // Cs
178 AV_CH_TOP_CENTER, // Ts
179 AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
180 AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT, // LRw
181 AV_CH_TOP_FRONT_CENTER, // Cvh
182 AV_CH_LOW_FREQUENCY_2, // LFE2
185 static int mlp_channel_layout_subset(uint64_t channel_layout, uint64_t mask)
187 return channel_layout && ((channel_layout & mask) == channel_layout);
190 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
195 if (av_get_channel_layout_nb_channels(channel_layout) <= index)
198 for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
199 if (channel_layout & thd_channel_order[i] && !index--)
200 return thd_channel_order[i];
204 static VLC huff_vlc[3];
206 /** Initialize static data, constant between all invocations of the codec. */
208 static av_cold void init_static(void)
210 for (int i = 0; i < 3; i++) {
211 static VLC_TYPE vlc_buf[3 * VLC_STATIC_SIZE][2];
212 huff_vlc[i].table = &vlc_buf[i * VLC_STATIC_SIZE];
213 huff_vlc[i].table_allocated = VLC_STATIC_SIZE;
214 init_vlc(&huff_vlc[i], VLC_BITS, 18,
215 &ff_mlp_huffman_tables[i][0][1], 2, 1,
216 &ff_mlp_huffman_tables[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
222 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
223 unsigned int substr, unsigned int ch)
225 SubStream *s = &m->substream[substr];
226 ChannelParams *cp = &s->channel_params[ch];
227 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
228 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
229 int32_t sign_huff_offset = cp->huff_offset;
231 if (cp->codebook > 0)
232 sign_huff_offset -= 7 << lsb_bits;
235 sign_huff_offset -= 1 << sign_shift;
237 return sign_huff_offset;
240 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
243 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
244 unsigned int substr, unsigned int pos)
246 SubStream *s = &m->substream[substr];
247 unsigned int mat, channel;
249 for (mat = 0; mat < s->num_primitive_matrices; mat++)
250 if (s->lsb_bypass[mat])
251 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
253 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
254 ChannelParams *cp = &s->channel_params[channel];
255 int codebook = cp->codebook;
256 int quant_step_size = s->quant_step_size[channel];
257 int lsb_bits = cp->huff_lsbs - quant_step_size;
261 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
262 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
265 return AVERROR_INVALIDDATA;
268 result = (result << lsb_bits) + get_bits_long(gbp, lsb_bits);
270 result += cp->sign_huff_offset;
271 result *= 1 << quant_step_size;
273 m->sample_buffer[pos + s->blockpos][channel] = result;
279 static av_cold int mlp_decode_init(AVCodecContext *avctx)
281 static AVOnce init_static_once = AV_ONCE_INIT;
282 MLPDecodeContext *m = avctx->priv_data;
286 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
287 m->substream[substr].lossless_check_data = 0xffffffff;
288 ff_mlpdsp_init(&m->dsp);
290 ff_thread_once(&init_static_once, init_static);
295 /** Read a major sync info header - contains high level information about
296 * the stream - sample rate, channel arrangement etc. Most of this
297 * information is not actually necessary for decoding, only for playback.
300 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
305 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
308 if (mh.group1_bits == 0) {
309 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
310 return AVERROR_INVALIDDATA;
312 if (mh.group2_bits > mh.group1_bits) {
313 av_log(m->avctx, AV_LOG_ERROR,
314 "Channel group 2 cannot have more bits per sample than group 1.\n");
315 return AVERROR_INVALIDDATA;
318 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
319 av_log(m->avctx, AV_LOG_ERROR,
320 "Channel groups with differing sample rates are not currently supported.\n");
321 return AVERROR_INVALIDDATA;
324 if (mh.group1_samplerate == 0) {
325 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
326 return AVERROR_INVALIDDATA;
328 if (mh.group1_samplerate > MAX_SAMPLERATE) {
329 av_log(m->avctx, AV_LOG_ERROR,
330 "Sampling rate %d is greater than the supported maximum (%d).\n",
331 mh.group1_samplerate, MAX_SAMPLERATE);
332 return AVERROR_INVALIDDATA;
334 if (mh.access_unit_size > MAX_BLOCKSIZE) {
335 av_log(m->avctx, AV_LOG_ERROR,
336 "Block size %d is greater than the supported maximum (%d).\n",
337 mh.access_unit_size, MAX_BLOCKSIZE);
338 return AVERROR_INVALIDDATA;
340 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
341 av_log(m->avctx, AV_LOG_ERROR,
342 "Block size pow2 %d is greater than the supported maximum (%d).\n",
343 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
344 return AVERROR_INVALIDDATA;
347 if (mh.num_substreams == 0)
348 return AVERROR_INVALIDDATA;
349 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
350 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
351 return AVERROR_INVALIDDATA;
353 if (mh.num_substreams > MAX_SUBSTREAMS) {
354 avpriv_request_sample(m->avctx,
355 "%d substreams (more than the "
356 "maximum supported by the decoder)",
358 return AVERROR_PATCHWELCOME;
361 m->major_sync_header_size = mh.header_size;
363 m->access_unit_size = mh.access_unit_size;
364 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
366 m->num_substreams = mh.num_substreams;
368 /* limit to decoding 3 substreams, as the 4th is used by Dolby Atmos for non-audio data */
369 m->max_decoded_substream = FFMIN(m->num_substreams - 1, 2);
371 m->avctx->sample_rate = mh.group1_samplerate;
372 m->avctx->frame_size = mh.access_unit_size;
374 m->avctx->bits_per_raw_sample = mh.group1_bits;
375 if (mh.group1_bits > 16)
376 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
378 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
379 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(m->substream[m->max_decoded_substream].ch_assign,
380 m->substream[m->max_decoded_substream].output_shift,
381 m->substream[m->max_decoded_substream].max_matrix_channel,
382 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
385 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
386 m->substream[substr].restart_seen = 0;
388 /* Set the layout for each substream. When there's more than one, the first
389 * substream is Stereo. Subsequent substreams' layouts are indicated in the
391 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
392 if (mh.stream_type != 0xbb) {
393 avpriv_request_sample(m->avctx,
394 "unexpected stream_type %X in MLP",
396 return AVERROR_PATCHWELCOME;
398 if ((substr = (mh.num_substreams > 1)))
399 m->substream[0].mask = AV_CH_LAYOUT_STEREO;
400 m->substream[substr].mask = mh.channel_layout_mlp;
402 if (mh.stream_type != 0xba) {
403 avpriv_request_sample(m->avctx,
404 "unexpected stream_type %X in !MLP",
406 return AVERROR_PATCHWELCOME;
408 if ((substr = (mh.num_substreams > 1)))
409 m->substream[0].mask = AV_CH_LAYOUT_STEREO;
410 if (mh.num_substreams > 2)
411 if (mh.channel_layout_thd_stream2)
412 m->substream[2].mask = mh.channel_layout_thd_stream2;
414 m->substream[2].mask = mh.channel_layout_thd_stream1;
415 m->substream[substr].mask = mh.channel_layout_thd_stream1;
417 if (m->avctx->channels<=2 && m->substream[substr].mask == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
418 av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
419 m->max_decoded_substream = 0;
420 if (m->avctx->channels==2)
421 m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
425 m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
427 /* Parse the TrueHD decoder channel modifiers and set each substream's
428 * AVMatrixEncoding accordingly.
430 * The meaning of the modifiers depends on the channel layout:
432 * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
434 * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
436 * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
437 * layouts with an Ls/Rs channel pair
439 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
440 m->substream[substr].matrix_encoding = AV_MATRIX_ENCODING_NONE;
441 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
442 if (mh.num_substreams > 2 &&
443 mh.channel_layout_thd_stream2 & AV_CH_SIDE_LEFT &&
444 mh.channel_layout_thd_stream2 & AV_CH_SIDE_RIGHT &&
445 mh.channel_modifier_thd_stream2 == THD_CH_MODIFIER_SURROUNDEX)
446 m->substream[2].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
448 if (mh.num_substreams > 1 &&
449 mh.channel_layout_thd_stream1 & AV_CH_SIDE_LEFT &&
450 mh.channel_layout_thd_stream1 & AV_CH_SIDE_RIGHT &&
451 mh.channel_modifier_thd_stream1 == THD_CH_MODIFIER_SURROUNDEX)
452 m->substream[1].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
454 if (mh.num_substreams > 0)
455 switch (mh.channel_modifier_thd_stream0) {
456 case THD_CH_MODIFIER_LTRT:
457 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
459 case THD_CH_MODIFIER_LBINRBIN:
460 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
470 /** Read a restart header from a block in a substream. This contains parameters
471 * required to decode the audio that do not change very often. Generally
472 * (always) present only in blocks following a major sync. */
474 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
475 const uint8_t *buf, unsigned int substr)
477 SubStream *s = &m->substream[substr];
481 uint8_t lossless_check;
482 int start_count = get_bits_count(gbp);
483 int min_channel, max_channel, max_matrix_channel, noise_type;
484 const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
485 ? MAX_MATRIX_CHANNEL_MLP
486 : MAX_MATRIX_CHANNEL_TRUEHD;
488 sync_word = get_bits(gbp, 13);
490 if (sync_word != 0x31ea >> 1) {
491 av_log(m->avctx, AV_LOG_ERROR,
492 "restart header sync incorrect (got 0x%04x)\n", sync_word);
493 return AVERROR_INVALIDDATA;
496 noise_type = get_bits1(gbp);
498 if (m->avctx->codec_id == AV_CODEC_ID_MLP && noise_type) {
499 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
500 return AVERROR_INVALIDDATA;
503 skip_bits(gbp, 16); /* Output timestamp */
505 min_channel = get_bits(gbp, 4);
506 max_channel = get_bits(gbp, 4);
507 max_matrix_channel = get_bits(gbp, 4);
509 if (max_matrix_channel > std_max_matrix_channel) {
510 av_log(m->avctx, AV_LOG_ERROR,
511 "Max matrix channel cannot be greater than %d.\n",
512 std_max_matrix_channel);
513 return AVERROR_INVALIDDATA;
516 if (max_channel != max_matrix_channel) {
517 av_log(m->avctx, AV_LOG_ERROR,
518 "Max channel must be equal max matrix channel.\n");
519 return AVERROR_INVALIDDATA;
522 /* This should happen for TrueHD streams with >6 channels and MLP's noise
523 * type. It is not yet known if this is allowed. */
524 if (max_channel > MAX_MATRIX_CHANNEL_MLP && !noise_type) {
525 avpriv_request_sample(m->avctx,
526 "%d channels (more than the "
527 "maximum supported by the decoder)",
529 return AVERROR_PATCHWELCOME;
532 if (min_channel > max_channel) {
533 av_log(m->avctx, AV_LOG_ERROR,
534 "Substream min channel cannot be greater than max channel.\n");
535 return AVERROR_INVALIDDATA;
538 s->min_channel = min_channel;
539 s->max_channel = max_channel;
540 s->max_matrix_channel = max_matrix_channel;
541 s->noise_type = noise_type;
543 if (mlp_channel_layout_subset(m->avctx->request_channel_layout, s->mask) &&
544 m->max_decoded_substream > substr) {
545 av_log(m->avctx, AV_LOG_DEBUG,
546 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
547 "Further substreams will be skipped.\n",
548 s->max_channel + 1, s->mask, substr);
549 m->max_decoded_substream = substr;
552 s->noise_shift = get_bits(gbp, 4);
553 s->noisegen_seed = get_bits(gbp, 23);
557 s->data_check_present = get_bits1(gbp);
558 lossless_check = get_bits(gbp, 8);
559 if (substr == m->max_decoded_substream
560 && s->lossless_check_data != 0xffffffff) {
561 tmp = xor_32_to_8(s->lossless_check_data);
562 if (tmp != lossless_check)
563 av_log(m->avctx, AV_LOG_WARNING,
564 "Lossless check failed - expected %02x, calculated %02x.\n",
565 lossless_check, tmp);
570 memset(s->ch_assign, 0, sizeof(s->ch_assign));
572 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
573 int ch_assign = get_bits(gbp, 6);
574 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
575 uint64_t channel = thd_channel_layout_extract_channel(s->mask,
577 ch_assign = av_get_channel_layout_channel_index(s->mask,
580 if (ch_assign < 0 || ch_assign > s->max_matrix_channel) {
581 avpriv_request_sample(m->avctx,
582 "Assignment of matrix channel %d to invalid output channel %d",
584 return AVERROR_PATCHWELCOME;
586 s->ch_assign[ch_assign] = ch;
589 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
591 if (checksum != get_bits(gbp, 8))
592 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
594 /* Set default decoding parameters. */
595 s->param_presence_flags = 0xff;
596 s->num_primitive_matrices = 0;
598 s->lossless_check_data = 0;
600 memset(s->output_shift , 0, sizeof(s->output_shift ));
601 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
603 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
604 ChannelParams *cp = &s->channel_params[ch];
605 cp->filter_params[FIR].order = 0;
606 cp->filter_params[IIR].order = 0;
607 cp->filter_params[FIR].shift = 0;
608 cp->filter_params[IIR].shift = 0;
610 /* Default audio coding is 24-bit raw PCM. */
612 cp->sign_huff_offset = -(1 << 23);
617 if (substr == m->max_decoded_substream) {
618 m->avctx->channels = s->max_matrix_channel + 1;
619 m->avctx->channel_layout = s->mask;
620 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
622 s->max_matrix_channel,
623 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
625 if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
626 if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
627 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
628 int i = s->ch_assign[4];
629 s->ch_assign[4] = s->ch_assign[3];
630 s->ch_assign[3] = s->ch_assign[2];
632 } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
633 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
634 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
643 /** Read parameters for one of the prediction filters. */
645 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
646 unsigned int substr, unsigned int channel,
649 SubStream *s = &m->substream[substr];
650 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
651 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
652 const char fchar = filter ? 'I' : 'F';
655 // Filter is 0 for FIR, 1 for IIR.
656 av_assert0(filter < 2);
658 if (m->filter_changed[channel][filter]++ > 1) {
659 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
660 return AVERROR_INVALIDDATA;
663 order = get_bits(gbp, 4);
664 if (order > max_order) {
665 av_log(m->avctx, AV_LOG_ERROR,
666 "%cIR filter order %d is greater than maximum %d.\n",
667 fchar, order, max_order);
668 return AVERROR_INVALIDDATA;
673 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
674 int coeff_bits, coeff_shift;
676 fp->shift = get_bits(gbp, 4);
678 coeff_bits = get_bits(gbp, 5);
679 coeff_shift = get_bits(gbp, 3);
680 if (coeff_bits < 1 || coeff_bits > 16) {
681 av_log(m->avctx, AV_LOG_ERROR,
682 "%cIR filter coeff_bits must be between 1 and 16.\n",
684 return AVERROR_INVALIDDATA;
686 if (coeff_bits + coeff_shift > 16) {
687 av_log(m->avctx, AV_LOG_ERROR,
688 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
690 return AVERROR_INVALIDDATA;
693 for (i = 0; i < order; i++)
694 fcoeff[i] = get_sbits(gbp, coeff_bits) * (1 << coeff_shift);
696 if (get_bits1(gbp)) {
697 int state_bits, state_shift;
700 av_log(m->avctx, AV_LOG_ERROR,
701 "FIR filter has state data specified.\n");
702 return AVERROR_INVALIDDATA;
705 state_bits = get_bits(gbp, 4);
706 state_shift = get_bits(gbp, 4);
708 /* TODO: Check validity of state data. */
710 for (i = 0; i < order; i++)
711 fp->state[i] = state_bits ? get_sbits(gbp, state_bits) * (1 << state_shift) : 0;
718 /** Read parameters for primitive matrices. */
720 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
722 SubStream *s = &m->substream[substr];
723 unsigned int mat, ch;
724 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
726 : MAX_MATRICES_TRUEHD;
728 if (m->matrix_changed++ > 1) {
729 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
730 return AVERROR_INVALIDDATA;
733 s->num_primitive_matrices = get_bits(gbp, 4);
735 if (s->num_primitive_matrices > max_primitive_matrices) {
736 av_log(m->avctx, AV_LOG_ERROR,
737 "Number of primitive matrices cannot be greater than %d.\n",
738 max_primitive_matrices);
742 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
743 int frac_bits, max_chan;
744 s->matrix_out_ch[mat] = get_bits(gbp, 4);
745 frac_bits = get_bits(gbp, 4);
746 s->lsb_bypass [mat] = get_bits1(gbp);
748 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
749 av_log(m->avctx, AV_LOG_ERROR,
750 "Invalid channel %d specified as output from matrix.\n",
751 s->matrix_out_ch[mat]);
754 if (frac_bits > 14) {
755 av_log(m->avctx, AV_LOG_ERROR,
756 "Too many fractional bits specified.\n");
760 max_chan = s->max_matrix_channel;
764 for (ch = 0; ch <= max_chan; ch++) {
767 coeff_val = get_sbits(gbp, frac_bits + 2);
769 s->matrix_coeff[mat][ch] = coeff_val * (1 << (14 - frac_bits));
773 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
775 s->matrix_noise_shift[mat] = 0;
780 s->num_primitive_matrices = 0;
781 memset(s->matrix_out_ch, 0, sizeof(s->matrix_out_ch));
783 return AVERROR_INVALIDDATA;
786 /** Read channel parameters. */
788 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
789 GetBitContext *gbp, unsigned int ch)
791 SubStream *s = &m->substream[substr];
792 ChannelParams *cp = &s->channel_params[ch];
793 FilterParams *fir = &cp->filter_params[FIR];
794 FilterParams *iir = &cp->filter_params[IIR];
797 if (s->param_presence_flags & PARAM_FIR)
799 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
802 if (s->param_presence_flags & PARAM_IIR)
804 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
807 if (fir->order + iir->order > 8) {
808 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
809 return AVERROR_INVALIDDATA;
812 if (fir->order && iir->order &&
813 fir->shift != iir->shift) {
814 av_log(m->avctx, AV_LOG_ERROR,
815 "FIR and IIR filters must use the same precision.\n");
816 return AVERROR_INVALIDDATA;
818 /* The FIR and IIR filters must have the same precision.
819 * To simplify the filtering code, only the precision of the
820 * FIR filter is considered. If only the IIR filter is employed,
821 * the FIR filter precision is set to that of the IIR filter, so
822 * that the filtering code can use it. */
823 if (!fir->order && iir->order)
824 fir->shift = iir->shift;
826 if (s->param_presence_flags & PARAM_HUFFOFFSET)
828 cp->huff_offset = get_sbits(gbp, 15);
830 cp->codebook = get_bits(gbp, 2);
831 cp->huff_lsbs = get_bits(gbp, 5);
833 if (cp->codebook > 0 && cp->huff_lsbs > 24) {
834 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
836 return AVERROR_INVALIDDATA;
842 /** Read decoding parameters that change more often than those in the restart
845 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
848 SubStream *s = &m->substream[substr];
851 unsigned recompute_sho = 0;
853 if (s->param_presence_flags & PARAM_PRESENCE)
855 s->param_presence_flags = get_bits(gbp, 8);
857 if (s->param_presence_flags & PARAM_BLOCKSIZE)
858 if (get_bits1(gbp)) {
859 s->blocksize = get_bits(gbp, 9);
860 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
861 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
863 return AVERROR_INVALIDDATA;
867 if (s->param_presence_flags & PARAM_MATRIX)
869 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
872 if (s->param_presence_flags & PARAM_OUTSHIFT)
873 if (get_bits1(gbp)) {
874 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
875 s->output_shift[ch] = get_sbits(gbp, 4);
876 if (s->output_shift[ch] < 0) {
877 avpriv_request_sample(m->avctx, "Negative output_shift");
878 s->output_shift[ch] = 0;
881 if (substr == m->max_decoded_substream)
882 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
884 s->max_matrix_channel,
885 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
888 if (s->param_presence_flags & PARAM_QUANTSTEP)
890 for (ch = 0; ch <= s->max_channel; ch++) {
891 s->quant_step_size[ch] = get_bits(gbp, 4);
893 recompute_sho |= 1<<ch;
896 for (ch = s->min_channel; ch <= s->max_channel; ch++)
897 if (get_bits1(gbp)) {
898 recompute_sho |= 1<<ch;
899 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
905 for (ch = 0; ch <= s->max_channel; ch++) {
906 if (recompute_sho & (1<<ch)) {
907 ChannelParams *cp = &s->channel_params[ch];
909 if (cp->codebook > 0 && cp->huff_lsbs < s->quant_step_size[ch]) {
911 av_log(m->avctx, AV_LOG_ERROR, "quant_step_size larger than huff_lsbs\n");
912 ret = AVERROR_INVALIDDATA;
914 s->quant_step_size[ch] = 0;
917 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
923 #define MSB_MASK(bits) (-1u << (bits))
925 /** Generate PCM samples using the prediction filters and residual values
926 * read from the data stream, and update the filter state. */
928 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
929 unsigned int channel)
931 SubStream *s = &m->substream[substr];
932 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
933 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
934 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
935 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
936 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
937 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
938 unsigned int filter_shift = fir->shift;
939 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
941 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
942 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
944 m->dsp.mlp_filter_channel(firbuf, fircoeff,
945 fir->order, iir->order,
946 filter_shift, mask, s->blocksize,
947 &m->sample_buffer[s->blockpos][channel]);
949 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
950 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
953 /** Read a block of PCM residual data (or actual if no filtering active). */
955 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
958 SubStream *s = &m->substream[substr];
959 unsigned int i, ch, expected_stream_pos = 0;
962 if (s->data_check_present) {
963 expected_stream_pos = get_bits_count(gbp);
964 expected_stream_pos += get_bits(gbp, 16);
965 avpriv_request_sample(m->avctx,
966 "Substreams with VLC block size check info");
969 if (s->blockpos + s->blocksize > m->access_unit_size) {
970 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
971 return AVERROR_INVALIDDATA;
974 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
975 s->blocksize * sizeof(m->bypassed_lsbs[0]));
977 for (i = 0; i < s->blocksize; i++)
978 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
981 for (ch = s->min_channel; ch <= s->max_channel; ch++)
982 filter_channel(m, substr, ch);
984 s->blockpos += s->blocksize;
986 if (s->data_check_present) {
987 if (get_bits_count(gbp) != expected_stream_pos)
988 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
995 /** Data table used for TrueHD noise generation function. */
997 static const int8_t noise_table[256] = {
998 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
999 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
1000 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
1001 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
1002 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
1003 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
1004 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
1005 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
1006 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
1007 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
1008 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
1009 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
1010 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
1011 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
1012 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
1013 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
1016 /** Noise generation functions.
1017 * I'm not sure what these are for - they seem to be some kind of pseudorandom
1018 * sequence generators, used to generate noise data which is used when the
1019 * channels are rematrixed. I'm not sure if they provide a practical benefit
1020 * to compression, or just obfuscate the decoder. Are they for some kind of
1023 /** Generate two channels of noise, used in the matrix when
1024 * restart sync word == 0x31ea. */
1026 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
1028 SubStream *s = &m->substream[substr];
1030 uint32_t seed = s->noisegen_seed;
1031 unsigned int maxchan = s->max_matrix_channel;
1033 for (i = 0; i < s->blockpos; i++) {
1034 uint16_t seed_shr7 = seed >> 7;
1035 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) * (1 << s->noise_shift);
1036 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) * (1 << s->noise_shift);
1038 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1041 s->noisegen_seed = seed;
1044 /** Generate a block of noise, used when restart sync word == 0x31eb. */
1046 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
1048 SubStream *s = &m->substream[substr];
1050 uint32_t seed = s->noisegen_seed;
1052 for (i = 0; i < m->access_unit_size_pow2; i++) {
1053 uint8_t seed_shr15 = seed >> 15;
1054 m->noise_buffer[i] = noise_table[seed_shr15];
1055 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
1058 s->noisegen_seed = seed;
1061 /** Write the audio data into the output buffer. */
1063 static int output_data(MLPDecodeContext *m, unsigned int substr,
1064 AVFrame *frame, int *got_frame_ptr)
1066 AVCodecContext *avctx = m->avctx;
1067 SubStream *s = &m->substream[substr];
1069 unsigned int maxchan;
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 maxchan = s->max_matrix_channel;
1084 if (!s->noise_type) {
1085 generate_2_noise_channels(m, substr);
1088 fill_noise_buffer(m, substr);
1091 /* Apply the channel matrices in turn to reconstruct the original audio
1093 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1094 unsigned int dest_ch = s->matrix_out_ch[mat];
1095 m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1096 s->matrix_coeff[mat],
1097 &m->bypassed_lsbs[0][mat],
1099 s->num_primitive_matrices - mat,
1103 s->matrix_noise_shift[mat],
1104 m->access_unit_size_pow2,
1105 MSB_MASK(s->quant_step_size[dest_ch]));
1108 /* get output buffer */
1109 frame->nb_samples = s->blockpos;
1110 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1112 s->lossless_check_data = m->dsp.mlp_pack_output(s->lossless_check_data,
1118 s->max_matrix_channel,
1121 /* Update matrix encoding side data */
1122 if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1130 /** Read an access unit from the stream.
1131 * @return negative on error, 0 if not enough data is present in the input stream,
1132 * otherwise the number of bytes consumed. */
1134 static int read_access_unit(AVCodecContext *avctx, void* data,
1135 int *got_frame_ptr, AVPacket *avpkt)
1137 const uint8_t *buf = avpkt->data;
1138 int buf_size = avpkt->size;
1139 MLPDecodeContext *m = avctx->priv_data;
1141 unsigned int length, substr;
1142 unsigned int substream_start;
1143 unsigned int header_size = 4;
1144 unsigned int substr_header_size = 0;
1145 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1146 uint16_t substream_data_len[MAX_SUBSTREAMS];
1147 uint8_t parity_bits;
1151 return AVERROR_INVALIDDATA;
1153 length = (AV_RB16(buf) & 0xfff) * 2;
1155 if (length < 4 || length > buf_size)
1156 return AVERROR_INVALIDDATA;
1158 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1160 m->is_major_sync_unit = 0;
1161 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1162 if (read_major_sync(m, &gb) < 0)
1164 m->is_major_sync_unit = 1;
1165 header_size += m->major_sync_header_size;
1168 if (!m->params_valid) {
1169 av_log(m->avctx, AV_LOG_WARNING,
1170 "Stream parameters not seen; skipping frame.\n");
1175 substream_start = 0;
1177 for (substr = 0; substr < m->num_substreams; substr++) {
1178 int extraword_present, checkdata_present, end, nonrestart_substr;
1180 extraword_present = get_bits1(&gb);
1181 nonrestart_substr = get_bits1(&gb);
1182 checkdata_present = get_bits1(&gb);
1185 end = get_bits(&gb, 12) * 2;
1187 substr_header_size += 2;
1189 if (extraword_present) {
1190 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1191 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1195 substr_header_size += 2;
1198 if (length < header_size + substr_header_size) {
1199 av_log(m->avctx, AV_LOG_ERROR, "Insufficient data for headers\n");
1203 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1204 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1208 if (end + header_size + substr_header_size > length) {
1209 av_log(m->avctx, AV_LOG_ERROR,
1210 "Indicated length of substream %d data goes off end of "
1211 "packet.\n", substr);
1212 end = length - header_size - substr_header_size;
1215 if (end < substream_start) {
1216 av_log(avctx, AV_LOG_ERROR,
1217 "Indicated end offset of substream %d data "
1218 "is smaller than calculated start offset.\n",
1223 if (substr > m->max_decoded_substream)
1226 substream_parity_present[substr] = checkdata_present;
1227 substream_data_len[substr] = end - substream_start;
1228 substream_start = end;
1231 parity_bits = ff_mlp_calculate_parity(buf, 4);
1232 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1234 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1235 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1239 buf += header_size + substr_header_size;
1241 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1242 SubStream *s = &m->substream[substr];
1243 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1245 m->matrix_changed = 0;
1246 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1250 if (get_bits1(&gb)) {
1251 if (get_bits1(&gb)) {
1252 /* A restart header should be present. */
1253 if (read_restart_header(m, &gb, buf, substr) < 0)
1255 s->restart_seen = 1;
1258 if (!s->restart_seen)
1260 if (read_decoding_params(m, &gb, substr) < 0)
1264 if (!s->restart_seen)
1267 if ((ret = read_block_data(m, &gb, substr)) < 0)
1270 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1271 goto substream_length_mismatch;
1273 } while (!get_bits1(&gb));
1275 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1277 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1280 if (get_bits(&gb, 16) != 0xD234)
1281 return AVERROR_INVALIDDATA;
1283 shorten_by = get_bits(&gb, 16);
1284 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1285 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1286 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1287 return AVERROR_INVALIDDATA;
1289 if (substr == m->max_decoded_substream)
1290 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1293 if (substream_parity_present[substr]) {
1294 uint8_t parity, checksum;
1296 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1297 goto substream_length_mismatch;
1299 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1300 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1302 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1303 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1304 if ( get_bits(&gb, 8) != checksum)
1305 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1308 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1309 goto substream_length_mismatch;
1312 if (!s->restart_seen)
1313 av_log(m->avctx, AV_LOG_ERROR,
1314 "No restart header present in substream %d.\n", substr);
1316 buf += substream_data_len[substr];
1319 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1324 substream_length_mismatch:
1325 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1326 return AVERROR_INVALIDDATA;
1329 m->params_valid = 0;
1330 return AVERROR_INVALIDDATA;
1333 #if CONFIG_MLP_DECODER
1334 const AVCodec ff_mlp_decoder = {
1336 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1337 .type = AVMEDIA_TYPE_AUDIO,
1338 .id = AV_CODEC_ID_MLP,
1339 .priv_data_size = sizeof(MLPDecodeContext),
1340 .init = mlp_decode_init,
1341 .decode = read_access_unit,
1342 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1343 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1346 #if CONFIG_TRUEHD_DECODER
1347 const AVCodec ff_truehd_decoder = {
1349 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1350 .type = AVMEDIA_TYPE_AUDIO,
1351 .id = AV_CODEC_ID_TRUEHD,
1352 .priv_data_size = sizeof(MLPDecodeContext),
1353 .init = mlp_decode_init,
1354 .decode = read_access_unit,
1355 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1356 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1358 #endif /* CONFIG_TRUEHD_DECODER */