mlpdec: Validate max_channel and max_matrix_channel.
[libav.git] / libavcodec / mlpdec.c
CommitLineData
b517af05
RP
1/*
2 * MLP decoder
3 * Copyright (c) 2007-2008 Ian Caulfield
4 *
5 * This file is part of FFmpeg.
6 *
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.
11 *
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.
16 *
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
20 */
21
22/**
bad5537e 23 * @file libavcodec/mlpdec.c
b517af05
RP
24 * MLP decoder
25 */
26
0e74e1ff
DB
27#include <stdint.h>
28
b517af05
RP
29#include "avcodec.h"
30#include "libavutil/intreadwrite.h"
9106a698 31#include "get_bits.h"
b517af05
RP
32#include "libavutil/crc.h"
33#include "parser.h"
34#include "mlp_parser.h"
ce15710f 35#include "mlp.h"
b517af05 36
9906a2be 37/** number of bits used for VLC lookup - longest Huffman code is 9 */
b517af05
RP
38#define VLC_BITS 9
39
40
41static const char* sample_message =
42 "Please file a bug report following the instructions at "
0fa5f24c 43 "http://ffmpeg.org/bugreports.html and include "
b517af05
RP
44 "a sample of this file.";
45
46typedef struct SubStream {
9906a2be 47 //! Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
b517af05
RP
48 uint8_t restart_seen;
49
50 //@{
51 /** restart header data */
52 //! The type of noise to be used in the rematrix stage.
53 uint16_t noise_type;
54
55 //! The index of the first channel coded in this substream.
56 uint8_t min_channel;
57 //! The index of the last channel coded in this substream.
58 uint8_t max_channel;
59 //! The number of channels input into the rematrix stage.
60 uint8_t max_matrix_channel;
9731e7f1
RP
61 //! For each channel output by the matrix, the output channel to map it to
62 uint8_t ch_assign[MAX_CHANNELS];
b517af05
RP
63
64 //! The left shift applied to random noise in 0x31ea substreams.
65 uint8_t noise_shift;
66 //! The current seed value for the pseudorandom noise generator(s).
67 uint32_t noisegen_seed;
68
69 //! Set if the substream contains extra info to check the size of VLC blocks.
70 uint8_t data_check_present;
71
72 //! Bitmask of which parameter sets are conveyed in a decoding parameter block.
73 uint8_t param_presence_flags;
74#define PARAM_BLOCKSIZE (1 << 7)
75#define PARAM_MATRIX (1 << 6)
76#define PARAM_OUTSHIFT (1 << 5)
77#define PARAM_QUANTSTEP (1 << 4)
78#define PARAM_FIR (1 << 3)
79#define PARAM_IIR (1 << 2)
80#define PARAM_HUFFOFFSET (1 << 1)
cbf3cf19 81#define PARAM_PRESENCE (1 << 0)
b517af05
RP
82 //@}
83
84 //@{
85 /** matrix data */
86
87 //! Number of matrices to be applied.
88 uint8_t num_primitive_matrices;
89
90 //! matrix output channel
91 uint8_t matrix_out_ch[MAX_MATRICES];
92
93 //! Whether the LSBs of the matrix output are encoded in the bitstream.
94 uint8_t lsb_bypass[MAX_MATRICES];
95 //! Matrix coefficients, stored as 2.14 fixed point.
96 int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS+2];
97 //! Left shift to apply to noise values in 0x31eb substreams.
98 uint8_t matrix_noise_shift[MAX_MATRICES];
99 //@}
100
9906a2be 101 //! Left shift to apply to Huffman-decoded residuals.
b517af05
RP
102 uint8_t quant_step_size[MAX_CHANNELS];
103
9906a2be 104 //! number of PCM samples in current audio block
b517af05
RP
105 uint16_t blocksize;
106 //! Number of PCM samples decoded so far in this frame.
107 uint16_t blockpos;
108
109 //! Left shift to apply to decoded PCM values to get final 24-bit output.
110 int8_t output_shift[MAX_CHANNELS];
111
112 //! Running XOR of all output samples.
113 int32_t lossless_check_data;
114
115} SubStream;
116
117typedef struct MLPDecodeContext {
118 AVCodecContext *avctx;
119
cc9c5126
RP
120 //! Current access unit being read has a major sync.
121 int is_major_sync_unit;
122
b517af05
RP
123 //! Set if a valid major sync block has been read. Otherwise no decoding is possible.
124 uint8_t params_valid;
125
126 //! Number of substreams contained within this stream.
127 uint8_t num_substreams;
128
129 //! Index of the last substream to decode - further substreams are skipped.
130 uint8_t max_decoded_substream;
131
9906a2be 132 //! number of PCM samples contained in each frame
b517af05 133 int access_unit_size;
9906a2be 134 //! next power of two above the number of samples in each frame
b517af05
RP
135 int access_unit_size_pow2;
136
137 SubStream substream[MAX_SUBSTREAMS];
138
f53acb7b 139 ChannelParams channel_params[MAX_CHANNELS];
b517af05 140
75428fa4
RP
141 int matrix_changed;
142 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
143
b517af05
RP
144 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
145 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
146 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS+2];
147} MLPDecodeContext;
148
b517af05
RP
149static VLC huff_vlc[3];
150
b517af05
RP
151/** Initialize static data, constant between all invocations of the codec. */
152
dc8a7c93 153static av_cold void init_static(void)
b517af05
RP
154{
155 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
ce15710f
RP
156 &ff_mlp_huffman_tables[0][0][1], 2, 1,
157 &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
b517af05 158 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
ce15710f
RP
159 &ff_mlp_huffman_tables[1][0][1], 2, 1,
160 &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
b517af05 161 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
ce15710f
RP
162 &ff_mlp_huffman_tables[2][0][1], 2, 1,
163 &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
b517af05 164
ce15710f 165 ff_mlp_init_crc();
b517af05
RP
166}
167
168static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
169 unsigned int substr, unsigned int ch)
170{
f53acb7b 171 ChannelParams *cp = &m->channel_params[ch];
b517af05 172 SubStream *s = &m->substream[substr];
f53acb7b
RP
173 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
174 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
175 int32_t sign_huff_offset = cp->huff_offset;
b517af05 176
f53acb7b 177 if (cp->codebook > 0)
b517af05
RP
178 sign_huff_offset -= 7 << lsb_bits;
179
180 if (sign_shift >= 0)
181 sign_huff_offset -= 1 << sign_shift;
182
183 return sign_huff_offset;
184}
185
186/** Read a sample, consisting of either, both or neither of entropy-coded MSBs
187 * and plain LSBs. */
188
189static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
190 unsigned int substr, unsigned int pos)
191{
192 SubStream *s = &m->substream[substr];
193 unsigned int mat, channel;
194
195 for (mat = 0; mat < s->num_primitive_matrices; mat++)
196 if (s->lsb_bypass[mat])
197 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
198
199 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
f53acb7b
RP
200 ChannelParams *cp = &m->channel_params[channel];
201 int codebook = cp->codebook;
b517af05 202 int quant_step_size = s->quant_step_size[channel];
f53acb7b 203 int lsb_bits = cp->huff_lsbs - quant_step_size;
b517af05
RP
204 int result = 0;
205
206 if (codebook > 0)
207 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
208 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
209
210 if (result < 0)
211 return -1;
212
213 if (lsb_bits > 0)
214 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
215
f53acb7b 216 result += cp->sign_huff_offset;
b517af05
RP
217 result <<= quant_step_size;
218
219 m->sample_buffer[pos + s->blockpos][channel] = result;
220 }
221
222 return 0;
223}
224
225static av_cold int mlp_decode_init(AVCodecContext *avctx)
226{
227 MLPDecodeContext *m = avctx->priv_data;
228 int substr;
229
230 init_static();
231 m->avctx = avctx;
232 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
233 m->substream[substr].lossless_check_data = 0xffffffff;
ee1a8f62 234
b517af05
RP
235 return 0;
236}
237
238/** Read a major sync info header - contains high level information about
239 * the stream - sample rate, channel arrangement etc. Most of this
240 * information is not actually necessary for decoding, only for playback.
241 */
242
243static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
244{
245 MLPHeaderInfo mh;
246 int substr;
247
248 if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
249 return -1;
250
251 if (mh.group1_bits == 0) {
9906a2be 252 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
b517af05
RP
253 return -1;
254 }
255 if (mh.group2_bits > mh.group1_bits) {
256 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 257 "Channel group 2 cannot have more bits per sample than group 1.\n");
b517af05
RP
258 return -1;
259 }
260
261 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
262 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 263 "Channel groups with differing sample rates are not currently supported.\n");
b517af05
RP
264 return -1;
265 }
266
267 if (mh.group1_samplerate == 0) {
9906a2be 268 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
b517af05
RP
269 return -1;
270 }
271 if (mh.group1_samplerate > MAX_SAMPLERATE) {
272 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 273 "Sampling rate %d is greater than the supported maximum (%d).\n",
b517af05
RP
274 mh.group1_samplerate, MAX_SAMPLERATE);
275 return -1;
276 }
277 if (mh.access_unit_size > MAX_BLOCKSIZE) {
278 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 279 "Block size %d is greater than the supported maximum (%d).\n",
b517af05
RP
280 mh.access_unit_size, MAX_BLOCKSIZE);
281 return -1;
282 }
283 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
284 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 285 "Block size pow2 %d is greater than the supported maximum (%d).\n",
b517af05
RP
286 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
287 return -1;
288 }
289
290 if (mh.num_substreams == 0)
291 return -1;
932cee5d
RP
292 if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
293 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
294 return -1;
295 }
b517af05
RP
296 if (mh.num_substreams > MAX_SUBSTREAMS) {
297 av_log(m->avctx, AV_LOG_ERROR,
9906a2be
DB
298 "Number of substreams %d is larger than the maximum supported "
299 "by the decoder. %s\n", mh.num_substreams, sample_message);
b517af05
RP
300 return -1;
301 }
302
303 m->access_unit_size = mh.access_unit_size;
304 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
305
306 m->num_substreams = mh.num_substreams;
307 m->max_decoded_substream = m->num_substreams - 1;
308
309 m->avctx->sample_rate = mh.group1_samplerate;
310 m->avctx->frame_size = mh.access_unit_size;
311
97679e6e 312 m->avctx->bits_per_raw_sample = mh.group1_bits;
c687643c 313 if (mh.group1_bits > 16)
b517af05 314 m->avctx->sample_fmt = SAMPLE_FMT_S32;
ee1a8f62
RP
315 else
316 m->avctx->sample_fmt = SAMPLE_FMT_S16;
b517af05
RP
317
318 m->params_valid = 1;
319 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
320 m->substream[substr].restart_seen = 0;
321
322 return 0;
323}
324
325/** Read a restart header from a block in a substream. This contains parameters
326 * required to decode the audio that do not change very often. Generally
327 * (always) present only in blocks following a major sync. */
328
329static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
330 const uint8_t *buf, unsigned int substr)
331{
332 SubStream *s = &m->substream[substr];
333 unsigned int ch;
334 int sync_word, tmp;
335 uint8_t checksum;
336 uint8_t lossless_check;
337 int start_count = get_bits_count(gbp);
868170c4
RP
338 const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP
339 ? MAX_MATRIX_CHANNEL_MLP
340 : MAX_MATRIX_CHANNEL_TRUEHD;
b517af05
RP
341
342 sync_word = get_bits(gbp, 13);
46958efe 343 s->noise_type = get_bits1(gbp);
b517af05 344
46958efe
RP
345 if ((m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) ||
346 sync_word != 0x31ea >> 1) {
b517af05 347 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 348 "restart header sync incorrect (got 0x%04x)\n", sync_word);
b517af05
RP
349 return -1;
350 }
b517af05
RP
351
352 skip_bits(gbp, 16); /* Output timestamp */
353
354 s->min_channel = get_bits(gbp, 4);
355 s->max_channel = get_bits(gbp, 4);
356 s->max_matrix_channel = get_bits(gbp, 4);
357
868170c4
RP
358 if (s->max_matrix_channel > max_matrix_channel) {
359 av_log(m->avctx, AV_LOG_ERROR,
360 "Max matrix channel cannot be greater than %d.\n",
361 max_matrix_channel);
362 return -1;
363 }
364
365 if (s->max_channel != s->max_matrix_channel) {
366 av_log(m->avctx, AV_LOG_ERROR,
367 "Max channel must be equal max matrix channel.\n");
368 return -1;
369 }
370
b517af05
RP
371 if (s->min_channel > s->max_channel) {
372 av_log(m->avctx, AV_LOG_ERROR,
373 "Substream min channel cannot be greater than max channel.\n");
374 return -1;
375 }
376
377 if (m->avctx->request_channels > 0
378 && s->max_channel + 1 >= m->avctx->request_channels
379 && substr < m->max_decoded_substream) {
380 av_log(m->avctx, AV_LOG_INFO,
381 "Extracting %d channel downmix from substream %d. "
382 "Further substreams will be skipped.\n",
383 s->max_channel + 1, substr);
384 m->max_decoded_substream = substr;
385 }
386
387 s->noise_shift = get_bits(gbp, 4);
388 s->noisegen_seed = get_bits(gbp, 23);
389
390 skip_bits(gbp, 19);
391
392 s->data_check_present = get_bits1(gbp);
393 lossless_check = get_bits(gbp, 8);
394 if (substr == m->max_decoded_substream
395 && s->lossless_check_data != 0xffffffff) {
a7cc783d 396 tmp = xor_32_to_8(s->lossless_check_data);
b517af05
RP
397 if (tmp != lossless_check)
398 av_log(m->avctx, AV_LOG_WARNING,
9906a2be 399 "Lossless check failed - expected %02x, calculated %02x.\n",
b517af05 400 lossless_check, tmp);
b517af05
RP
401 }
402
403 skip_bits(gbp, 16);
404
9731e7f1
RP
405 memset(s->ch_assign, 0, sizeof(s->ch_assign));
406
b517af05
RP
407 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
408 int ch_assign = get_bits(gbp, 6);
9731e7f1 409 if (ch_assign > s->max_matrix_channel) {
b517af05 410 av_log(m->avctx, AV_LOG_ERROR,
9731e7f1
RP
411 "Assignment of matrix channel %d to invalid output channel %d. %s\n",
412 ch, ch_assign, sample_message);
b517af05
RP
413 return -1;
414 }
9731e7f1 415 s->ch_assign[ch_assign] = ch;
b517af05
RP
416 }
417
ce15710f 418 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
b517af05
RP
419
420 if (checksum != get_bits(gbp, 8))
9906a2be 421 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
b517af05 422
9906a2be 423 /* Set default decoding parameters. */
b517af05
RP
424 s->param_presence_flags = 0xff;
425 s->num_primitive_matrices = 0;
426 s->blocksize = 8;
427 s->lossless_check_data = 0;
428
429 memset(s->output_shift , 0, sizeof(s->output_shift ));
430 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
431
432 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
f53acb7b
RP
433 ChannelParams *cp = &m->channel_params[ch];
434 cp->filter_params[FIR].order = 0;
435 cp->filter_params[IIR].order = 0;
436 cp->filter_params[FIR].shift = 0;
437 cp->filter_params[IIR].shift = 0;
b517af05 438
9906a2be 439 /* Default audio coding is 24-bit raw PCM. */
f53acb7b
RP
440 cp->huff_offset = 0;
441 cp->sign_huff_offset = (-1) << 23;
442 cp->codebook = 0;
443 cp->huff_lsbs = 24;
b517af05
RP
444 }
445
f95f6ab9 446 if (substr == m->max_decoded_substream)
9731e7f1 447 m->avctx->channels = s->max_matrix_channel + 1;
b517af05
RP
448
449 return 0;
450}
451
452/** Read parameters for one of the prediction filters. */
453
454static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
455 unsigned int channel, unsigned int filter)
456{
f53acb7b 457 FilterParams *fp = &m->channel_params[channel].filter_params[filter];
0c5670a0 458 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
b517af05
RP
459 const char fchar = filter ? 'I' : 'F';
460 int i, order;
461
9906a2be 462 // Filter is 0 for FIR, 1 for IIR.
b517af05
RP
463 assert(filter < 2);
464
5d9e4eaa
RP
465 if (m->filter_changed[channel][filter]++ > 1) {
466 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
467 return -1;
468 }
75428fa4 469
b517af05 470 order = get_bits(gbp, 4);
0c5670a0 471 if (order > max_order) {
b517af05 472 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 473 "%cIR filter order %d is greater than maximum %d.\n",
0c5670a0 474 fchar, order, max_order);
b517af05
RP
475 return -1;
476 }
d6aa052d 477 fp->order = order;
b517af05
RP
478
479 if (order > 0) {
480 int coeff_bits, coeff_shift;
481
d6aa052d 482 fp->shift = get_bits(gbp, 4);
b517af05
RP
483
484 coeff_bits = get_bits(gbp, 5);
485 coeff_shift = get_bits(gbp, 3);
486 if (coeff_bits < 1 || coeff_bits > 16) {
487 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 488 "%cIR filter coeff_bits must be between 1 and 16.\n",
b517af05
RP
489 fchar);
490 return -1;
491 }
492 if (coeff_bits + coeff_shift > 16) {
493 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 494 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
b517af05
RP
495 fchar);
496 return -1;
497 }
498
499 for (i = 0; i < order; i++)
db01fa13 500 fp->coeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
b517af05
RP
501
502 if (get_bits1(gbp)) {
503 int state_bits, state_shift;
504
505 if (filter == FIR) {
506 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 507 "FIR filter has state data specified.\n");
b517af05
RP
508 return -1;
509 }
510
511 state_bits = get_bits(gbp, 4);
512 state_shift = get_bits(gbp, 4);
513
9906a2be 514 /* TODO: Check validity of state data. */
b517af05
RP
515
516 for (i = 0; i < order; i++)
db01fa13 517 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
b517af05
RP
518 }
519 }
520
521 return 0;
522}
523
f8e6293b
RP
524/** Read parameters for primitive matrices. */
525
95c14b1e 526static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
f8e6293b 527{
95c14b1e 528 SubStream *s = &m->substream[substr];
f8e6293b
RP
529 unsigned int mat, ch;
530
5d9e4eaa
RP
531 if (m->matrix_changed++ > 1) {
532 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
533 return -1;
534 }
535
f8e6293b
RP
536 s->num_primitive_matrices = get_bits(gbp, 4);
537
538 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
539 int frac_bits, max_chan;
540 s->matrix_out_ch[mat] = get_bits(gbp, 4);
541 frac_bits = get_bits(gbp, 4);
542 s->lsb_bypass [mat] = get_bits1(gbp);
543
0091d8a1 544 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
f8e6293b
RP
545 av_log(m->avctx, AV_LOG_ERROR,
546 "Invalid channel %d specified as output from matrix.\n",
547 s->matrix_out_ch[mat]);
548 return -1;
549 }
550 if (frac_bits > 14) {
551 av_log(m->avctx, AV_LOG_ERROR,
552 "Too many fractional bits specified.\n");
553 return -1;
554 }
555
556 max_chan = s->max_matrix_channel;
557 if (!s->noise_type)
558 max_chan+=2;
559
560 for (ch = 0; ch <= max_chan; ch++) {
561 int coeff_val = 0;
562 if (get_bits1(gbp))
563 coeff_val = get_sbits(gbp, frac_bits + 2);
564
565 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
566 }
567
568 if (s->noise_type)
569 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
570 else
571 s->matrix_noise_shift[mat] = 0;
572 }
573
574 return 0;
575}
576
43ee5fe0
RP
577/** Read channel parameters. */
578
579static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
580 GetBitContext *gbp, unsigned int ch)
581{
582 ChannelParams *cp = &m->channel_params[ch];
583 FilterParams *fir = &cp->filter_params[FIR];
584 FilterParams *iir = &cp->filter_params[IIR];
585 SubStream *s = &m->substream[substr];
586
587 if (s->param_presence_flags & PARAM_FIR)
588 if (get_bits1(gbp))
589 if (read_filter_params(m, gbp, ch, FIR) < 0)
590 return -1;
591
592 if (s->param_presence_flags & PARAM_IIR)
593 if (get_bits1(gbp))
594 if (read_filter_params(m, gbp, ch, IIR) < 0)
595 return -1;
596
125cf771
RP
597 if (fir->order + iir->order > 8) {
598 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
599 return -1;
600 }
601
43ee5fe0
RP
602 if (fir->order && iir->order &&
603 fir->shift != iir->shift) {
604 av_log(m->avctx, AV_LOG_ERROR,
605 "FIR and IIR filters must use the same precision.\n");
606 return -1;
607 }
608 /* The FIR and IIR filters must have the same precision.
609 * To simplify the filtering code, only the precision of the
610 * FIR filter is considered. If only the IIR filter is employed,
611 * the FIR filter precision is set to that of the IIR filter, so
612 * that the filtering code can use it. */
613 if (!fir->order && iir->order)
614 fir->shift = iir->shift;
615
616 if (s->param_presence_flags & PARAM_HUFFOFFSET)
617 if (get_bits1(gbp))
618 cp->huff_offset = get_sbits(gbp, 15);
619
620 cp->codebook = get_bits(gbp, 2);
621 cp->huff_lsbs = get_bits(gbp, 5);
622
125cf771
RP
623 if (cp->huff_lsbs > 24) {
624 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
625 return -1;
626 }
43ee5fe0 627
125cf771 628 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
43ee5fe0
RP
629
630 return 0;
631}
632
b517af05
RP
633/** Read decoding parameters that change more often than those in the restart
634 * header. */
635
636static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
637 unsigned int substr)
638{
639 SubStream *s = &m->substream[substr];
f8e6293b 640 unsigned int ch;
b517af05 641
cbf3cf19 642 if (s->param_presence_flags & PARAM_PRESENCE)
f95f6ab9
RP
643 if (get_bits1(gbp))
644 s->param_presence_flags = get_bits(gbp, 8);
b517af05
RP
645
646 if (s->param_presence_flags & PARAM_BLOCKSIZE)
647 if (get_bits1(gbp)) {
648 s->blocksize = get_bits(gbp, 9);
b864098c
RP
649 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
650 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
b517af05
RP
651 s->blocksize = 0;
652 return -1;
653 }
654 }
655
656 if (s->param_presence_flags & PARAM_MATRIX)
f95f6ab9 657 if (get_bits1(gbp))
95c14b1e 658 if (read_matrix_params(m, substr, gbp) < 0)
f8e6293b 659 return -1;
b517af05
RP
660
661 if (s->param_presence_flags & PARAM_OUTSHIFT)
662 if (get_bits1(gbp))
f95f6ab9 663 for (ch = 0; ch <= s->max_matrix_channel; ch++)
af048026 664 s->output_shift[ch] = get_sbits(gbp, 4);
b517af05
RP
665
666 if (s->param_presence_flags & PARAM_QUANTSTEP)
667 if (get_bits1(gbp))
668 for (ch = 0; ch <= s->max_channel; ch++) {
f53acb7b
RP
669 ChannelParams *cp = &m->channel_params[ch];
670
b517af05 671 s->quant_step_size[ch] = get_bits(gbp, 4);
b517af05 672
f53acb7b 673 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
b517af05
RP
674 }
675
676 for (ch = s->min_channel; ch <= s->max_channel; ch++)
f95f6ab9 677 if (get_bits1(gbp))
43ee5fe0 678 if (read_channel_params(m, substr, gbp, ch) < 0)
b517af05 679 return -1;
b517af05
RP
680
681 return 0;
682}
683
684#define MSB_MASK(bits) (-1u << bits)
685
686/** Generate PCM samples using the prediction filters and residual values
687 * read from the data stream, and update the filter state. */
688
689static void filter_channel(MLPDecodeContext *m, unsigned int substr,
690 unsigned int channel)
691{
692 SubStream *s = &m->substream[substr];
e71365f4
RP
693 int32_t firbuf[MAX_BLOCKSIZE + MAX_FIR_ORDER];
694 int32_t iirbuf[MAX_BLOCKSIZE + MAX_IIR_ORDER];
695 FilterParams *fir = &m->channel_params[channel].filter_params[FIR];
696 FilterParams *iir = &m->channel_params[channel].filter_params[IIR];
697 unsigned int filter_shift = fir->shift;
b517af05
RP
698 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
699 int index = MAX_BLOCKSIZE;
0ae59bb0 700 int i;
b517af05 701
06e34be8
RP
702 memcpy(&firbuf[index], fir->state, MAX_FIR_ORDER * sizeof(int32_t));
703 memcpy(&iirbuf[index], iir->state, MAX_IIR_ORDER * sizeof(int32_t));
b517af05
RP
704
705 for (i = 0; i < s->blocksize; i++) {
706 int32_t residual = m->sample_buffer[i + s->blockpos][channel];
707 unsigned int order;
708 int64_t accum = 0;
709 int32_t result;
710
711 /* TODO: Move this code to DSPContext? */
712
e71365f4 713 for (order = 0; order < fir->order; order++)
06e34be8 714 accum += (int64_t) firbuf[index + order] * fir->coeff[order];
e71365f4 715 for (order = 0; order < iir->order; order++)
06e34be8 716 accum += (int64_t) iirbuf[index + order] * iir->coeff[order];
b517af05
RP
717
718 accum = accum >> filter_shift;
719 result = (accum + residual) & mask;
720
721 --index;
722
e71365f4
RP
723 firbuf[index] = result;
724 iirbuf[index] = result - accum;
b517af05
RP
725
726 m->sample_buffer[i + s->blockpos][channel] = result;
727 }
728
06e34be8
RP
729 memcpy(fir->state, &firbuf[index], MAX_FIR_ORDER * sizeof(int32_t));
730 memcpy(iir->state, &iirbuf[index], MAX_IIR_ORDER * sizeof(int32_t));
b517af05
RP
731}
732
733/** Read a block of PCM residual data (or actual if no filtering active). */
734
735static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
736 unsigned int substr)
737{
738 SubStream *s = &m->substream[substr];
739 unsigned int i, ch, expected_stream_pos = 0;
740
741 if (s->data_check_present) {
742 expected_stream_pos = get_bits_count(gbp);
743 expected_stream_pos += get_bits(gbp, 16);
744 av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
745 "we have not tested yet. %s\n", sample_message);
746 }
747
748 if (s->blockpos + s->blocksize > m->access_unit_size) {
9906a2be 749 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
b517af05
RP
750 return -1;
751 }
752
753 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
754 s->blocksize * sizeof(m->bypassed_lsbs[0]));
755
f95f6ab9 756 for (i = 0; i < s->blocksize; i++)
b517af05
RP
757 if (read_huff_channels(m, gbp, substr, i) < 0)
758 return -1;
b517af05 759
f95f6ab9 760 for (ch = s->min_channel; ch <= s->max_channel; ch++)
b517af05 761 filter_channel(m, substr, ch);
b517af05
RP
762
763 s->blockpos += s->blocksize;
764
765 if (s->data_check_present) {
766 if (get_bits_count(gbp) != expected_stream_pos)
9906a2be 767 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
b517af05
RP
768 skip_bits(gbp, 8);
769 }
770
771 return 0;
772}
773
9906a2be 774/** Data table used for TrueHD noise generation function. */
b517af05
RP
775
776static const int8_t noise_table[256] = {
777 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
778 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
779 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
780 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
781 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
782 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
783 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
784 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
785 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
786 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
787 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
788 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
789 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
790 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
791 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
792 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
793};
794
795/** Noise generation functions.
796 * I'm not sure what these are for - they seem to be some kind of pseudorandom
797 * sequence generators, used to generate noise data which is used when the
798 * channels are rematrixed. I'm not sure if they provide a practical benefit
799 * to compression, or just obfuscate the decoder. Are they for some kind of
800 * dithering? */
801
802/** Generate two channels of noise, used in the matrix when
803 * restart sync word == 0x31ea. */
804
805static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
806{
807 SubStream *s = &m->substream[substr];
808 unsigned int i;
809 uint32_t seed = s->noisegen_seed;
810 unsigned int maxchan = s->max_matrix_channel;
811
812 for (i = 0; i < s->blockpos; i++) {
813 uint16_t seed_shr7 = seed >> 7;
814 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
815 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
816
817 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
818 }
819
820 s->noisegen_seed = seed;
821}
822
823/** Generate a block of noise, used when restart sync word == 0x31eb. */
824
825static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
826{
827 SubStream *s = &m->substream[substr];
828 unsigned int i;
829 uint32_t seed = s->noisegen_seed;
830
831 for (i = 0; i < m->access_unit_size_pow2; i++) {
832 uint8_t seed_shr15 = seed >> 15;
833 m->noise_buffer[i] = noise_table[seed_shr15];
834 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
835 }
836
837 s->noisegen_seed = seed;
838}
839
840
841/** Apply the channel matrices in turn to reconstruct the original audio
842 * samples. */
843
844static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
845{
846 SubStream *s = &m->substream[substr];
847 unsigned int mat, src_ch, i;
848 unsigned int maxchan;
849
850 maxchan = s->max_matrix_channel;
851 if (!s->noise_type) {
852 generate_2_noise_channels(m, substr);
853 maxchan += 2;
854 } else {
855 fill_noise_buffer(m, substr);
856 }
857
858 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
859 int matrix_noise_shift = s->matrix_noise_shift[mat];
860 unsigned int dest_ch = s->matrix_out_ch[mat];
861 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
63ad832d 862 int32_t *coeffs = s->matrix_coeff[mat];
15e6748b
RP
863 int index = s->num_primitive_matrices - mat;
864 int index2 = 2 * index + 1;
b517af05
RP
865
866 /* TODO: DSPContext? */
867
868 for (i = 0; i < s->blockpos; i++) {
a256445e 869 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
63ad832d 870 int32_t *samples = m->sample_buffer[i];
b517af05 871 int64_t accum = 0;
f95f6ab9
RP
872
873 for (src_ch = 0; src_ch <= maxchan; src_ch++)
874 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
875
b517af05 876 if (matrix_noise_shift) {
15e6748b 877 index &= m->access_unit_size_pow2 - 1;
b517af05 878 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
15e6748b 879 index += index2;
b517af05 880 }
f95f6ab9 881
a256445e 882 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
b517af05
RP
883 }
884 }
885}
886
887/** Write the audio data into the output buffer. */
888
889static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
890 uint8_t *data, unsigned int *data_size, int is32)
891{
892 SubStream *s = &m->substream[substr];
9731e7f1 893 unsigned int i, out_ch = 0;
b517af05
RP
894 int32_t *data_32 = (int32_t*) data;
895 int16_t *data_16 = (int16_t*) data;
896
897 if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
898 return -1;
899
900 for (i = 0; i < s->blockpos; i++) {
9731e7f1
RP
901 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
902 int mat_ch = s->ch_assign[out_ch];
903 int32_t sample = m->sample_buffer[i][mat_ch]
904 << s->output_shift[mat_ch];
905 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
b517af05
RP
906 if (is32) *data_32++ = sample << 8;
907 else *data_16++ = sample >> 8;
908 }
909 }
910
9731e7f1 911 *data_size = i * out_ch * (is32 ? 4 : 2);
b517af05
RP
912
913 return 0;
914}
915
916static int output_data(MLPDecodeContext *m, unsigned int substr,
917 uint8_t *data, unsigned int *data_size)
918{
919 if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
920 return output_data_internal(m, substr, data, data_size, 1);
921 else
922 return output_data_internal(m, substr, data, data_size, 0);
923}
924
925
b517af05
RP
926/** Read an access unit from the stream.
927 * Returns < 0 on error, 0 if not enough data is present in the input stream
928 * otherwise returns the number of bytes consumed. */
929
930static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
7a00bbad 931 AVPacket *avpkt)
b517af05 932{
7a00bbad
TB
933 const uint8_t *buf = avpkt->data;
934 int buf_size = avpkt->size;
b517af05
RP
935 MLPDecodeContext *m = avctx->priv_data;
936 GetBitContext gb;
937 unsigned int length, substr;
938 unsigned int substream_start;
939 unsigned int header_size = 4;
940 unsigned int substr_header_size = 0;
941 uint8_t substream_parity_present[MAX_SUBSTREAMS];
942 uint16_t substream_data_len[MAX_SUBSTREAMS];
943 uint8_t parity_bits;
944
945 if (buf_size < 4)
946 return 0;
947
948 length = (AV_RB16(buf) & 0xfff) * 2;
949
950 if (length > buf_size)
951 return -1;
952
953 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
954
cc9c5126 955 m->is_major_sync_unit = 0;
b517af05 956 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
b517af05
RP
957 if (read_major_sync(m, &gb) < 0)
958 goto error;
cc9c5126 959 m->is_major_sync_unit = 1;
b517af05
RP
960 header_size += 28;
961 }
962
963 if (!m->params_valid) {
964 av_log(m->avctx, AV_LOG_WARNING,
9906a2be 965 "Stream parameters not seen; skipping frame.\n");
b517af05
RP
966 *data_size = 0;
967 return length;
968 }
969
970 substream_start = 0;
971
972 for (substr = 0; substr < m->num_substreams; substr++) {
cc9c5126 973 int extraword_present, checkdata_present, end, nonrestart_substr;
b517af05
RP
974
975 extraword_present = get_bits1(&gb);
cc9c5126 976 nonrestart_substr = get_bits1(&gb);
b517af05
RP
977 checkdata_present = get_bits1(&gb);
978 skip_bits1(&gb);
979
980 end = get_bits(&gb, 12) * 2;
981
982 substr_header_size += 2;
983
984 if (extraword_present) {
89e39be3
RP
985 if (m->avctx->codec_id == CODEC_ID_MLP) {
986 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
987 goto error;
988 }
b517af05
RP
989 skip_bits(&gb, 16);
990 substr_header_size += 2;
991 }
992
cc9c5126
RP
993 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
994 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
995 goto error;
996 }
997
b517af05
RP
998 if (end + header_size + substr_header_size > length) {
999 av_log(m->avctx, AV_LOG_ERROR,
1000 "Indicated length of substream %d data goes off end of "
1001 "packet.\n", substr);
1002 end = length - header_size - substr_header_size;
1003 }
1004
1005 if (end < substream_start) {
1006 av_log(avctx, AV_LOG_ERROR,
1007 "Indicated end offset of substream %d data "
1008 "is smaller than calculated start offset.\n",
1009 substr);
1010 goto error;
1011 }
1012
1013 if (substr > m->max_decoded_substream)
1014 continue;
1015
1016 substream_parity_present[substr] = checkdata_present;
1017 substream_data_len[substr] = end - substream_start;
1018 substream_start = end;
1019 }
1020
ce15710f
RP
1021 parity_bits = ff_mlp_calculate_parity(buf, 4);
1022 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
b517af05
RP
1023
1024 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1025 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1026 goto error;
1027 }
1028
1029 buf += header_size + substr_header_size;
1030
1031 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1032 SubStream *s = &m->substream[substr];
1033 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1034
75428fa4
RP
1035 m->matrix_changed = 0;
1036 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1037
b517af05
RP
1038 s->blockpos = 0;
1039 do {
1040 if (get_bits1(&gb)) {
1041 if (get_bits1(&gb)) {
9906a2be 1042 /* A restart header should be present. */
b517af05
RP
1043 if (read_restart_header(m, &gb, buf, substr) < 0)
1044 goto next_substr;
1045 s->restart_seen = 1;
1046 }
1047
f95f6ab9 1048 if (!s->restart_seen)
b517af05 1049 goto next_substr;
b517af05
RP
1050 if (read_decoding_params(m, &gb, substr) < 0)
1051 goto next_substr;
1052 }
1053
f95f6ab9 1054 if (!s->restart_seen)
b517af05 1055 goto next_substr;
b517af05
RP
1056
1057 if (read_block_data(m, &gb, substr) < 0)
1058 return -1;
1059
d7952be3
RP
1060 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1061 goto substream_length_mismatch;
1062
1063 } while (!get_bits1(&gb));
b517af05
RP
1064
1065 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
f95f6ab9 1066
7b18e13a
RP
1067 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1068 int shorten_by;
1069
1070 if (get_bits(&gb, 16) != 0xD234)
1071 return -1;
1072
1073 shorten_by = get_bits(&gb, 16);
1074 if (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by & 0x2000)
1075 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1076 else if (m->avctx->codec_id == CODEC_ID_MLP && shorten_by != 0xD234)
1077 return -1;
1078
b517af05 1079 if (substr == m->max_decoded_substream)
9906a2be 1080 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
b517af05 1081 }
f95f6ab9 1082
ab79fa44 1083 if (substream_parity_present[substr]) {
b517af05
RP
1084 uint8_t parity, checksum;
1085
ab79fa44
RP
1086 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1087 goto substream_length_mismatch;
1088
d544dcdf
RP
1089 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1090 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
b517af05 1091
d544dcdf
RP
1092 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1093 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1094 if ( get_bits(&gb, 8) != checksum)
1095 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
b517af05 1096 }
f95f6ab9
RP
1097
1098 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
d7952be3 1099 goto substream_length_mismatch;
b517af05
RP
1100
1101next_substr:
f95f6ab9 1102 if (!s->restart_seen)
01aaf092
RP
1103 av_log(m->avctx, AV_LOG_ERROR,
1104 "No restart header present in substream %d.\n", substr);
01aaf092 1105
b517af05
RP
1106 buf += substream_data_len[substr];
1107 }
1108
1109 rematrix_channels(m, m->max_decoded_substream);
1110
1111 if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1112 return -1;
1113
1114 return length;
1115
d7952be3
RP
1116substream_length_mismatch:
1117 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1118 return -1;
1119
b517af05
RP
1120error:
1121 m->params_valid = 0;
1122 return -1;
1123}
1124
9ba4821d 1125#if CONFIG_MLP_DECODER
b517af05
RP
1126AVCodec mlp_decoder = {
1127 "mlp",
1128 CODEC_TYPE_AUDIO,
1129 CODEC_ID_MLP,
1130 sizeof(MLPDecodeContext),
1131 mlp_decode_init,
1132 NULL,
1133 NULL,
1134 read_access_unit,
9ba4821d 1135 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
b517af05 1136};
9ba4821d 1137#endif /* CONFIG_MLP_DECODER */
b517af05 1138
9ba4821d
RP
1139#if CONFIG_TRUEHD_DECODER
1140AVCodec truehd_decoder = {
1141 "truehd",
1142 CODEC_TYPE_AUDIO,
1143 CODEC_ID_TRUEHD,
1144 sizeof(MLPDecodeContext),
1145 mlp_decode_init,
1146 NULL,
1147 NULL,
1148 read_access_unit,
1149 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1150};
1151#endif /* CONFIG_TRUEHD_DECODER */