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 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 /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
136 uint8_t params_valid;
138 /// Number of substreams contained within this stream.
139 uint8_t num_substreams;
141 /// Index of the last substream to decode - further substreams are skipped.
142 uint8_t max_decoded_substream;
144 /// Stream needs channel reordering to comply with FFmpeg's channel order
145 uint8_t needs_reordering;
147 /// number of PCM samples contained in each frame
148 int access_unit_size;
149 /// next power of two above the number of samples in each frame
150 int access_unit_size_pow2;
152 SubStream substream[MAX_SUBSTREAMS];
155 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
157 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
158 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
159 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
164 static const uint64_t thd_channel_order[] = {
165 AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT, // LR
166 AV_CH_FRONT_CENTER, // C
167 AV_CH_LOW_FREQUENCY, // LFE
168 AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT, // LRs
169 AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT, // LRvh
170 AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
171 AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT, // LRrs
172 AV_CH_BACK_CENTER, // Cs
173 AV_CH_TOP_CENTER, // Ts
174 AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
175 AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT, // LRw
176 AV_CH_TOP_FRONT_CENTER, // Cvh
177 AV_CH_LOW_FREQUENCY_2, // LFE2
180 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
185 if (av_get_channel_layout_nb_channels(channel_layout) <= index)
188 for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
189 if (channel_layout & thd_channel_order[i] && !index--)
190 return thd_channel_order[i];
194 static VLC huff_vlc[3];
196 /** Initialize static data, constant between all invocations of the codec. */
198 static av_cold void init_static(void)
200 if (!huff_vlc[0].bits) {
201 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
202 &ff_mlp_huffman_tables[0][0][1], 2, 1,
203 &ff_mlp_huffman_tables[0][0][0], 2, 1, VLC_STATIC_SIZE);
204 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
205 &ff_mlp_huffman_tables[1][0][1], 2, 1,
206 &ff_mlp_huffman_tables[1][0][0], 2, 1, VLC_STATIC_SIZE);
207 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
208 &ff_mlp_huffman_tables[2][0][1], 2, 1,
209 &ff_mlp_huffman_tables[2][0][0], 2, 1, VLC_STATIC_SIZE);
215 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
216 unsigned int substr, unsigned int ch)
218 SubStream *s = &m->substream[substr];
219 ChannelParams *cp = &s->channel_params[ch];
220 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
221 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
222 int32_t sign_huff_offset = cp->huff_offset;
224 if (cp->codebook > 0)
225 sign_huff_offset -= 7 << lsb_bits;
228 sign_huff_offset -= 1 << sign_shift;
230 return sign_huff_offset;
233 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
236 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
237 unsigned int substr, unsigned int pos)
239 SubStream *s = &m->substream[substr];
240 unsigned int mat, channel;
242 for (mat = 0; mat < s->num_primitive_matrices; mat++)
243 if (s->lsb_bypass[mat])
244 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
246 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
247 ChannelParams *cp = &s->channel_params[channel];
248 int codebook = cp->codebook;
249 int quant_step_size = s->quant_step_size[channel];
250 int lsb_bits = cp->huff_lsbs - quant_step_size;
254 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
255 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
258 return AVERROR_INVALIDDATA;
261 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
263 result += cp->sign_huff_offset;
264 result <<= quant_step_size;
266 m->sample_buffer[pos + s->blockpos][channel] = result;
272 static av_cold int mlp_decode_init(AVCodecContext *avctx)
274 MLPDecodeContext *m = avctx->priv_data;
279 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
280 m->substream[substr].lossless_check_data = 0xffffffff;
281 ff_mlpdsp_init(&m->dsp);
286 /** Read a major sync info header - contains high level information about
287 * the stream - sample rate, channel arrangement etc. Most of this
288 * information is not actually necessary for decoding, only for playback.
291 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
296 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
299 if (mh.group1_bits == 0) {
300 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
301 return AVERROR_INVALIDDATA;
303 if (mh.group2_bits > mh.group1_bits) {
304 av_log(m->avctx, AV_LOG_ERROR,
305 "Channel group 2 cannot have more bits per sample than group 1.\n");
306 return AVERROR_INVALIDDATA;
309 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
310 av_log(m->avctx, AV_LOG_ERROR,
311 "Channel groups with differing sample rates are not currently supported.\n");
312 return AVERROR_INVALIDDATA;
315 if (mh.group1_samplerate == 0) {
316 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
317 return AVERROR_INVALIDDATA;
319 if (mh.group1_samplerate > MAX_SAMPLERATE) {
320 av_log(m->avctx, AV_LOG_ERROR,
321 "Sampling rate %d is greater than the supported maximum (%d).\n",
322 mh.group1_samplerate, MAX_SAMPLERATE);
323 return AVERROR_INVALIDDATA;
325 if (mh.access_unit_size > MAX_BLOCKSIZE) {
326 av_log(m->avctx, AV_LOG_ERROR,
327 "Block size %d is greater than the supported maximum (%d).\n",
328 mh.access_unit_size, MAX_BLOCKSIZE);
329 return AVERROR_INVALIDDATA;
331 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
332 av_log(m->avctx, AV_LOG_ERROR,
333 "Block size pow2 %d is greater than the supported maximum (%d).\n",
334 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
335 return AVERROR_INVALIDDATA;
338 if (mh.num_substreams == 0)
339 return AVERROR_INVALIDDATA;
340 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
341 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
342 return AVERROR_INVALIDDATA;
344 if (mh.num_substreams > MAX_SUBSTREAMS) {
345 avpriv_request_sample(m->avctx,
346 "%d substreams (more than the "
347 "maximum supported by the decoder)",
349 return AVERROR_PATCHWELCOME;
352 m->access_unit_size = mh.access_unit_size;
353 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
355 m->num_substreams = mh.num_substreams;
356 m->max_decoded_substream = m->num_substreams - 1;
358 m->avctx->sample_rate = mh.group1_samplerate;
359 m->avctx->frame_size = mh.access_unit_size;
361 m->avctx->bits_per_raw_sample = mh.group1_bits;
362 if (mh.group1_bits > 16)
363 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
365 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
368 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
369 m->substream[substr].restart_seen = 0;
371 /* Set the layout for each substream. When there's more than one, the first
372 * substream is Stereo. Subsequent substreams' layouts are indicated in the
374 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
375 if (mh.stream_type != 0xbb) {
376 avpriv_request_sample(m->avctx,
377 "unexpected stream_type %X in MLP",
379 return AVERROR_PATCHWELCOME;
381 if ((substr = (mh.num_substreams > 1)))
382 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
383 m->substream[substr].ch_layout = mh.channel_layout_mlp;
385 if (mh.stream_type != 0xba) {
386 avpriv_request_sample(m->avctx,
387 "unexpected stream_type %X in !MLP",
389 return AVERROR_PATCHWELCOME;
391 if ((substr = (mh.num_substreams > 1)))
392 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
393 if (mh.num_substreams > 2)
394 if (mh.channel_layout_thd_stream2)
395 m->substream[2].ch_layout = mh.channel_layout_thd_stream2;
397 m->substream[2].ch_layout = mh.channel_layout_thd_stream1;
398 m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;
400 if (m->avctx->channels<=2 && m->substream[substr].ch_layout == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
401 av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
402 m->max_decoded_substream = 0;
403 if (m->avctx->channels==2)
404 m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
408 m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
410 /* Parse the TrueHD decoder channel modifiers and set each substream's
411 * AVMatrixEncoding accordingly.
413 * The meaning of the modifiers depends on the channel layout:
415 * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
417 * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
419 * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
420 * layouts with an Ls/Rs channel pair
422 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
423 m->substream[substr].matrix_encoding = AV_MATRIX_ENCODING_NONE;
424 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
425 if (mh.num_substreams > 2 &&
426 mh.channel_layout_thd_stream2 & AV_CH_SIDE_LEFT &&
427 mh.channel_layout_thd_stream2 & AV_CH_SIDE_RIGHT &&
428 mh.channel_modifier_thd_stream2 == THD_CH_MODIFIER_SURROUNDEX)
429 m->substream[2].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
431 if (mh.num_substreams > 1 &&
432 mh.channel_layout_thd_stream1 & AV_CH_SIDE_LEFT &&
433 mh.channel_layout_thd_stream1 & AV_CH_SIDE_RIGHT &&
434 mh.channel_modifier_thd_stream1 == THD_CH_MODIFIER_SURROUNDEX)
435 m->substream[1].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
437 if (mh.num_substreams > 0)
438 switch (mh.channel_modifier_thd_stream0) {
439 case THD_CH_MODIFIER_LTRT:
440 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
442 case THD_CH_MODIFIER_LBINRBIN:
443 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
453 /** Read a restart header from a block in a substream. This contains parameters
454 * required to decode the audio that do not change very often. Generally
455 * (always) present only in blocks following a major sync. */
457 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
458 const uint8_t *buf, unsigned int substr)
460 SubStream *s = &m->substream[substr];
464 uint8_t lossless_check;
465 int start_count = get_bits_count(gbp);
466 int min_channel, max_channel, max_matrix_channel;
467 const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
468 ? MAX_MATRIX_CHANNEL_MLP
469 : MAX_MATRIX_CHANNEL_TRUEHD;
471 sync_word = get_bits(gbp, 13);
473 if (sync_word != 0x31ea >> 1) {
474 av_log(m->avctx, AV_LOG_ERROR,
475 "restart header sync incorrect (got 0x%04x)\n", sync_word);
476 return AVERROR_INVALIDDATA;
479 s->noise_type = get_bits1(gbp);
481 if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
482 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
483 return AVERROR_INVALIDDATA;
486 skip_bits(gbp, 16); /* Output timestamp */
488 min_channel = get_bits(gbp, 4);
489 max_channel = get_bits(gbp, 4);
490 max_matrix_channel = get_bits(gbp, 4);
492 if (max_matrix_channel > std_max_matrix_channel) {
493 av_log(m->avctx, AV_LOG_ERROR,
494 "Max matrix channel cannot be greater than %d.\n",
495 std_max_matrix_channel);
496 return AVERROR_INVALIDDATA;
499 if (max_channel != max_matrix_channel) {
500 av_log(m->avctx, AV_LOG_ERROR,
501 "Max channel must be equal max matrix channel.\n");
502 return AVERROR_INVALIDDATA;
505 /* This should happen for TrueHD streams with >6 channels and MLP's noise
506 * type. It is not yet known if this is allowed. */
507 if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
508 avpriv_request_sample(m->avctx,
509 "%d channels (more than the "
510 "maximum supported by the decoder)",
512 return AVERROR_PATCHWELCOME;
515 if (min_channel > max_channel) {
516 av_log(m->avctx, AV_LOG_ERROR,
517 "Substream min channel cannot be greater than max channel.\n");
518 return AVERROR_INVALIDDATA;
521 s->min_channel = min_channel;
522 s->max_channel = max_channel;
523 s->max_matrix_channel = max_matrix_channel;
525 #if FF_API_REQUEST_CHANNELS
526 FF_DISABLE_DEPRECATION_WARNINGS
527 if (m->avctx->request_channels > 0 &&
528 m->avctx->request_channels <= s->max_channel + 1 &&
529 m->max_decoded_substream > substr) {
530 av_log(m->avctx, AV_LOG_DEBUG,
531 "Extracting %d-channel downmix from substream %d. "
532 "Further substreams will be skipped.\n",
533 s->max_channel + 1, substr);
534 m->max_decoded_substream = substr;
535 FF_ENABLE_DEPRECATION_WARNINGS
538 if (m->avctx->request_channel_layout && (s->ch_layout & m->avctx->request_channel_layout) ==
539 m->avctx->request_channel_layout && m->max_decoded_substream > substr) {
540 av_log(m->avctx, AV_LOG_DEBUG,
541 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
542 "Further substreams will be skipped.\n",
543 s->max_channel + 1, s->ch_layout, substr);
544 m->max_decoded_substream = substr;
547 s->noise_shift = get_bits(gbp, 4);
548 s->noisegen_seed = get_bits(gbp, 23);
552 s->data_check_present = get_bits1(gbp);
553 lossless_check = get_bits(gbp, 8);
554 if (substr == m->max_decoded_substream
555 && s->lossless_check_data != 0xffffffff) {
556 tmp = xor_32_to_8(s->lossless_check_data);
557 if (tmp != lossless_check)
558 av_log(m->avctx, AV_LOG_WARNING,
559 "Lossless check failed - expected %02x, calculated %02x.\n",
560 lossless_check, tmp);
565 memset(s->ch_assign, 0, sizeof(s->ch_assign));
567 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
568 int ch_assign = get_bits(gbp, 6);
569 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
570 uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
572 ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
575 if ((unsigned)ch_assign > s->max_matrix_channel) {
576 avpriv_request_sample(m->avctx,
577 "Assignment of matrix channel %d to invalid output channel %d",
579 return AVERROR_PATCHWELCOME;
581 s->ch_assign[ch_assign] = ch;
584 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
586 if (checksum != get_bits(gbp, 8))
587 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
589 /* Set default decoding parameters. */
590 s->param_presence_flags = 0xff;
591 s->num_primitive_matrices = 0;
593 s->lossless_check_data = 0;
595 memset(s->output_shift , 0, sizeof(s->output_shift ));
596 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
598 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
599 ChannelParams *cp = &s->channel_params[ch];
600 cp->filter_params[FIR].order = 0;
601 cp->filter_params[IIR].order = 0;
602 cp->filter_params[FIR].shift = 0;
603 cp->filter_params[IIR].shift = 0;
605 /* Default audio coding is 24-bit raw PCM. */
607 cp->sign_huff_offset = (-1) << 23;
612 if (substr == m->max_decoded_substream) {
613 m->avctx->channels = s->max_matrix_channel + 1;
614 m->avctx->channel_layout = s->ch_layout;
616 if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
617 if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
618 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
619 int i = s->ch_assign[4];
620 s->ch_assign[4] = s->ch_assign[3];
621 s->ch_assign[3] = s->ch_assign[2];
623 } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
624 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
625 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
634 /** Read parameters for one of the prediction filters. */
636 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
637 unsigned int substr, unsigned int channel,
640 SubStream *s = &m->substream[substr];
641 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
642 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
643 const char fchar = filter ? 'I' : 'F';
646 // Filter is 0 for FIR, 1 for IIR.
647 av_assert0(filter < 2);
649 if (m->filter_changed[channel][filter]++ > 1) {
650 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
651 return AVERROR_INVALIDDATA;
654 order = get_bits(gbp, 4);
655 if (order > max_order) {
656 av_log(m->avctx, AV_LOG_ERROR,
657 "%cIR filter order %d is greater than maximum %d.\n",
658 fchar, order, max_order);
659 return AVERROR_INVALIDDATA;
664 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
665 int coeff_bits, coeff_shift;
667 fp->shift = get_bits(gbp, 4);
669 coeff_bits = get_bits(gbp, 5);
670 coeff_shift = get_bits(gbp, 3);
671 if (coeff_bits < 1 || coeff_bits > 16) {
672 av_log(m->avctx, AV_LOG_ERROR,
673 "%cIR filter coeff_bits must be between 1 and 16.\n",
675 return AVERROR_INVALIDDATA;
677 if (coeff_bits + coeff_shift > 16) {
678 av_log(m->avctx, AV_LOG_ERROR,
679 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
681 return AVERROR_INVALIDDATA;
684 for (i = 0; i < order; i++)
685 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
687 if (get_bits1(gbp)) {
688 int state_bits, state_shift;
691 av_log(m->avctx, AV_LOG_ERROR,
692 "FIR filter has state data specified.\n");
693 return AVERROR_INVALIDDATA;
696 state_bits = get_bits(gbp, 4);
697 state_shift = get_bits(gbp, 4);
699 /* TODO: Check validity of state data. */
701 for (i = 0; i < order; i++)
702 fp->state[i] = state_bits ? get_sbits(gbp, state_bits) << state_shift : 0;
709 /** Read parameters for primitive matrices. */
711 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
713 SubStream *s = &m->substream[substr];
714 unsigned int mat, ch;
715 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
717 : MAX_MATRICES_TRUEHD;
719 if (m->matrix_changed++ > 1) {
720 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
721 return AVERROR_INVALIDDATA;
724 s->num_primitive_matrices = get_bits(gbp, 4);
726 if (s->num_primitive_matrices > max_primitive_matrices) {
727 av_log(m->avctx, AV_LOG_ERROR,
728 "Number of primitive matrices cannot be greater than %d.\n",
729 max_primitive_matrices);
730 return AVERROR_INVALIDDATA;
733 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
734 int frac_bits, max_chan;
735 s->matrix_out_ch[mat] = get_bits(gbp, 4);
736 frac_bits = get_bits(gbp, 4);
737 s->lsb_bypass [mat] = get_bits1(gbp);
739 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
740 av_log(m->avctx, AV_LOG_ERROR,
741 "Invalid channel %d specified as output from matrix.\n",
742 s->matrix_out_ch[mat]);
743 return AVERROR_INVALIDDATA;
745 if (frac_bits > 14) {
746 av_log(m->avctx, AV_LOG_ERROR,
747 "Too many fractional bits specified.\n");
748 return AVERROR_INVALIDDATA;
751 max_chan = s->max_matrix_channel;
755 for (ch = 0; ch <= max_chan; ch++) {
758 coeff_val = get_sbits(gbp, frac_bits + 2);
760 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
764 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
766 s->matrix_noise_shift[mat] = 0;
772 /** Read channel parameters. */
774 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
775 GetBitContext *gbp, unsigned int ch)
777 SubStream *s = &m->substream[substr];
778 ChannelParams *cp = &s->channel_params[ch];
779 FilterParams *fir = &cp->filter_params[FIR];
780 FilterParams *iir = &cp->filter_params[IIR];
783 if (s->param_presence_flags & PARAM_FIR)
785 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
788 if (s->param_presence_flags & PARAM_IIR)
790 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
793 if (fir->order + iir->order > 8) {
794 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
795 return AVERROR_INVALIDDATA;
798 if (fir->order && iir->order &&
799 fir->shift != iir->shift) {
800 av_log(m->avctx, AV_LOG_ERROR,
801 "FIR and IIR filters must use the same precision.\n");
802 return AVERROR_INVALIDDATA;
804 /* The FIR and IIR filters must have the same precision.
805 * To simplify the filtering code, only the precision of the
806 * FIR filter is considered. If only the IIR filter is employed,
807 * the FIR filter precision is set to that of the IIR filter, so
808 * that the filtering code can use it. */
809 if (!fir->order && iir->order)
810 fir->shift = iir->shift;
812 if (s->param_presence_flags & PARAM_HUFFOFFSET)
814 cp->huff_offset = get_sbits(gbp, 15);
816 cp->codebook = get_bits(gbp, 2);
817 cp->huff_lsbs = get_bits(gbp, 5);
819 if (cp->huff_lsbs > 24) {
820 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
822 return AVERROR_INVALIDDATA;
825 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
830 /** Read decoding parameters that change more often than those in the restart
833 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
836 SubStream *s = &m->substream[substr];
840 if (s->param_presence_flags & PARAM_PRESENCE)
842 s->param_presence_flags = get_bits(gbp, 8);
844 if (s->param_presence_flags & PARAM_BLOCKSIZE)
845 if (get_bits1(gbp)) {
846 s->blocksize = get_bits(gbp, 9);
847 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
848 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
850 return AVERROR_INVALIDDATA;
854 if (s->param_presence_flags & PARAM_MATRIX)
856 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
859 if (s->param_presence_flags & PARAM_OUTSHIFT)
861 for (ch = 0; ch <= s->max_matrix_channel; ch++)
862 s->output_shift[ch] = get_sbits(gbp, 4);
864 if (s->param_presence_flags & PARAM_QUANTSTEP)
866 for (ch = 0; ch <= s->max_channel; ch++) {
867 ChannelParams *cp = &s->channel_params[ch];
869 s->quant_step_size[ch] = get_bits(gbp, 4);
871 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
874 for (ch = s->min_channel; ch <= s->max_channel; ch++)
876 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
882 #define MSB_MASK(bits) (-1u << bits)
884 /** Generate PCM samples using the prediction filters and residual values
885 * read from the data stream, and update the filter state. */
887 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
888 unsigned int channel)
890 SubStream *s = &m->substream[substr];
891 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
892 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
893 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
894 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
895 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
896 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
897 unsigned int filter_shift = fir->shift;
898 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
900 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
901 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
903 m->dsp.mlp_filter_channel(firbuf, fircoeff,
904 fir->order, iir->order,
905 filter_shift, mask, s->blocksize,
906 &m->sample_buffer[s->blockpos][channel]);
908 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
909 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
912 /** Read a block of PCM residual data (or actual if no filtering active). */
914 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
917 SubStream *s = &m->substream[substr];
918 unsigned int i, ch, expected_stream_pos = 0;
921 if (s->data_check_present) {
922 expected_stream_pos = get_bits_count(gbp);
923 expected_stream_pos += get_bits(gbp, 16);
924 avpriv_request_sample(m->avctx,
925 "Substreams with VLC block size check info");
928 if (s->blockpos + s->blocksize > m->access_unit_size) {
929 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
930 return AVERROR_INVALIDDATA;
933 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
934 s->blocksize * sizeof(m->bypassed_lsbs[0]));
936 for (i = 0; i < s->blocksize; i++)
937 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
940 for (ch = s->min_channel; ch <= s->max_channel; ch++)
941 filter_channel(m, substr, ch);
943 s->blockpos += s->blocksize;
945 if (s->data_check_present) {
946 if (get_bits_count(gbp) != expected_stream_pos)
947 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
954 /** Data table used for TrueHD noise generation function. */
956 static const int8_t noise_table[256] = {
957 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
958 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
959 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
960 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
961 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
962 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
963 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
964 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
965 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
966 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
967 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
968 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
969 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
970 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
971 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
972 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
975 /** Noise generation functions.
976 * I'm not sure what these are for - they seem to be some kind of pseudorandom
977 * sequence generators, used to generate noise data which is used when the
978 * channels are rematrixed. I'm not sure if they provide a practical benefit
979 * to compression, or just obfuscate the decoder. Are they for some kind of
982 /** Generate two channels of noise, used in the matrix when
983 * restart sync word == 0x31ea. */
985 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
987 SubStream *s = &m->substream[substr];
989 uint32_t seed = s->noisegen_seed;
990 unsigned int maxchan = s->max_matrix_channel;
992 for (i = 0; i < s->blockpos; i++) {
993 uint16_t seed_shr7 = seed >> 7;
994 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
995 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
997 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1000 s->noisegen_seed = seed;
1003 /** Generate a block of noise, used when restart sync word == 0x31eb. */
1005 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
1007 SubStream *s = &m->substream[substr];
1009 uint32_t seed = s->noisegen_seed;
1011 for (i = 0; i < m->access_unit_size_pow2; i++) {
1012 uint8_t seed_shr15 = seed >> 15;
1013 m->noise_buffer[i] = noise_table[seed_shr15];
1014 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
1017 s->noisegen_seed = seed;
1021 /** Apply the channel matrices in turn to reconstruct the original audio
1024 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
1026 SubStream *s = &m->substream[substr];
1027 unsigned int mat, src_ch, i;
1028 unsigned int maxchan;
1030 maxchan = s->max_matrix_channel;
1031 if (!s->noise_type) {
1032 generate_2_noise_channels(m, substr);
1035 fill_noise_buffer(m, substr);
1038 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1039 int matrix_noise_shift = s->matrix_noise_shift[mat];
1040 unsigned int dest_ch = s->matrix_out_ch[mat];
1041 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
1042 int32_t *coeffs = s->matrix_coeff[mat];
1043 int index = s->num_primitive_matrices - mat;
1044 int index2 = 2 * index + 1;
1046 /* TODO: DSPContext? */
1048 for (i = 0; i < s->blockpos; i++) {
1049 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
1050 int32_t *samples = m->sample_buffer[i];
1053 for (src_ch = 0; src_ch <= maxchan; src_ch++)
1054 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
1056 if (matrix_noise_shift) {
1057 index &= m->access_unit_size_pow2 - 1;
1058 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
1062 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
1067 /** Write the audio data into the output buffer. */
1069 static int output_data(MLPDecodeContext *m, unsigned int substr,
1070 AVFrame *frame, int *got_frame_ptr)
1072 AVCodecContext *avctx = m->avctx;
1073 SubStream *s = &m->substream[substr];
1074 unsigned int i, out_ch = 0;
1078 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1080 if (m->avctx->channels != s->max_matrix_channel + 1) {
1081 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1082 return AVERROR_INVALIDDATA;
1086 av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1087 return AVERROR_INVALIDDATA;
1090 /* get output buffer */
1091 frame->nb_samples = s->blockpos;
1092 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1094 data_32 = (int32_t *)frame->data[0];
1095 data_16 = (int16_t *)frame->data[0];
1097 for (i = 0; i < s->blockpos; i++) {
1098 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
1099 int mat_ch = s->ch_assign[out_ch];
1100 int32_t sample = m->sample_buffer[i][mat_ch]
1101 << s->output_shift[mat_ch];
1102 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
1103 if (is32) *data_32++ = sample << 8;
1104 else *data_16++ = sample >> 8;
1108 /* Update matrix encoding side data */
1109 if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1117 /** Read an access unit from the stream.
1118 * @return negative on error, 0 if not enough data is present in the input stream,
1119 * otherwise the number of bytes consumed. */
1121 static int read_access_unit(AVCodecContext *avctx, void* data,
1122 int *got_frame_ptr, AVPacket *avpkt)
1124 const uint8_t *buf = avpkt->data;
1125 int buf_size = avpkt->size;
1126 MLPDecodeContext *m = avctx->priv_data;
1128 unsigned int length, substr;
1129 unsigned int substream_start;
1130 unsigned int header_size = 4;
1131 unsigned int substr_header_size = 0;
1132 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1133 uint16_t substream_data_len[MAX_SUBSTREAMS];
1134 uint8_t parity_bits;
1138 return AVERROR_INVALIDDATA;
1140 length = (AV_RB16(buf) & 0xfff) * 2;
1142 if (length < 4 || length > buf_size)
1143 return AVERROR_INVALIDDATA;
1145 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1147 m->is_major_sync_unit = 0;
1148 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1149 if (read_major_sync(m, &gb) < 0)
1151 m->is_major_sync_unit = 1;
1155 if (!m->params_valid) {
1156 av_log(m->avctx, AV_LOG_WARNING,
1157 "Stream parameters not seen; skipping frame.\n");
1162 substream_start = 0;
1164 for (substr = 0; substr < m->num_substreams; substr++) {
1165 int extraword_present, checkdata_present, end, nonrestart_substr;
1167 extraword_present = get_bits1(&gb);
1168 nonrestart_substr = get_bits1(&gb);
1169 checkdata_present = get_bits1(&gb);
1172 end = get_bits(&gb, 12) * 2;
1174 substr_header_size += 2;
1176 if (extraword_present) {
1177 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1178 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1182 substr_header_size += 2;
1185 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1186 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1190 if (end + header_size + substr_header_size > length) {
1191 av_log(m->avctx, AV_LOG_ERROR,
1192 "Indicated length of substream %d data goes off end of "
1193 "packet.\n", substr);
1194 end = length - header_size - substr_header_size;
1197 if (end < substream_start) {
1198 av_log(avctx, AV_LOG_ERROR,
1199 "Indicated end offset of substream %d data "
1200 "is smaller than calculated start offset.\n",
1205 if (substr > m->max_decoded_substream)
1208 substream_parity_present[substr] = checkdata_present;
1209 substream_data_len[substr] = end - substream_start;
1210 substream_start = end;
1213 parity_bits = ff_mlp_calculate_parity(buf, 4);
1214 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1216 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1217 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1221 buf += header_size + substr_header_size;
1223 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1224 SubStream *s = &m->substream[substr];
1225 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1227 m->matrix_changed = 0;
1228 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1232 if (get_bits1(&gb)) {
1233 if (get_bits1(&gb)) {
1234 /* A restart header should be present. */
1235 if (read_restart_header(m, &gb, buf, substr) < 0)
1237 s->restart_seen = 1;
1240 if (!s->restart_seen)
1242 if (read_decoding_params(m, &gb, substr) < 0)
1246 if (!s->restart_seen)
1249 if ((ret = read_block_data(m, &gb, substr)) < 0)
1252 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1253 goto substream_length_mismatch;
1255 } while (!get_bits1(&gb));
1257 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1259 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1262 if (get_bits(&gb, 16) != 0xD234)
1263 return AVERROR_INVALIDDATA;
1265 shorten_by = get_bits(&gb, 16);
1266 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1267 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1268 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1269 return AVERROR_INVALIDDATA;
1271 if (substr == m->max_decoded_substream)
1272 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1275 if (substream_parity_present[substr]) {
1276 uint8_t parity, checksum;
1278 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1279 goto substream_length_mismatch;
1281 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1282 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1284 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1285 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1286 if ( get_bits(&gb, 8) != checksum)
1287 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1290 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1291 goto substream_length_mismatch;
1294 if (!s->restart_seen)
1295 av_log(m->avctx, AV_LOG_ERROR,
1296 "No restart header present in substream %d.\n", substr);
1298 buf += substream_data_len[substr];
1301 rematrix_channels(m, m->max_decoded_substream);
1303 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1308 substream_length_mismatch:
1309 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1310 return AVERROR_INVALIDDATA;
1313 m->params_valid = 0;
1314 return AVERROR_INVALIDDATA;
1317 #if CONFIG_MLP_DECODER
1318 AVCodec ff_mlp_decoder = {
1320 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1321 .type = AVMEDIA_TYPE_AUDIO,
1322 .id = AV_CODEC_ID_MLP,
1323 .priv_data_size = sizeof(MLPDecodeContext),
1324 .init = mlp_decode_init,
1325 .decode = read_access_unit,
1326 .capabilities = CODEC_CAP_DR1,
1329 #if CONFIG_TRUEHD_DECODER
1330 AVCodec ff_truehd_decoder = {
1332 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1333 .type = AVMEDIA_TYPE_AUDIO,
1334 .id = AV_CODEC_ID_TRUEHD,
1335 .priv_data_size = sizeof(MLPDecodeContext),
1336 .init = mlp_decode_init,
1337 .decode = read_access_unit,
1338 .capabilities = CODEC_CAP_DR1,
1340 #endif /* CONFIG_TRUEHD_DECODER */