ffmpeg / libavcodec / mlpdec.c @ 72415b2a
History  View  Annotate  Download (38.1 KB)
1 
/*


2 
* MLP decoder

3 
* Copyright (c) 20072008 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 021101301 USA

20 
*/

21  
22 
/**

23 
* @file libavcodec/mlpdec.c

24 
* MLP decoder

25 
*/

26  
27 
#include <stdint.h> 
28  
29 
#include "avcodec.h" 
30 
#include "dsputil.h" 
31 
#include "libavutil/intreadwrite.h" 
32 
#include "get_bits.h" 
33 
#include "libavutil/crc.h" 
34 
#include "parser.h" 
35 
#include "mlp_parser.h" 
36 
#include "mlp.h" 
37  
38 
/** number of bits used for VLC lookup  longest Huffman code is 9 */

39 
#define VLC_BITS 9 
40  
41  
42 
static const char* sample_message = 
43 
"Please file a bug report following the instructions at "

44 
"http://ffmpeg.org/bugreports.html and include "

45 
"a sample of this file.";

46  
47 
typedef struct SubStream { 
48 
//! Set if a valid restart header has been read. Otherwise the substream cannot be decoded.

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; 
62 
//! For each channel output by the matrix, the output channel to map it to

63 
uint8_t ch_assign[MAX_CHANNELS]; 
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) 
82 
#define PARAM_PRESENCE (1 << 0) 
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.

97 
int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS]; 
98 
//! Left shift to apply to noise values in 0x31eb substreams.

99 
uint8_t matrix_noise_shift[MAX_MATRICES]; 
100 
//@}

101  
102 
//! Left shift to apply to Huffmandecoded residuals.

103 
uint8_t quant_step_size[MAX_CHANNELS]; 
104  
105 
//! number of PCM samples in current audio block

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 24bit 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  
118 
typedef struct MLPDecodeContext { 
119 
AVCodecContext *avctx; 
120  
121 
//! Current access unit being read has a major sync.

122 
int is_major_sync_unit;

123  
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  
133 
//! number of PCM samples contained in each frame

134 
int access_unit_size;

135 
//! next power of two above the number of samples in each frame

136 
int access_unit_size_pow2;

137  
138 
SubStream substream[MAX_SUBSTREAMS]; 
139  
140 
ChannelParams channel_params[MAX_CHANNELS]; 
141  
142 
int matrix_changed;

143 
int filter_changed[MAX_CHANNELS][NUM_FILTERS];

144  
145 
int8_t noise_buffer[MAX_BLOCKSIZE_POW2]; 
146 
int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS]; 
147 
int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS]; 
148  
149 
DSPContext dsp; 
150 
} MLPDecodeContext; 
151  
152 
static VLC huff_vlc[3]; 
153  
154 
/** Initialize static data, constant between all invocations of the codec. */

155  
156 
static av_cold void init_static(void) 
157 
{ 
158 
if (!huff_vlc[0].bits) { 
159 
INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18, 
160 
&ff_mlp_huffman_tables[0][0][1], 2, 1, 
161 
&ff_mlp_huffman_tables[0][0][0], 2, 1, 512); 
162 
INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16, 
163 
&ff_mlp_huffman_tables[1][0][1], 2, 1, 
164 
&ff_mlp_huffman_tables[1][0][0], 2, 1, 512); 
165 
INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15, 
166 
&ff_mlp_huffman_tables[2][0][1], 2, 1, 
167 
&ff_mlp_huffman_tables[2][0][0], 2, 1, 512); 
168 
} 
169  
170 
ff_mlp_init_crc(); 
171 
} 
172  
173 
static inline int32_t calculate_sign_huff(MLPDecodeContext *m, 
174 
unsigned int substr, unsigned int ch) 
175 
{ 
176 
ChannelParams *cp = &m>channel_params[ch]; 
177 
SubStream *s = &m>substream[substr]; 
178 
int lsb_bits = cp>huff_lsbs  s>quant_step_size[ch];

179 
int sign_shift = lsb_bits + (cp>codebook ? 2  cp>codebook : 1); 
180 
int32_t sign_huff_offset = cp>huff_offset; 
181  
182 
if (cp>codebook > 0) 
183 
sign_huff_offset = 7 << lsb_bits;

184  
185 
if (sign_shift >= 0) 
186 
sign_huff_offset = 1 << sign_shift;

187  
188 
return sign_huff_offset;

189 
} 
190  
191 
/** Read a sample, consisting of either, both or neither of entropycoded MSBs

192 
* and plain LSBs. */

193  
194 
static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp, 
195 
unsigned int substr, unsigned int pos) 
196 
{ 
197 
SubStream *s = &m>substream[substr]; 
198 
unsigned int mat, channel; 
199  
200 
for (mat = 0; mat < s>num_primitive_matrices; mat++) 
201 
if (s>lsb_bypass[mat])

202 
m>bypassed_lsbs[pos + s>blockpos][mat] = get_bits1(gbp); 
203  
204 
for (channel = s>min_channel; channel <= s>max_channel; channel++) {

205 
ChannelParams *cp = &m>channel_params[channel]; 
206 
int codebook = cp>codebook;

207 
int quant_step_size = s>quant_step_size[channel];

208 
int lsb_bits = cp>huff_lsbs  quant_step_size;

209 
int result = 0; 
210  
211 
if (codebook > 0) 
212 
result = get_vlc2(gbp, huff_vlc[codebook1].table,

213 
VLC_BITS, (9 + VLC_BITS  1) / VLC_BITS); 
214  
215 
if (result < 0) 
216 
return 1; 
217  
218 
if (lsb_bits > 0) 
219 
result = (result << lsb_bits) + get_bits(gbp, lsb_bits); 
220  
221 
result += cp>sign_huff_offset; 
222 
result <<= quant_step_size; 
223  
224 
m>sample_buffer[pos + s>blockpos][channel] = result; 
225 
} 
226  
227 
return 0; 
228 
} 
229  
230 
static av_cold int mlp_decode_init(AVCodecContext *avctx) 
231 
{ 
232 
MLPDecodeContext *m = avctx>priv_data; 
233 
int substr;

234  
235 
init_static(); 
236 
m>avctx = avctx; 
237 
for (substr = 0; substr < MAX_SUBSTREAMS; substr++) 
238 
m>substream[substr].lossless_check_data = 0xffffffff;

239 
dsputil_init(&m>dsp, avctx); 
240  
241 
return 0; 
242 
} 
243  
244 
/** Read a major sync info header  contains high level information about

245 
* the stream  sample rate, channel arrangement etc. Most of this

246 
* information is not actually necessary for decoding, only for playback.

247 
*/

248  
249 
static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb) 
250 
{ 
251 
MLPHeaderInfo mh; 
252 
int substr;

253  
254 
if (ff_mlp_read_major_sync(m>avctx, &mh, gb) != 0) 
255 
return 1; 
256  
257 
if (mh.group1_bits == 0) { 
258 
av_log(m>avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");

259 
return 1; 
260 
} 
261 
if (mh.group2_bits > mh.group1_bits) {

262 
av_log(m>avctx, AV_LOG_ERROR, 
263 
"Channel group 2 cannot have more bits per sample than group 1.\n");

264 
return 1; 
265 
} 
266  
267 
if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {

268 
av_log(m>avctx, AV_LOG_ERROR, 
269 
"Channel groups with differing sample rates are not currently supported.\n");

270 
return 1; 
271 
} 
272  
273 
if (mh.group1_samplerate == 0) { 
274 
av_log(m>avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");

275 
return 1; 
276 
} 
277 
if (mh.group1_samplerate > MAX_SAMPLERATE) {

278 
av_log(m>avctx, AV_LOG_ERROR, 
279 
"Sampling rate %d is greater than the supported maximum (%d).\n",

280 
mh.group1_samplerate, MAX_SAMPLERATE); 
281 
return 1; 
282 
} 
283 
if (mh.access_unit_size > MAX_BLOCKSIZE) {

284 
av_log(m>avctx, AV_LOG_ERROR, 
285 
"Block size %d is greater than the supported maximum (%d).\n",

286 
mh.access_unit_size, MAX_BLOCKSIZE); 
287 
return 1; 
288 
} 
289 
if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {

290 
av_log(m>avctx, AV_LOG_ERROR, 
291 
"Block size pow2 %d is greater than the supported maximum (%d).\n",

292 
mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2); 
293 
return 1; 
294 
} 
295  
296 
if (mh.num_substreams == 0) 
297 
return 1; 
298 
if (m>avctx>codec_id == CODEC_ID_MLP && mh.num_substreams > 2) { 
299 
av_log(m>avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");

300 
return 1; 
301 
} 
302 
if (mh.num_substreams > MAX_SUBSTREAMS) {

303 
av_log(m>avctx, AV_LOG_ERROR, 
304 
"Number of substreams %d is larger than the maximum supported "

305 
"by the decoder. %s\n", mh.num_substreams, sample_message);

306 
return 1; 
307 
} 
308  
309 
m>access_unit_size = mh.access_unit_size; 
310 
m>access_unit_size_pow2 = mh.access_unit_size_pow2; 
311  
312 
m>num_substreams = mh.num_substreams; 
313 
m>max_decoded_substream = m>num_substreams  1;

314  
315 
m>avctx>sample_rate = mh.group1_samplerate; 
316 
m>avctx>frame_size = mh.access_unit_size; 
317  
318 
m>avctx>bits_per_raw_sample = mh.group1_bits; 
319 
if (mh.group1_bits > 16) 
320 
m>avctx>sample_fmt = SAMPLE_FMT_S32; 
321 
else

322 
m>avctx>sample_fmt = SAMPLE_FMT_S16; 
323  
324 
m>params_valid = 1;

325 
for (substr = 0; substr < MAX_SUBSTREAMS; substr++) 
326 
m>substream[substr].restart_seen = 0;

327  
328 
return 0; 
329 
} 
330  
331 
/** Read a restart header from a block in a substream. This contains parameters

332 
* required to decode the audio that do not change very often. Generally

333 
* (always) present only in blocks following a major sync. */

334  
335 
static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp, 
336 
const uint8_t *buf, unsigned int substr) 
337 
{ 
338 
SubStream *s = &m>substream[substr]; 
339 
unsigned int ch; 
340 
int sync_word, tmp;

341 
uint8_t checksum; 
342 
uint8_t lossless_check; 
343 
int start_count = get_bits_count(gbp);

344 
const int max_matrix_channel = m>avctx>codec_id == CODEC_ID_MLP 
345 
? MAX_MATRIX_CHANNEL_MLP 
346 
: MAX_MATRIX_CHANNEL_TRUEHD; 
347  
348 
sync_word = get_bits(gbp, 13);

349  
350 
if (sync_word != 0x31ea >> 1) { 
351 
av_log(m>avctx, AV_LOG_ERROR, 
352 
"restart header sync incorrect (got 0x%04x)\n", sync_word);

353 
return 1; 
354 
} 
355  
356 
s>noise_type = get_bits1(gbp); 
357  
358 
if (m>avctx>codec_id == CODEC_ID_MLP && s>noise_type) {

359 
av_log(m>avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");

360 
return 1; 
361 
} 
362  
363 
skip_bits(gbp, 16); /* Output timestamp */ 
364  
365 
s>min_channel = get_bits(gbp, 4);

366 
s>max_channel = get_bits(gbp, 4);

367 
s>max_matrix_channel = get_bits(gbp, 4);

368  
369 
if (s>max_matrix_channel > max_matrix_channel) {

370 
av_log(m>avctx, AV_LOG_ERROR, 
371 
"Max matrix channel cannot be greater than %d.\n",

372 
max_matrix_channel); 
373 
return 1; 
374 
} 
375  
376 
if (s>max_channel != s>max_matrix_channel) {

377 
av_log(m>avctx, AV_LOG_ERROR, 
378 
"Max channel must be equal max matrix channel.\n");

379 
return 1; 
380 
} 
381  
382 
/* This should happen for TrueHD streams with >6 channels and MLP's noise

383 
* type. It is not yet known if this is allowed. */

384 
if (s>max_channel > MAX_MATRIX_CHANNEL_MLP && !s>noise_type) {

385 
av_log(m>avctx, AV_LOG_ERROR, 
386 
"Number of channels %d is larger than the maximum supported "

387 
"by the decoder. %s\n", s>max_channel+2, sample_message); 
388 
return 1; 
389 
} 
390  
391 
if (s>min_channel > s>max_channel) {

392 
av_log(m>avctx, AV_LOG_ERROR, 
393 
"Substream min channel cannot be greater than max channel.\n");

394 
return 1; 
395 
} 
396  
397 
if (m>avctx>request_channels > 0 
398 
&& s>max_channel + 1 >= m>avctx>request_channels

399 
&& substr < m>max_decoded_substream) { 
400 
av_log(m>avctx, AV_LOG_DEBUG, 
401 
"Extracting %d channel downmix from substream %d. "

402 
"Further substreams will be skipped.\n",

403 
s>max_channel + 1, substr);

404 
m>max_decoded_substream = substr; 
405 
} 
406  
407 
s>noise_shift = get_bits(gbp, 4);

408 
s>noisegen_seed = get_bits(gbp, 23);

409  
410 
skip_bits(gbp, 19);

411  
412 
s>data_check_present = get_bits1(gbp); 
413 
lossless_check = get_bits(gbp, 8);

414 
if (substr == m>max_decoded_substream

415 
&& s>lossless_check_data != 0xffffffff) {

416 
tmp = xor_32_to_8(s>lossless_check_data); 
417 
if (tmp != lossless_check)

418 
av_log(m>avctx, AV_LOG_WARNING, 
419 
"Lossless check failed  expected %02x, calculated %02x.\n",

420 
lossless_check, tmp); 
421 
} 
422  
423 
skip_bits(gbp, 16);

424  
425 
memset(s>ch_assign, 0, sizeof(s>ch_assign)); 
426  
427 
for (ch = 0; ch <= s>max_matrix_channel; ch++) { 
428 
int ch_assign = get_bits(gbp, 6); 
429 
if (ch_assign > s>max_matrix_channel) {

430 
av_log(m>avctx, AV_LOG_ERROR, 
431 
"Assignment of matrix channel %d to invalid output channel %d. %s\n",

432 
ch, ch_assign, sample_message); 
433 
return 1; 
434 
} 
435 
s>ch_assign[ch_assign] = ch; 
436 
} 
437  
438 
checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp)  start_count); 
439  
440 
if (checksum != get_bits(gbp, 8)) 
441 
av_log(m>avctx, AV_LOG_ERROR, "restart header checksum error\n");

442  
443 
/* Set default decoding parameters. */

444 
s>param_presence_flags = 0xff;

445 
s>num_primitive_matrices = 0;

446 
s>blocksize = 8;

447 
s>lossless_check_data = 0;

448  
449 
memset(s>output_shift , 0, sizeof(s>output_shift )); 
450 
memset(s>quant_step_size, 0, sizeof(s>quant_step_size)); 
451  
452 
for (ch = s>min_channel; ch <= s>max_channel; ch++) {

453 
ChannelParams *cp = &m>channel_params[ch]; 
454 
cp>filter_params[FIR].order = 0;

455 
cp>filter_params[IIR].order = 0;

456 
cp>filter_params[FIR].shift = 0;

457 
cp>filter_params[IIR].shift = 0;

458  
459 
/* Default audio coding is 24bit raw PCM. */

460 
cp>huff_offset = 0;

461 
cp>sign_huff_offset = (1) << 23; 
462 
cp>codebook = 0;

463 
cp>huff_lsbs = 24;

464 
} 
465  
466 
if (substr == m>max_decoded_substream)

467 
m>avctx>channels = s>max_matrix_channel + 1;

468  
469 
return 0; 
470 
} 
471  
472 
/** Read parameters for one of the prediction filters. */

473  
474 
static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp, 
475 
unsigned int channel, unsigned int filter) 
476 
{ 
477 
FilterParams *fp = &m>channel_params[channel].filter_params[filter]; 
478 
const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER; 
479 
const char fchar = filter ? 'I' : 'F'; 
480 
int i, order;

481  
482 
// Filter is 0 for FIR, 1 for IIR.

483 
assert(filter < 2);

484  
485 
if (m>filter_changed[channel][filter]++ > 1) { 
486 
av_log(m>avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");

487 
return 1; 
488 
} 
489  
490 
order = get_bits(gbp, 4);

491 
if (order > max_order) {

492 
av_log(m>avctx, AV_LOG_ERROR, 
493 
"%cIR filter order %d is greater than maximum %d.\n",

494 
fchar, order, max_order); 
495 
return 1; 
496 
} 
497 
fp>order = order; 
498  
499 
if (order > 0) { 
500 
int32_t *fcoeff = m>channel_params[channel].coeff[filter]; 
501 
int coeff_bits, coeff_shift;

502  
503 
fp>shift = get_bits(gbp, 4);

504  
505 
coeff_bits = get_bits(gbp, 5);

506 
coeff_shift = get_bits(gbp, 3);

507 
if (coeff_bits < 1  coeff_bits > 16) { 
508 
av_log(m>avctx, AV_LOG_ERROR, 
509 
"%cIR filter coeff_bits must be between 1 and 16.\n",

510 
fchar); 
511 
return 1; 
512 
} 
513 
if (coeff_bits + coeff_shift > 16) { 
514 
av_log(m>avctx, AV_LOG_ERROR, 
515 
"Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",

516 
fchar); 
517 
return 1; 
518 
} 
519  
520 
for (i = 0; i < order; i++) 
521 
fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift; 
522  
523 
if (get_bits1(gbp)) {

524 
int state_bits, state_shift;

525  
526 
if (filter == FIR) {

527 
av_log(m>avctx, AV_LOG_ERROR, 
528 
"FIR filter has state data specified.\n");

529 
return 1; 
530 
} 
531  
532 
state_bits = get_bits(gbp, 4);

533 
state_shift = get_bits(gbp, 4);

534  
535 
/* TODO: Check validity of state data. */

536  
537 
for (i = 0; i < order; i++) 
538 
fp>state[i] = get_sbits(gbp, state_bits) << state_shift; 
539 
} 
540 
} 
541  
542 
return 0; 
543 
} 
544  
545 
/** Read parameters for primitive matrices. */

546  
547 
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp) 
548 
{ 
549 
SubStream *s = &m>substream[substr]; 
550 
unsigned int mat, ch; 
551 
const int max_primitive_matrices = m>avctx>codec_id == CODEC_ID_MLP 
552 
? MAX_MATRICES_MLP 
553 
: MAX_MATRICES_TRUEHD; 
554  
555 
if (m>matrix_changed++ > 1) { 
556 
av_log(m>avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");

557 
return 1; 
558 
} 
559  
560 
s>num_primitive_matrices = get_bits(gbp, 4);

561  
562 
if (s>num_primitive_matrices > max_primitive_matrices) {

563 
av_log(m>avctx, AV_LOG_ERROR, 
564 
"Number of primitive matrices cannot be greater than %d.\n",

565 
max_primitive_matrices); 
566 
return 1; 
567 
} 
568  
569 
for (mat = 0; mat < s>num_primitive_matrices; mat++) { 
570 
int frac_bits, max_chan;

571 
s>matrix_out_ch[mat] = get_bits(gbp, 4);

572 
frac_bits = get_bits(gbp, 4);

573 
s>lsb_bypass [mat] = get_bits1(gbp); 
574  
575 
if (s>matrix_out_ch[mat] > s>max_matrix_channel) {

576 
av_log(m>avctx, AV_LOG_ERROR, 
577 
"Invalid channel %d specified as output from matrix.\n",

578 
s>matrix_out_ch[mat]); 
579 
return 1; 
580 
} 
581 
if (frac_bits > 14) { 
582 
av_log(m>avctx, AV_LOG_ERROR, 
583 
"Too many fractional bits specified.\n");

584 
return 1; 
585 
} 
586  
587 
max_chan = s>max_matrix_channel; 
588 
if (!s>noise_type)

589 
max_chan+=2;

590  
591 
for (ch = 0; ch <= max_chan; ch++) { 
592 
int coeff_val = 0; 
593 
if (get_bits1(gbp))

594 
coeff_val = get_sbits(gbp, frac_bits + 2);

595  
596 
s>matrix_coeff[mat][ch] = coeff_val << (14  frac_bits);

597 
} 
598  
599 
if (s>noise_type)

600 
s>matrix_noise_shift[mat] = get_bits(gbp, 4);

601 
else

602 
s>matrix_noise_shift[mat] = 0;

603 
} 
604  
605 
return 0; 
606 
} 
607  
608 
/** Read channel parameters. */

609  
610 
static int read_channel_params(MLPDecodeContext *m, unsigned int substr, 
611 
GetBitContext *gbp, unsigned int ch) 
612 
{ 
613 
ChannelParams *cp = &m>channel_params[ch]; 
614 
FilterParams *fir = &cp>filter_params[FIR]; 
615 
FilterParams *iir = &cp>filter_params[IIR]; 
616 
SubStream *s = &m>substream[substr]; 
617  
618 
if (s>param_presence_flags & PARAM_FIR)

619 
if (get_bits1(gbp))

620 
if (read_filter_params(m, gbp, ch, FIR) < 0) 
621 
return 1; 
622  
623 
if (s>param_presence_flags & PARAM_IIR)

624 
if (get_bits1(gbp))

625 
if (read_filter_params(m, gbp, ch, IIR) < 0) 
626 
return 1; 
627  
628 
if (fir>order + iir>order > 8) { 
629 
av_log(m>avctx, AV_LOG_ERROR, "Total filter orders too high.\n");

630 
return 1; 
631 
} 
632  
633 
if (fir>order && iir>order &&

634 
fir>shift != iir>shift) { 
635 
av_log(m>avctx, AV_LOG_ERROR, 
636 
"FIR and IIR filters must use the same precision.\n");

637 
return 1; 
638 
} 
639 
/* The FIR and IIR filters must have the same precision.

640 
* To simplify the filtering code, only the precision of the

641 
* FIR filter is considered. If only the IIR filter is employed,

642 
* the FIR filter precision is set to that of the IIR filter, so

643 
* that the filtering code can use it. */

644 
if (!fir>order && iir>order)

645 
fir>shift = iir>shift; 
646  
647 
if (s>param_presence_flags & PARAM_HUFFOFFSET)

648 
if (get_bits1(gbp))

649 
cp>huff_offset = get_sbits(gbp, 15);

650  
651 
cp>codebook = get_bits(gbp, 2);

652 
cp>huff_lsbs = get_bits(gbp, 5);

653  
654 
if (cp>huff_lsbs > 24) { 
655 
av_log(m>avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");

656 
return 1; 
657 
} 
658  
659 
cp>sign_huff_offset = calculate_sign_huff(m, substr, ch); 
660  
661 
return 0; 
662 
} 
663  
664 
/** Read decoding parameters that change more often than those in the restart

665 
* header. */

666  
667 
static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp, 
668 
unsigned int substr) 
669 
{ 
670 
SubStream *s = &m>substream[substr]; 
671 
unsigned int ch; 
672  
673 
if (s>param_presence_flags & PARAM_PRESENCE)

674 
if (get_bits1(gbp))

675 
s>param_presence_flags = get_bits(gbp, 8);

676  
677 
if (s>param_presence_flags & PARAM_BLOCKSIZE)

678 
if (get_bits1(gbp)) {

679 
s>blocksize = get_bits(gbp, 9);

680 
if (s>blocksize < 8  s>blocksize > m>access_unit_size) { 
681 
av_log(m>avctx, AV_LOG_ERROR, "Invalid blocksize.");

682 
s>blocksize = 0;

683 
return 1; 
684 
} 
685 
} 
686  
687 
if (s>param_presence_flags & PARAM_MATRIX)

688 
if (get_bits1(gbp))

689 
if (read_matrix_params(m, substr, gbp) < 0) 
690 
return 1; 
691  
692 
if (s>param_presence_flags & PARAM_OUTSHIFT)

693 
if (get_bits1(gbp))

694 
for (ch = 0; ch <= s>max_matrix_channel; ch++) 
695 
s>output_shift[ch] = get_sbits(gbp, 4);

696  
697 
if (s>param_presence_flags & PARAM_QUANTSTEP)

698 
if (get_bits1(gbp))

699 
for (ch = 0; ch <= s>max_channel; ch++) { 
700 
ChannelParams *cp = &m>channel_params[ch]; 
701  
702 
s>quant_step_size[ch] = get_bits(gbp, 4);

703  
704 
cp>sign_huff_offset = calculate_sign_huff(m, substr, ch); 
705 
} 
706  
707 
for (ch = s>min_channel; ch <= s>max_channel; ch++)

708 
if (get_bits1(gbp))

709 
if (read_channel_params(m, substr, gbp, ch) < 0) 
710 
return 1; 
711  
712 
return 0; 
713 
} 
714  
715 
#define MSB_MASK(bits) (1u << bits) 
716  
717 
/** Generate PCM samples using the prediction filters and residual values

718 
* read from the data stream, and update the filter state. */

719  
720 
static void filter_channel(MLPDecodeContext *m, unsigned int substr, 
721 
unsigned int channel) 
722 
{ 
723 
SubStream *s = &m>substream[substr]; 
724 
const int32_t *fircoeff = m>channel_params[channel].coeff[FIR];

725 
int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER]; 
726 
int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE; 
727 
int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE; 
728 
FilterParams *fir = &m>channel_params[channel].filter_params[FIR]; 
729 
FilterParams *iir = &m>channel_params[channel].filter_params[IIR]; 
730 
unsigned int filter_shift = fir>shift; 
731 
int32_t mask = MSB_MASK(s>quant_step_size[channel]); 
732  
733 
memcpy(firbuf, fir>state, MAX_FIR_ORDER * sizeof(int32_t));

734 
memcpy(iirbuf, iir>state, MAX_IIR_ORDER * sizeof(int32_t));

735  
736 
m>dsp.mlp_filter_channel(firbuf, fircoeff, 
737 
fir>order, iir>order, 
738 
filter_shift, mask, s>blocksize, 
739 
&m>sample_buffer[s>blockpos][channel]); 
740  
741 
memcpy(fir>state, firbuf  s>blocksize, MAX_FIR_ORDER * sizeof(int32_t));

742 
memcpy(iir>state, iirbuf  s>blocksize, MAX_IIR_ORDER * sizeof(int32_t));

743 
} 
744  
745 
/** Read a block of PCM residual data (or actual if no filtering active). */

746  
747 
static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp, 
748 
unsigned int substr) 
749 
{ 
750 
SubStream *s = &m>substream[substr]; 
751 
unsigned int i, ch, expected_stream_pos = 0; 
752  
753 
if (s>data_check_present) {

754 
expected_stream_pos = get_bits_count(gbp); 
755 
expected_stream_pos += get_bits(gbp, 16);

756 
av_log(m>avctx, AV_LOG_WARNING, "This file contains some features "

757 
"we have not tested yet. %s\n", sample_message);

758 
} 
759  
760 
if (s>blockpos + s>blocksize > m>access_unit_size) {

761 
av_log(m>avctx, AV_LOG_ERROR, "too many audio samples in frame\n");

762 
return 1; 
763 
} 
764  
765 
memset(&m>bypassed_lsbs[s>blockpos][0], 0, 
766 
s>blocksize * sizeof(m>bypassed_lsbs[0])); 
767  
768 
for (i = 0; i < s>blocksize; i++) 
769 
if (read_huff_channels(m, gbp, substr, i) < 0) 
770 
return 1; 
771  
772 
for (ch = s>min_channel; ch <= s>max_channel; ch++)

773 
filter_channel(m, substr, ch); 
774  
775 
s>blockpos += s>blocksize; 
776  
777 
if (s>data_check_present) {

778 
if (get_bits_count(gbp) != expected_stream_pos)

779 
av_log(m>avctx, AV_LOG_ERROR, "block data length mismatch\n");

780 
skip_bits(gbp, 8);

781 
} 
782  
783 
return 0; 
784 
} 
785  
786 
/** Data table used for TrueHD noise generation function. */

787  
788 
static const int8_t noise_table[256] = { 
789 
30, 51, 22, 54, 3, 7, 4, 38, 14, 55, 46, 81, 22, 58, 3, 2, 
790 
52, 31, 7, 51, 15, 44, 74, 30, 85, 17, 10, 33, 18, 80, 28, 62, 
791 
10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, 2, 5, 
792 
51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40, 
793 
38, 16, 10, 28, 92, 22, 18, 29, 10, 5, 13, 49, 19, 24, 70, 34, 
794 
61, 48, 30, 14, 6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30, 
795 
67, 44, 9, 50, 11, 43, 40, 32, 59, 82, 13, 49, 14, 55, 60, 36, 
796 
48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, 2, 84, 69, 
797 
0, 72, 37, 57, 27, 41, 15, 16, 35, 31, 14, 61, 24, 0, 27, 24, 
798 
16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, 20, 8, 20, 
799 
13, 28, 3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, 23, 
800 
89, 18, 74, 21, 38, 12, 19, 12, 19, 8, 15, 33, 4, 57, 9, 8, 
801 
36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40, 
802 
39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, 1, 32, 37, 
803 
45, 5, 53, 6, 7, 36, 50, 23, 6, 32, 9, 21, 18, 71, 27, 52, 
804 
25, 31, 35, 42, 1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70, 
805 
}; 
806  
807 
/** Noise generation functions.

808 
* I'm not sure what these are for  they seem to be some kind of pseudorandom

809 
* sequence generators, used to generate noise data which is used when the

810 
* channels are rematrixed. I'm not sure if they provide a practical benefit

811 
* to compression, or just obfuscate the decoder. Are they for some kind of

812 
* dithering? */

813  
814 
/** Generate two channels of noise, used in the matrix when

815 
* restart sync word == 0x31ea. */

816  
817 
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr) 
818 
{ 
819 
SubStream *s = &m>substream[substr]; 
820 
unsigned int i; 
821 
uint32_t seed = s>noisegen_seed; 
822 
unsigned int maxchan = s>max_matrix_channel; 
823  
824 
for (i = 0; i < s>blockpos; i++) { 
825 
uint16_t seed_shr7 = seed >> 7;

826 
m>sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s>noise_shift; 
827 
m>sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s>noise_shift;

828  
829 
seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5); 
830 
} 
831  
832 
s>noisegen_seed = seed; 
833 
} 
834  
835 
/** Generate a block of noise, used when restart sync word == 0x31eb. */

836  
837 
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr) 
838 
{ 
839 
SubStream *s = &m>substream[substr]; 
840 
unsigned int i; 
841 
uint32_t seed = s>noisegen_seed; 
842  
843 
for (i = 0; i < m>access_unit_size_pow2; i++) { 
844 
uint8_t seed_shr15 = seed >> 15;

845 
m>noise_buffer[i] = noise_table[seed_shr15]; 
846 
seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5); 
847 
} 
848  
849 
s>noisegen_seed = seed; 
850 
} 
851  
852  
853 
/** Apply the channel matrices in turn to reconstruct the original audio

854 
* samples. */

855  
856 
static void rematrix_channels(MLPDecodeContext *m, unsigned int substr) 
857 
{ 
858 
SubStream *s = &m>substream[substr]; 
859 
unsigned int mat, src_ch, i; 
860 
unsigned int maxchan; 
861  
862 
maxchan = s>max_matrix_channel; 
863 
if (!s>noise_type) {

864 
generate_2_noise_channels(m, substr); 
865 
maxchan += 2;

866 
} else {

867 
fill_noise_buffer(m, substr); 
868 
} 
869  
870 
for (mat = 0; mat < s>num_primitive_matrices; mat++) { 
871 
int matrix_noise_shift = s>matrix_noise_shift[mat];

872 
unsigned int dest_ch = s>matrix_out_ch[mat]; 
873 
int32_t mask = MSB_MASK(s>quant_step_size[dest_ch]); 
874 
int32_t *coeffs = s>matrix_coeff[mat]; 
875 
int index = s>num_primitive_matrices  mat;

876 
int index2 = 2 * index + 1; 
877  
878 
/* TODO: DSPContext? */

879  
880 
for (i = 0; i < s>blockpos; i++) { 
881 
int32_t bypassed_lsb = m>bypassed_lsbs[i][mat]; 
882 
int32_t *samples = m>sample_buffer[i]; 
883 
int64_t accum = 0;

884  
885 
for (src_ch = 0; src_ch <= maxchan; src_ch++) 
886 
accum += (int64_t) samples[src_ch] * coeffs[src_ch]; 
887  
888 
if (matrix_noise_shift) {

889 
index &= m>access_unit_size_pow2  1;

890 
accum += m>noise_buffer[index] << (matrix_noise_shift + 7);

891 
index += index2; 
892 
} 
893  
894 
samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;

895 
} 
896 
} 
897 
} 
898  
899 
/** Write the audio data into the output buffer. */

900  
901 
static int output_data_internal(MLPDecodeContext *m, unsigned int substr, 
902 
uint8_t *data, unsigned int *data_size, int is32) 
903 
{ 
904 
SubStream *s = &m>substream[substr]; 
905 
unsigned int i, out_ch = 0; 
906 
int32_t *data_32 = (int32_t*) data; 
907 
int16_t *data_16 = (int16_t*) data; 
908  
909 
if (*data_size < (s>max_channel + 1) * s>blockpos * (is32 ? 4 : 2)) 
910 
return 1; 
911  
912 
for (i = 0; i < s>blockpos; i++) { 
913 
for (out_ch = 0; out_ch <= s>max_matrix_channel; out_ch++) { 
914 
int mat_ch = s>ch_assign[out_ch];

915 
int32_t sample = m>sample_buffer[i][mat_ch] 
916 
<< s>output_shift[mat_ch]; 
917 
s>lossless_check_data ^= (sample & 0xffffff) << mat_ch;

918 
if (is32) *data_32++ = sample << 8; 
919 
else *data_16++ = sample >> 8; 
920 
} 
921 
} 
922  
923 
*data_size = i * out_ch * (is32 ? 4 : 2); 
924  
925 
return 0; 
926 
} 
927  
928 
static int output_data(MLPDecodeContext *m, unsigned int substr, 
929 
uint8_t *data, unsigned int *data_size) 
930 
{ 
931 
if (m>avctx>sample_fmt == SAMPLE_FMT_S32)

932 
return output_data_internal(m, substr, data, data_size, 1); 
933 
else

934 
return output_data_internal(m, substr, data, data_size, 0); 
935 
} 
936  
937  
938 
/** Read an access unit from the stream.

939 
* Returns < 0 on error, 0 if not enough data is present in the input stream

940 
* otherwise returns the number of bytes consumed. */

941  
942 
static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size, 
943 
AVPacket *avpkt) 
944 
{ 
945 
const uint8_t *buf = avpkt>data;

946 
int buf_size = avpkt>size;

947 
MLPDecodeContext *m = avctx>priv_data; 
948 
GetBitContext gb; 
949 
unsigned int length, substr; 
950 
unsigned int substream_start; 
951 
unsigned int header_size = 4; 
952 
unsigned int substr_header_size = 0; 
953 
uint8_t substream_parity_present[MAX_SUBSTREAMS]; 
954 
uint16_t substream_data_len[MAX_SUBSTREAMS]; 
955 
uint8_t parity_bits; 
956  
957 
if (buf_size < 4) 
958 
return 0; 
959  
960 
length = (AV_RB16(buf) & 0xfff) * 2; 
961  
962 
if (length < 4  length > buf_size) 
963 
return 1; 
964  
965 
init_get_bits(&gb, (buf + 4), (length  4) * 8); 
966  
967 
m>is_major_sync_unit = 0;

968 
if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) { 
969 
if (read_major_sync(m, &gb) < 0) 
970 
goto error;

971 
m>is_major_sync_unit = 1;

972 
header_size += 28;

973 
} 
974  
975 
if (!m>params_valid) {

976 
av_log(m>avctx, AV_LOG_WARNING, 
977 
"Stream parameters not seen; skipping frame.\n");

978 
*data_size = 0;

979 
return length;

980 
} 
981  
982 
substream_start = 0;

983  
984 
for (substr = 0; substr < m>num_substreams; substr++) { 
985 
int extraword_present, checkdata_present, end, nonrestart_substr;

986  
987 
extraword_present = get_bits1(&gb); 
988 
nonrestart_substr = get_bits1(&gb); 
989 
checkdata_present = get_bits1(&gb); 
990 
skip_bits1(&gb); 
991  
992 
end = get_bits(&gb, 12) * 2; 
993  
994 
substr_header_size += 2;

995  
996 
if (extraword_present) {

997 
if (m>avctx>codec_id == CODEC_ID_MLP) {

998 
av_log(m>avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");

999 
goto error;

1000 
} 
1001 
skip_bits(&gb, 16);

1002 
substr_header_size += 2;

1003 
} 
1004  
1005 
if (!(nonrestart_substr ^ m>is_major_sync_unit)) {

1006 
av_log(m>avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");

1007 
goto error;

1008 
} 
1009  
1010 
if (end + header_size + substr_header_size > length) {

1011 
av_log(m>avctx, AV_LOG_ERROR, 
1012 
"Indicated length of substream %d data goes off end of "

1013 
"packet.\n", substr);

1014 
end = length  header_size  substr_header_size; 
1015 
} 
1016  
1017 
if (end < substream_start) {

1018 
av_log(avctx, AV_LOG_ERROR, 
1019 
"Indicated end offset of substream %d data "

1020 
"is smaller than calculated start offset.\n",

1021 
substr); 
1022 
goto error;

1023 
} 
1024  
1025 
if (substr > m>max_decoded_substream)

1026 
continue;

1027  
1028 
substream_parity_present[substr] = checkdata_present; 
1029 
substream_data_len[substr] = end  substream_start; 
1030 
substream_start = end; 
1031 
} 
1032  
1033 
parity_bits = ff_mlp_calculate_parity(buf, 4);

1034 
parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size); 
1035  
1036 
if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) { 
1037 
av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");

1038 
goto error;

1039 
} 
1040  
1041 
buf += header_size + substr_header_size; 
1042  
1043 
for (substr = 0; substr <= m>max_decoded_substream; substr++) { 
1044 
SubStream *s = &m>substream[substr]; 
1045 
init_get_bits(&gb, buf, substream_data_len[substr] * 8);

1046  
1047 
m>matrix_changed = 0;

1048 
memset(m>filter_changed, 0, sizeof(m>filter_changed)); 
1049  
1050 
s>blockpos = 0;

1051 
do {

1052 
if (get_bits1(&gb)) {

1053 
if (get_bits1(&gb)) {

1054 
/* A restart header should be present. */

1055 
if (read_restart_header(m, &gb, buf, substr) < 0) 
1056 
goto next_substr;

1057 
s>restart_seen = 1;

1058 
} 
1059  
1060 
if (!s>restart_seen)

1061 
goto next_substr;

1062 
if (read_decoding_params(m, &gb, substr) < 0) 
1063 
goto next_substr;

1064 
} 
1065  
1066 
if (!s>restart_seen)

1067 
goto next_substr;

1068  
1069 
if (read_block_data(m, &gb, substr) < 0) 
1070 
return 1; 
1071  
1072 
if (get_bits_count(&gb) >= substream_data_len[substr] * 8) 
1073 
goto substream_length_mismatch;

1074  
1075 
} while (!get_bits1(&gb));

1076  
1077 
skip_bits(&gb, (get_bits_count(&gb)) & 15);

1078  
1079 
if (substream_data_len[substr] * 8  get_bits_count(&gb) >= 32) { 
1080 
int shorten_by;

1081  
1082 
if (get_bits(&gb, 16) != 0xD234) 
1083 
return 1; 
1084  
1085 
shorten_by = get_bits(&gb, 16);

1086 
if (m>avctx>codec_id == CODEC_ID_TRUEHD && shorten_by & 0x2000) 
1087 
s>blockpos = FFMIN(shorten_by & 0x1FFF, s>blockpos);

1088 
else if (m>avctx>codec_id == CODEC_ID_MLP && shorten_by != 0xD234) 
1089 
return 1; 
1090  
1091 
if (substr == m>max_decoded_substream)

1092 
av_log(m>avctx, AV_LOG_INFO, "End of stream indicated.\n");

1093 
} 
1094  
1095 
if (substream_parity_present[substr]) {

1096 
uint8_t parity, checksum; 
1097  
1098 
if (substream_data_len[substr] * 8  get_bits_count(&gb) != 16) 
1099 
goto substream_length_mismatch;

1100  
1101 
parity = ff_mlp_calculate_parity(buf, substream_data_len[substr]  2);

1102 
checksum = ff_mlp_checksum8 (buf, substream_data_len[substr]  2);

1103  
1104 
if ((get_bits(&gb, 8) ^ parity) != 0xa9 ) 
1105 
av_log(m>avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);

1106 
if ( get_bits(&gb, 8) != checksum) 
1107 
av_log(m>avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);

1108 
} 
1109  
1110 
if (substream_data_len[substr] * 8 != get_bits_count(&gb)) 
1111 
goto substream_length_mismatch;

1112  
1113 
next_substr:

1114 
if (!s>restart_seen)

1115 
av_log(m>avctx, AV_LOG_ERROR, 
1116 
"No restart header present in substream %d.\n", substr);

1117  
1118 
buf += substream_data_len[substr]; 
1119 
} 
1120  
1121 
rematrix_channels(m, m>max_decoded_substream); 
1122  
1123 
if (output_data(m, m>max_decoded_substream, data, data_size) < 0) 
1124 
return 1; 
1125  
1126 
return length;

1127  
1128 
substream_length_mismatch:

1129 
av_log(m>avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);

1130 
return 1; 
1131  
1132 
error:

1133 
m>params_valid = 0;

1134 
return 1; 
1135 
} 
1136  
1137 
AVCodec mlp_decoder = { 
1138 
"mlp",

1139 
AVMEDIA_TYPE_AUDIO, 
1140 
CODEC_ID_MLP, 
1141 
sizeof(MLPDecodeContext),

1142 
mlp_decode_init, 
1143 
NULL,

1144 
NULL,

1145 
read_access_unit, 
1146 
.long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),

1147 
}; 
1148  
1149 
#if CONFIG_TRUEHD_DECODER

1150 
AVCodec truehd_decoder = { 
1151 
"truehd",

1152 
AVMEDIA_TYPE_AUDIO, 
1153 
CODEC_ID_TRUEHD, 
1154 
sizeof(MLPDecodeContext),

1155 
mlp_decode_init, 
1156 
NULL,

1157 
NULL,

1158 
read_access_unit, 
1159 
.long_name = NULL_IF_CONFIG_SMALL("TrueHD"),

1160 
}; 
1161 
#endif /* CONFIG_TRUEHD_DECODER */ 