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 /// 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 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 <<= 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 FF_API_REQUEST_CHANNELS
537 FF_DISABLE_DEPRECATION_WARNINGS
538 if (m->avctx->request_channels > 0 &&
539 m->avctx->request_channels <= s->max_channel + 1 &&
540 m->max_decoded_substream > substr) {
541 av_log(m->avctx, AV_LOG_DEBUG,
542 "Extracting %d-channel downmix from substream %d. "
543 "Further substreams will be skipped.\n",
544 s->max_channel + 1, substr);
545 m->max_decoded_substream = substr;
546 FF_ENABLE_DEPRECATION_WARNINGS
549 if (m->avctx->request_channel_layout && (s->ch_layout & m->avctx->request_channel_layout) ==
550 m->avctx->request_channel_layout && m->max_decoded_substream > substr) {
551 av_log(m->avctx, AV_LOG_DEBUG,
552 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
553 "Further substreams will be skipped.\n",
554 s->max_channel + 1, s->ch_layout, substr);
555 m->max_decoded_substream = substr;
558 s->noise_shift = get_bits(gbp, 4);
559 s->noisegen_seed = get_bits(gbp, 23);
563 s->data_check_present = get_bits1(gbp);
564 lossless_check = get_bits(gbp, 8);
565 if (substr == m->max_decoded_substream
566 && s->lossless_check_data != 0xffffffff) {
567 tmp = xor_32_to_8(s->lossless_check_data);
568 if (tmp != lossless_check)
569 av_log(m->avctx, AV_LOG_WARNING,
570 "Lossless check failed - expected %02x, calculated %02x.\n",
571 lossless_check, tmp);
576 memset(s->ch_assign, 0, sizeof(s->ch_assign));
578 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
579 int ch_assign = get_bits(gbp, 6);
580 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
581 uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
583 ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
586 if ((unsigned)ch_assign > s->max_matrix_channel) {
587 avpriv_request_sample(m->avctx,
588 "Assignment of matrix channel %d to invalid output channel %d",
590 return AVERROR_PATCHWELCOME;
592 s->ch_assign[ch_assign] = ch;
595 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
597 if (checksum != get_bits(gbp, 8))
598 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
600 /* Set default decoding parameters. */
601 s->param_presence_flags = 0xff;
602 s->num_primitive_matrices = 0;
604 s->lossless_check_data = 0;
606 memset(s->output_shift , 0, sizeof(s->output_shift ));
607 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
609 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
610 ChannelParams *cp = &s->channel_params[ch];
611 cp->filter_params[FIR].order = 0;
612 cp->filter_params[IIR].order = 0;
613 cp->filter_params[FIR].shift = 0;
614 cp->filter_params[IIR].shift = 0;
616 /* Default audio coding is 24-bit raw PCM. */
618 cp->sign_huff_offset = (-1) << 23;
623 if (substr == m->max_decoded_substream) {
624 m->avctx->channels = s->max_matrix_channel + 1;
625 m->avctx->channel_layout = s->ch_layout;
626 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
628 s->max_matrix_channel,
629 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
631 if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
632 if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
633 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
634 int i = s->ch_assign[4];
635 s->ch_assign[4] = s->ch_assign[3];
636 s->ch_assign[3] = s->ch_assign[2];
638 } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
639 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
640 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
649 /** Read parameters for one of the prediction filters. */
651 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
652 unsigned int substr, unsigned int channel,
655 SubStream *s = &m->substream[substr];
656 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
657 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
658 const char fchar = filter ? 'I' : 'F';
661 // Filter is 0 for FIR, 1 for IIR.
662 av_assert0(filter < 2);
664 if (m->filter_changed[channel][filter]++ > 1) {
665 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
666 return AVERROR_INVALIDDATA;
669 order = get_bits(gbp, 4);
670 if (order > max_order) {
671 av_log(m->avctx, AV_LOG_ERROR,
672 "%cIR filter order %d is greater than maximum %d.\n",
673 fchar, order, max_order);
674 return AVERROR_INVALIDDATA;
679 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
680 int coeff_bits, coeff_shift;
682 fp->shift = get_bits(gbp, 4);
684 coeff_bits = get_bits(gbp, 5);
685 coeff_shift = get_bits(gbp, 3);
686 if (coeff_bits < 1 || coeff_bits > 16) {
687 av_log(m->avctx, AV_LOG_ERROR,
688 "%cIR filter coeff_bits must be between 1 and 16.\n",
690 return AVERROR_INVALIDDATA;
692 if (coeff_bits + coeff_shift > 16) {
693 av_log(m->avctx, AV_LOG_ERROR,
694 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
696 return AVERROR_INVALIDDATA;
699 for (i = 0; i < order; i++)
700 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
702 if (get_bits1(gbp)) {
703 int state_bits, state_shift;
706 av_log(m->avctx, AV_LOG_ERROR,
707 "FIR filter has state data specified.\n");
708 return AVERROR_INVALIDDATA;
711 state_bits = get_bits(gbp, 4);
712 state_shift = get_bits(gbp, 4);
714 /* TODO: Check validity of state data. */
716 for (i = 0; i < order; i++)
717 fp->state[i] = state_bits ? get_sbits(gbp, state_bits) << state_shift : 0;
724 /** Read parameters for primitive matrices. */
726 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
728 SubStream *s = &m->substream[substr];
729 unsigned int mat, ch;
730 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
732 : MAX_MATRICES_TRUEHD;
734 if (m->matrix_changed++ > 1) {
735 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
736 return AVERROR_INVALIDDATA;
739 s->num_primitive_matrices = get_bits(gbp, 4);
741 if (s->num_primitive_matrices > max_primitive_matrices) {
742 av_log(m->avctx, AV_LOG_ERROR,
743 "Number of primitive matrices cannot be greater than %d.\n",
744 max_primitive_matrices);
745 return AVERROR_INVALIDDATA;
748 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
749 int frac_bits, max_chan;
750 s->matrix_out_ch[mat] = get_bits(gbp, 4);
751 frac_bits = get_bits(gbp, 4);
752 s->lsb_bypass [mat] = get_bits1(gbp);
754 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
755 av_log(m->avctx, AV_LOG_ERROR,
756 "Invalid channel %d specified as output from matrix.\n",
757 s->matrix_out_ch[mat]);
758 return AVERROR_INVALIDDATA;
760 if (frac_bits > 14) {
761 av_log(m->avctx, AV_LOG_ERROR,
762 "Too many fractional bits specified.\n");
763 return AVERROR_INVALIDDATA;
766 max_chan = s->max_matrix_channel;
770 for (ch = 0; ch <= max_chan; ch++) {
773 coeff_val = get_sbits(gbp, frac_bits + 2);
775 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
779 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
781 s->matrix_noise_shift[mat] = 0;
787 /** Read channel parameters. */
789 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
790 GetBitContext *gbp, unsigned int ch)
792 SubStream *s = &m->substream[substr];
793 ChannelParams *cp = &s->channel_params[ch];
794 FilterParams *fir = &cp->filter_params[FIR];
795 FilterParams *iir = &cp->filter_params[IIR];
798 if (s->param_presence_flags & PARAM_FIR)
800 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
803 if (s->param_presence_flags & PARAM_IIR)
805 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
808 if (fir->order + iir->order > 8) {
809 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
810 return AVERROR_INVALIDDATA;
813 if (fir->order && iir->order &&
814 fir->shift != iir->shift) {
815 av_log(m->avctx, AV_LOG_ERROR,
816 "FIR and IIR filters must use the same precision.\n");
817 return AVERROR_INVALIDDATA;
819 /* The FIR and IIR filters must have the same precision.
820 * To simplify the filtering code, only the precision of the
821 * FIR filter is considered. If only the IIR filter is employed,
822 * the FIR filter precision is set to that of the IIR filter, so
823 * that the filtering code can use it. */
824 if (!fir->order && iir->order)
825 fir->shift = iir->shift;
827 if (s->param_presence_flags & PARAM_HUFFOFFSET)
829 cp->huff_offset = get_sbits(gbp, 15);
831 cp->codebook = get_bits(gbp, 2);
832 cp->huff_lsbs = get_bits(gbp, 5);
834 if (cp->huff_lsbs > 24) {
835 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
837 return AVERROR_INVALIDDATA;
840 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
845 /** Read decoding parameters that change more often than those in the restart
848 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
851 SubStream *s = &m->substream[substr];
855 if (s->param_presence_flags & PARAM_PRESENCE)
857 s->param_presence_flags = get_bits(gbp, 8);
859 if (s->param_presence_flags & PARAM_BLOCKSIZE)
860 if (get_bits1(gbp)) {
861 s->blocksize = get_bits(gbp, 9);
862 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
863 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
865 return AVERROR_INVALIDDATA;
869 if (s->param_presence_flags & PARAM_MATRIX)
871 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
874 if (s->param_presence_flags & PARAM_OUTSHIFT)
875 if (get_bits1(gbp)) {
876 for (ch = 0; ch <= s->max_matrix_channel; ch++)
877 s->output_shift[ch] = get_sbits(gbp, 4);
878 if (substr == m->max_decoded_substream)
879 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
881 s->max_matrix_channel,
882 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
885 if (s->param_presence_flags & PARAM_QUANTSTEP)
887 for (ch = 0; ch <= s->max_channel; ch++) {
888 ChannelParams *cp = &s->channel_params[ch];
890 s->quant_step_size[ch] = get_bits(gbp, 4);
892 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
895 for (ch = s->min_channel; ch <= s->max_channel; ch++)
897 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
903 #define MSB_MASK(bits) (-1u << (bits))
905 /** Generate PCM samples using the prediction filters and residual values
906 * read from the data stream, and update the filter state. */
908 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
909 unsigned int channel)
911 SubStream *s = &m->substream[substr];
912 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
913 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
914 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
915 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
916 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
917 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
918 unsigned int filter_shift = fir->shift;
919 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
921 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
922 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
924 m->dsp.mlp_filter_channel(firbuf, fircoeff,
925 fir->order, iir->order,
926 filter_shift, mask, s->blocksize,
927 &m->sample_buffer[s->blockpos][channel]);
929 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
930 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
933 /** Read a block of PCM residual data (or actual if no filtering active). */
935 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
938 SubStream *s = &m->substream[substr];
939 unsigned int i, ch, expected_stream_pos = 0;
942 if (s->data_check_present) {
943 expected_stream_pos = get_bits_count(gbp);
944 expected_stream_pos += get_bits(gbp, 16);
945 avpriv_request_sample(m->avctx,
946 "Substreams with VLC block size check info");
949 if (s->blockpos + s->blocksize > m->access_unit_size) {
950 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
951 return AVERROR_INVALIDDATA;
954 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
955 s->blocksize * sizeof(m->bypassed_lsbs[0]));
957 for (i = 0; i < s->blocksize; i++)
958 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
961 for (ch = s->min_channel; ch <= s->max_channel; ch++)
962 filter_channel(m, substr, ch);
964 s->blockpos += s->blocksize;
966 if (s->data_check_present) {
967 if (get_bits_count(gbp) != expected_stream_pos)
968 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
975 /** Data table used for TrueHD noise generation function. */
977 static const int8_t noise_table[256] = {
978 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
979 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
980 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
981 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
982 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
983 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
984 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
985 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
986 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
987 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
988 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
989 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
990 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
991 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
992 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
993 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
996 /** Noise generation functions.
997 * I'm not sure what these are for - they seem to be some kind of pseudorandom
998 * sequence generators, used to generate noise data which is used when the
999 * channels are rematrixed. I'm not sure if they provide a practical benefit
1000 * to compression, or just obfuscate the decoder. Are they for some kind of
1003 /** Generate two channels of noise, used in the matrix when
1004 * restart sync word == 0x31ea. */
1006 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
1008 SubStream *s = &m->substream[substr];
1010 uint32_t seed = s->noisegen_seed;
1011 unsigned int maxchan = s->max_matrix_channel;
1013 for (i = 0; i < s->blockpos; i++) {
1014 uint16_t seed_shr7 = seed >> 7;
1015 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
1016 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
1018 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1021 s->noisegen_seed = seed;
1024 /** Generate a block of noise, used when restart sync word == 0x31eb. */
1026 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
1028 SubStream *s = &m->substream[substr];
1030 uint32_t seed = s->noisegen_seed;
1032 for (i = 0; i < m->access_unit_size_pow2; i++) {
1033 uint8_t seed_shr15 = seed >> 15;
1034 m->noise_buffer[i] = noise_table[seed_shr15];
1035 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
1038 s->noisegen_seed = seed;
1042 /** Apply the channel matrices in turn to reconstruct the original audio
1045 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
1047 SubStream *s = &m->substream[substr];
1049 unsigned int maxchan;
1051 maxchan = s->max_matrix_channel;
1052 if (!s->noise_type) {
1053 generate_2_noise_channels(m, substr);
1056 fill_noise_buffer(m, substr);
1059 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1060 unsigned int dest_ch = s->matrix_out_ch[mat];
1061 m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1062 s->matrix_coeff[mat],
1063 &m->bypassed_lsbs[0][mat],
1065 s->num_primitive_matrices - mat,
1069 s->matrix_noise_shift[mat],
1070 m->access_unit_size_pow2,
1071 MSB_MASK(s->quant_step_size[dest_ch]));
1075 /** Write the audio data into the output buffer. */
1077 static int output_data(MLPDecodeContext *m, unsigned int substr,
1078 AVFrame *frame, int *got_frame_ptr)
1080 AVCodecContext *avctx = m->avctx;
1081 SubStream *s = &m->substream[substr];
1083 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1085 if (m->avctx->channels != s->max_matrix_channel + 1) {
1086 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1087 return AVERROR_INVALIDDATA;
1091 av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1092 return AVERROR_INVALIDDATA;
1095 /* get output buffer */
1096 frame->nb_samples = s->blockpos;
1097 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1099 s->lossless_check_data = m->dsp.mlp_pack_output(s->lossless_check_data,
1105 s->max_matrix_channel,
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;
1152 header_size += m->major_sync_header_size;
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 */