mlpdec: Split sync word error and MLP sync word check.
[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 29#include "avcodec.h"
bf4f19dc 30#include "dsputil.h"
b517af05 31#include "libavutil/intreadwrite.h"
9106a698 32#include "get_bits.h"
b517af05
RP
33#include "libavutil/crc.h"
34#include "parser.h"
35#include "mlp_parser.h"
ce15710f 36#include "mlp.h"
b517af05 37
9906a2be 38/** number of bits used for VLC lookup - longest Huffman code is 9 */
b517af05
RP
39#define VLC_BITS 9
40
41
42static const char* sample_message =
43 "Please file a bug report following the instructions at "
0fa5f24c 44 "http://ffmpeg.org/bugreports.html and include "
b517af05
RP
45 "a sample of this file.";
46
47typedef struct SubStream {
9906a2be 48 //! Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
b517af05
RP
49 uint8_t restart_seen;
50
51 //@{
52 /** restart header data */
53 //! The type of noise to be used in the rematrix stage.
54 uint16_t noise_type;
55
56 //! The index of the first channel coded in this substream.
57 uint8_t min_channel;
58 //! The index of the last channel coded in this substream.
59 uint8_t max_channel;
60 //! The number of channels input into the rematrix stage.
61 uint8_t max_matrix_channel;
9731e7f1
RP
62 //! For each channel output by the matrix, the output channel to map it to
63 uint8_t ch_assign[MAX_CHANNELS];
b517af05
RP
64
65 //! The left shift applied to random noise in 0x31ea substreams.
66 uint8_t noise_shift;
67 //! The current seed value for the pseudorandom noise generator(s).
68 uint32_t noisegen_seed;
69
70 //! Set if the substream contains extra info to check the size of VLC blocks.
71 uint8_t data_check_present;
72
73 //! Bitmask of which parameter sets are conveyed in a decoding parameter block.
74 uint8_t param_presence_flags;
75#define PARAM_BLOCKSIZE (1 << 7)
76#define PARAM_MATRIX (1 << 6)
77#define PARAM_OUTSHIFT (1 << 5)
78#define PARAM_QUANTSTEP (1 << 4)
79#define PARAM_FIR (1 << 3)
80#define PARAM_IIR (1 << 2)
81#define PARAM_HUFFOFFSET (1 << 1)
cbf3cf19 82#define PARAM_PRESENCE (1 << 0)
b517af05
RP
83 //@}
84
85 //@{
86 /** matrix data */
87
88 //! Number of matrices to be applied.
89 uint8_t num_primitive_matrices;
90
91 //! matrix output channel
92 uint8_t matrix_out_ch[MAX_MATRICES];
93
94 //! Whether the LSBs of the matrix output are encoded in the bitstream.
95 uint8_t lsb_bypass[MAX_MATRICES];
96 //! Matrix coefficients, stored as 2.14 fixed point.
420df930 97 int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
b517af05
RP
98 //! Left shift to apply to noise values in 0x31eb substreams.
99 uint8_t matrix_noise_shift[MAX_MATRICES];
100 //@}
101
9906a2be 102 //! Left shift to apply to Huffman-decoded residuals.
b517af05
RP
103 uint8_t quant_step_size[MAX_CHANNELS];
104
9906a2be 105 //! number of PCM samples in current audio block
b517af05
RP
106 uint16_t blocksize;
107 //! Number of PCM samples decoded so far in this frame.
108 uint16_t blockpos;
109
110 //! Left shift to apply to decoded PCM values to get final 24-bit output.
111 int8_t output_shift[MAX_CHANNELS];
112
113 //! Running XOR of all output samples.
114 int32_t lossless_check_data;
115
116} SubStream;
117
118typedef struct MLPDecodeContext {
119 AVCodecContext *avctx;
120
cc9c5126
RP
121 //! Current access unit being read has a major sync.
122 int is_major_sync_unit;
123
b517af05
RP
124 //! Set if a valid major sync block has been read. Otherwise no decoding is possible.
125 uint8_t params_valid;
126
127 //! Number of substreams contained within this stream.
128 uint8_t num_substreams;
129
130 //! Index of the last substream to decode - further substreams are skipped.
131 uint8_t max_decoded_substream;
132
9906a2be 133 //! number of PCM samples contained in each frame
b517af05 134 int access_unit_size;
9906a2be 135 //! next power of two above the number of samples in each frame
b517af05
RP
136 int access_unit_size_pow2;
137
138 SubStream substream[MAX_SUBSTREAMS];
139
f53acb7b 140 ChannelParams channel_params[MAX_CHANNELS];
b517af05 141
75428fa4
RP
142 int matrix_changed;
143 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
144
b517af05
RP
145 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
146 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
420df930 147 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
bf4f19dc
RP
148
149 DSPContext dsp;
b517af05
RP
150} MLPDecodeContext;
151
b517af05
RP
152static VLC huff_vlc[3];
153
b517af05
RP
154/** Initialize static data, constant between all invocations of the codec. */
155
dc8a7c93 156static av_cold void init_static(void)
b517af05
RP
157{
158 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
ce15710f
RP
159 &ff_mlp_huffman_tables[0][0][1], 2, 1,
160 &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
b517af05 161 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
ce15710f
RP
162 &ff_mlp_huffman_tables[1][0][1], 2, 1,
163 &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
b517af05 164 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
ce15710f
RP
165 &ff_mlp_huffman_tables[2][0][1], 2, 1,
166 &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
b517af05 167
ce15710f 168 ff_mlp_init_crc();
b517af05
RP
169}
170
171static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
172 unsigned int substr, unsigned int ch)
173{
f53acb7b 174 ChannelParams *cp = &m->channel_params[ch];
b517af05 175 SubStream *s = &m->substream[substr];
f53acb7b
RP
176 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
177 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
178 int32_t sign_huff_offset = cp->huff_offset;
b517af05 179
f53acb7b 180 if (cp->codebook > 0)
b517af05
RP
181 sign_huff_offset -= 7 << lsb_bits;
182
183 if (sign_shift >= 0)
184 sign_huff_offset -= 1 << sign_shift;
185
186 return sign_huff_offset;
187}
188
189/** Read a sample, consisting of either, both or neither of entropy-coded MSBs
190 * and plain LSBs. */
191
192static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
193 unsigned int substr, unsigned int pos)
194{
195 SubStream *s = &m->substream[substr];
196 unsigned int mat, channel;
197
198 for (mat = 0; mat < s->num_primitive_matrices; mat++)
199 if (s->lsb_bypass[mat])
200 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
201
202 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
f53acb7b
RP
203 ChannelParams *cp = &m->channel_params[channel];
204 int codebook = cp->codebook;
b517af05 205 int quant_step_size = s->quant_step_size[channel];
f53acb7b 206 int lsb_bits = cp->huff_lsbs - quant_step_size;
b517af05
RP
207 int result = 0;
208
209 if (codebook > 0)
210 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
211 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
212
213 if (result < 0)
214 return -1;
215
216 if (lsb_bits > 0)
217 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
218
f53acb7b 219 result += cp->sign_huff_offset;
b517af05
RP
220 result <<= quant_step_size;
221
222 m->sample_buffer[pos + s->blockpos][channel] = result;
223 }
224
225 return 0;
226}
227
228static av_cold int mlp_decode_init(AVCodecContext *avctx)
229{
230 MLPDecodeContext *m = avctx->priv_data;
231 int substr;
232
233 init_static();
234 m->avctx = avctx;
235 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
236 m->substream[substr].lossless_check_data = 0xffffffff;
bf4f19dc 237 dsputil_init(&m->dsp, avctx);
ee1a8f62 238
b517af05
RP
239 return 0;
240}
241
242/** Read a major sync info header - contains high level information about
243 * the stream - sample rate, channel arrangement etc. Most of this
244 * information is not actually necessary for decoding, only for playback.
245 */
246
247static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
248{
249 MLPHeaderInfo mh;
250 int substr;
251
252 if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
253 return -1;
254
255 if (mh.group1_bits == 0) {
9906a2be 256 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
b517af05
RP
257 return -1;
258 }
259 if (mh.group2_bits > mh.group1_bits) {
260 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 261 "Channel group 2 cannot have more bits per sample than group 1.\n");
b517af05
RP
262 return -1;
263 }
264
265 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
266 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 267 "Channel groups with differing sample rates are not currently supported.\n");
b517af05
RP
268 return -1;
269 }
270
271 if (mh.group1_samplerate == 0) {
9906a2be 272 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
b517af05
RP
273 return -1;
274 }
275 if (mh.group1_samplerate > MAX_SAMPLERATE) {
276 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 277 "Sampling rate %d is greater than the supported maximum (%d).\n",
b517af05
RP
278 mh.group1_samplerate, MAX_SAMPLERATE);
279 return -1;
280 }
281 if (mh.access_unit_size > MAX_BLOCKSIZE) {
282 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 283 "Block size %d is greater than the supported maximum (%d).\n",
b517af05
RP
284 mh.access_unit_size, MAX_BLOCKSIZE);
285 return -1;
286 }
287 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
288 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 289 "Block size pow2 %d is greater than the supported maximum (%d).\n",
b517af05
RP
290 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
291 return -1;
292 }
293
294 if (mh.num_substreams == 0)
295 return -1;
932cee5d
RP
296 if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
297 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
298 return -1;
299 }
b517af05
RP
300 if (mh.num_substreams > MAX_SUBSTREAMS) {
301 av_log(m->avctx, AV_LOG_ERROR,
9906a2be
DB
302 "Number of substreams %d is larger than the maximum supported "
303 "by the decoder. %s\n", mh.num_substreams, sample_message);
b517af05
RP
304 return -1;
305 }
306
307 m->access_unit_size = mh.access_unit_size;
308 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
309
310 m->num_substreams = mh.num_substreams;
311 m->max_decoded_substream = m->num_substreams - 1;
312
313 m->avctx->sample_rate = mh.group1_samplerate;
314 m->avctx->frame_size = mh.access_unit_size;
315
97679e6e 316 m->avctx->bits_per_raw_sample = mh.group1_bits;
c687643c 317 if (mh.group1_bits > 16)
b517af05 318 m->avctx->sample_fmt = SAMPLE_FMT_S32;
ee1a8f62
RP
319 else
320 m->avctx->sample_fmt = SAMPLE_FMT_S16;
b517af05
RP
321
322 m->params_valid = 1;
323 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
324 m->substream[substr].restart_seen = 0;
325
326 return 0;
327}
328
329/** Read a restart header from a block in a substream. This contains parameters
330 * required to decode the audio that do not change very often. Generally
331 * (always) present only in blocks following a major sync. */
332
333static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
334 const uint8_t *buf, unsigned int substr)
335{
336 SubStream *s = &m->substream[substr];
337 unsigned int ch;
338 int sync_word, tmp;
339 uint8_t checksum;
340 uint8_t lossless_check;
341 int start_count = get_bits_count(gbp);
868170c4
RP
342 const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP
343 ? MAX_MATRIX_CHANNEL_MLP
344 : MAX_MATRIX_CHANNEL_TRUEHD;
b517af05
RP
345
346 sync_word = get_bits(gbp, 13);
347
e8d341ce 348 if (sync_word != 0x31ea >> 1) {
b517af05 349 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 350 "restart header sync incorrect (got 0x%04x)\n", sync_word);
b517af05
RP
351 return -1;
352 }
b517af05 353
e8d341ce
RP
354 s->noise_type = get_bits1(gbp);
355
356 if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) {
357 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
358 return -1;
359 }
360
b517af05
RP
361 skip_bits(gbp, 16); /* Output timestamp */
362
363 s->min_channel = get_bits(gbp, 4);
364 s->max_channel = get_bits(gbp, 4);
365 s->max_matrix_channel = get_bits(gbp, 4);
366
868170c4
RP
367 if (s->max_matrix_channel > max_matrix_channel) {
368 av_log(m->avctx, AV_LOG_ERROR,
369 "Max matrix channel cannot be greater than %d.\n",
370 max_matrix_channel);
371 return -1;
372 }
373
374 if (s->max_channel != s->max_matrix_channel) {
375 av_log(m->avctx, AV_LOG_ERROR,
376 "Max channel must be equal max matrix channel.\n");
377 return -1;
378 }
379
b517af05
RP
380 if (s->min_channel > s->max_channel) {
381 av_log(m->avctx, AV_LOG_ERROR,
382 "Substream min channel cannot be greater than max channel.\n");
383 return -1;
384 }
385
386 if (m->avctx->request_channels > 0
387 && s->max_channel + 1 >= m->avctx->request_channels
388 && substr < m->max_decoded_substream) {
389 av_log(m->avctx, AV_LOG_INFO,
390 "Extracting %d channel downmix from substream %d. "
391 "Further substreams will be skipped.\n",
392 s->max_channel + 1, substr);
393 m->max_decoded_substream = substr;
394 }
395
396 s->noise_shift = get_bits(gbp, 4);
397 s->noisegen_seed = get_bits(gbp, 23);
398
399 skip_bits(gbp, 19);
400
401 s->data_check_present = get_bits1(gbp);
402 lossless_check = get_bits(gbp, 8);
403 if (substr == m->max_decoded_substream
404 && s->lossless_check_data != 0xffffffff) {
a7cc783d 405 tmp = xor_32_to_8(s->lossless_check_data);
b517af05
RP
406 if (tmp != lossless_check)
407 av_log(m->avctx, AV_LOG_WARNING,
9906a2be 408 "Lossless check failed - expected %02x, calculated %02x.\n",
b517af05 409 lossless_check, tmp);
b517af05
RP
410 }
411
412 skip_bits(gbp, 16);
413
9731e7f1
RP
414 memset(s->ch_assign, 0, sizeof(s->ch_assign));
415
b517af05
RP
416 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
417 int ch_assign = get_bits(gbp, 6);
9731e7f1 418 if (ch_assign > s->max_matrix_channel) {
b517af05 419 av_log(m->avctx, AV_LOG_ERROR,
9731e7f1
RP
420 "Assignment of matrix channel %d to invalid output channel %d. %s\n",
421 ch, ch_assign, sample_message);
b517af05
RP
422 return -1;
423 }
9731e7f1 424 s->ch_assign[ch_assign] = ch;
b517af05
RP
425 }
426
ce15710f 427 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
b517af05
RP
428
429 if (checksum != get_bits(gbp, 8))
9906a2be 430 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
b517af05 431
9906a2be 432 /* Set default decoding parameters. */
b517af05
RP
433 s->param_presence_flags = 0xff;
434 s->num_primitive_matrices = 0;
435 s->blocksize = 8;
436 s->lossless_check_data = 0;
437
438 memset(s->output_shift , 0, sizeof(s->output_shift ));
439 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
440
441 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
f53acb7b
RP
442 ChannelParams *cp = &m->channel_params[ch];
443 cp->filter_params[FIR].order = 0;
444 cp->filter_params[IIR].order = 0;
445 cp->filter_params[FIR].shift = 0;
446 cp->filter_params[IIR].shift = 0;
b517af05 447
9906a2be 448 /* Default audio coding is 24-bit raw PCM. */
f53acb7b
RP
449 cp->huff_offset = 0;
450 cp->sign_huff_offset = (-1) << 23;
451 cp->codebook = 0;
452 cp->huff_lsbs = 24;
b517af05
RP
453 }
454
f95f6ab9 455 if (substr == m->max_decoded_substream)
9731e7f1 456 m->avctx->channels = s->max_matrix_channel + 1;
b517af05
RP
457
458 return 0;
459}
460
461/** Read parameters for one of the prediction filters. */
462
463static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
464 unsigned int channel, unsigned int filter)
465{
f53acb7b 466 FilterParams *fp = &m->channel_params[channel].filter_params[filter];
0c5670a0 467 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
b517af05
RP
468 const char fchar = filter ? 'I' : 'F';
469 int i, order;
470
9906a2be 471 // Filter is 0 for FIR, 1 for IIR.
b517af05
RP
472 assert(filter < 2);
473
5d9e4eaa
RP
474 if (m->filter_changed[channel][filter]++ > 1) {
475 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
476 return -1;
477 }
75428fa4 478
b517af05 479 order = get_bits(gbp, 4);
0c5670a0 480 if (order > max_order) {
b517af05 481 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 482 "%cIR filter order %d is greater than maximum %d.\n",
0c5670a0 483 fchar, order, max_order);
b517af05
RP
484 return -1;
485 }
d6aa052d 486 fp->order = order;
b517af05
RP
487
488 if (order > 0) {
489 int coeff_bits, coeff_shift;
490
d6aa052d 491 fp->shift = get_bits(gbp, 4);
b517af05
RP
492
493 coeff_bits = get_bits(gbp, 5);
494 coeff_shift = get_bits(gbp, 3);
495 if (coeff_bits < 1 || coeff_bits > 16) {
496 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 497 "%cIR filter coeff_bits must be between 1 and 16.\n",
b517af05
RP
498 fchar);
499 return -1;
500 }
501 if (coeff_bits + coeff_shift > 16) {
502 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 503 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
b517af05
RP
504 fchar);
505 return -1;
506 }
507
508 for (i = 0; i < order; i++)
db01fa13 509 fp->coeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
b517af05
RP
510
511 if (get_bits1(gbp)) {
512 int state_bits, state_shift;
513
514 if (filter == FIR) {
515 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 516 "FIR filter has state data specified.\n");
b517af05
RP
517 return -1;
518 }
519
520 state_bits = get_bits(gbp, 4);
521 state_shift = get_bits(gbp, 4);
522
9906a2be 523 /* TODO: Check validity of state data. */
b517af05
RP
524
525 for (i = 0; i < order; i++)
db01fa13 526 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
b517af05
RP
527 }
528 }
529
530 return 0;
531}
532
f8e6293b
RP
533/** Read parameters for primitive matrices. */
534
95c14b1e 535static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
f8e6293b 536{
95c14b1e 537 SubStream *s = &m->substream[substr];
f8e6293b 538 unsigned int mat, ch;
309616b2
RP
539 const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
540 ? MAX_MATRICES_MLP
541 : MAX_MATRICES_TRUEHD;
f8e6293b 542
5d9e4eaa
RP
543 if (m->matrix_changed++ > 1) {
544 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
545 return -1;
546 }
547
f8e6293b
RP
548 s->num_primitive_matrices = get_bits(gbp, 4);
549
309616b2
RP
550 if (s->num_primitive_matrices > max_primitive_matrices) {
551 av_log(m->avctx, AV_LOG_ERROR,
552 "Number of primitive matrices cannot be greater than %d.\n",
553 max_primitive_matrices);
554 return -1;
555 }
556
f8e6293b
RP
557 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
558 int frac_bits, max_chan;
559 s->matrix_out_ch[mat] = get_bits(gbp, 4);
560 frac_bits = get_bits(gbp, 4);
561 s->lsb_bypass [mat] = get_bits1(gbp);
562
0091d8a1 563 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
f8e6293b
RP
564 av_log(m->avctx, AV_LOG_ERROR,
565 "Invalid channel %d specified as output from matrix.\n",
566 s->matrix_out_ch[mat]);
567 return -1;
568 }
569 if (frac_bits > 14) {
570 av_log(m->avctx, AV_LOG_ERROR,
571 "Too many fractional bits specified.\n");
572 return -1;
573 }
574
575 max_chan = s->max_matrix_channel;
576 if (!s->noise_type)
577 max_chan+=2;
578
579 for (ch = 0; ch <= max_chan; ch++) {
580 int coeff_val = 0;
581 if (get_bits1(gbp))
582 coeff_val = get_sbits(gbp, frac_bits + 2);
583
584 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
585 }
586
587 if (s->noise_type)
588 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
589 else
590 s->matrix_noise_shift[mat] = 0;
591 }
592
593 return 0;
594}
595
43ee5fe0
RP
596/** Read channel parameters. */
597
598static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
599 GetBitContext *gbp, unsigned int ch)
600{
601 ChannelParams *cp = &m->channel_params[ch];
602 FilterParams *fir = &cp->filter_params[FIR];
603 FilterParams *iir = &cp->filter_params[IIR];
604 SubStream *s = &m->substream[substr];
605
606 if (s->param_presence_flags & PARAM_FIR)
607 if (get_bits1(gbp))
608 if (read_filter_params(m, gbp, ch, FIR) < 0)
609 return -1;
610
611 if (s->param_presence_flags & PARAM_IIR)
612 if (get_bits1(gbp))
613 if (read_filter_params(m, gbp, ch, IIR) < 0)
614 return -1;
615
125cf771
RP
616 if (fir->order + iir->order > 8) {
617 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
618 return -1;
619 }
620
43ee5fe0
RP
621 if (fir->order && iir->order &&
622 fir->shift != iir->shift) {
623 av_log(m->avctx, AV_LOG_ERROR,
624 "FIR and IIR filters must use the same precision.\n");
625 return -1;
626 }
627 /* The FIR and IIR filters must have the same precision.
aff42ee0
RP
628 * To simplify the filtering code, only the precision of the
629 * FIR filter is considered. If only the IIR filter is employed,
630 * the FIR filter precision is set to that of the IIR filter, so
631 * that the filtering code can use it. */
43ee5fe0
RP
632 if (!fir->order && iir->order)
633 fir->shift = iir->shift;
634
635 if (s->param_presence_flags & PARAM_HUFFOFFSET)
636 if (get_bits1(gbp))
637 cp->huff_offset = get_sbits(gbp, 15);
638
639 cp->codebook = get_bits(gbp, 2);
640 cp->huff_lsbs = get_bits(gbp, 5);
641
125cf771
RP
642 if (cp->huff_lsbs > 24) {
643 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
644 return -1;
645 }
43ee5fe0 646
125cf771 647 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
43ee5fe0
RP
648
649 return 0;
650}
651
b517af05
RP
652/** Read decoding parameters that change more often than those in the restart
653 * header. */
654
655static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
656 unsigned int substr)
657{
658 SubStream *s = &m->substream[substr];
f8e6293b 659 unsigned int ch;
b517af05 660
cbf3cf19 661 if (s->param_presence_flags & PARAM_PRESENCE)
f95f6ab9
RP
662 if (get_bits1(gbp))
663 s->param_presence_flags = get_bits(gbp, 8);
b517af05
RP
664
665 if (s->param_presence_flags & PARAM_BLOCKSIZE)
666 if (get_bits1(gbp)) {
667 s->blocksize = get_bits(gbp, 9);
b864098c
RP
668 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
669 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
b517af05
RP
670 s->blocksize = 0;
671 return -1;
672 }
673 }
674
675 if (s->param_presence_flags & PARAM_MATRIX)
f95f6ab9 676 if (get_bits1(gbp))
95c14b1e 677 if (read_matrix_params(m, substr, gbp) < 0)
f8e6293b 678 return -1;
b517af05
RP
679
680 if (s->param_presence_flags & PARAM_OUTSHIFT)
681 if (get_bits1(gbp))
f95f6ab9 682 for (ch = 0; ch <= s->max_matrix_channel; ch++)
af048026 683 s->output_shift[ch] = get_sbits(gbp, 4);
b517af05
RP
684
685 if (s->param_presence_flags & PARAM_QUANTSTEP)
686 if (get_bits1(gbp))
687 for (ch = 0; ch <= s->max_channel; ch++) {
f53acb7b
RP
688 ChannelParams *cp = &m->channel_params[ch];
689
b517af05 690 s->quant_step_size[ch] = get_bits(gbp, 4);
b517af05 691
f53acb7b 692 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
b517af05
RP
693 }
694
695 for (ch = s->min_channel; ch <= s->max_channel; ch++)
f95f6ab9 696 if (get_bits1(gbp))
43ee5fe0 697 if (read_channel_params(m, substr, gbp, ch) < 0)
b517af05 698 return -1;
b517af05
RP
699
700 return 0;
701}
702
703#define MSB_MASK(bits) (-1u << bits)
704
705/** Generate PCM samples using the prediction filters and residual values
706 * read from the data stream, and update the filter state. */
707
708static void filter_channel(MLPDecodeContext *m, unsigned int substr,
709 unsigned int channel)
710{
711 SubStream *s = &m->substream[substr];
77b12f80
RP
712 int32_t fir_state_buffer[MAX_BLOCKSIZE + MAX_FIR_ORDER];
713 int32_t iir_state_buffer[MAX_BLOCKSIZE + MAX_IIR_ORDER];
714 int32_t *firbuf = fir_state_buffer + MAX_BLOCKSIZE;
715 int32_t *iirbuf = iir_state_buffer + MAX_BLOCKSIZE;
e71365f4
RP
716 FilterParams *fir = &m->channel_params[channel].filter_params[FIR];
717 FilterParams *iir = &m->channel_params[channel].filter_params[IIR];
718 unsigned int filter_shift = fir->shift;
b517af05 719 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
b517af05 720
77b12f80
RP
721 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
722 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
b517af05 723
bf4f19dc
RP
724 m->dsp.mlp_filter_channel(firbuf, fir->coeff, fir->order,
725 iirbuf, iir->coeff, iir->order,
726 filter_shift, mask, s->blocksize,
727 &m->sample_buffer[s->blockpos][channel]);
b517af05 728
bf4f19dc
RP
729 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
730 memcpy(iir->state, iirbuf - s->blocksize, 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 */