ffmpeg / libavcodec / mlpdec.c @ d3f126df
History  View  Annotate  Download (39.9 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

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 
//! Channel coding parameters for channels in the substream

66 
ChannelParams channel_params[MAX_CHANNELS]; 
67  
68 
//! The left shift applied to random noise in 0x31ea substreams.

69 
uint8_t noise_shift; 
70 
//! The current seed value for the pseudorandom noise generator(s).

71 
uint32_t noisegen_seed; 
72  
73 
//! Set if the substream contains extra info to check the size of VLC blocks.

74 
uint8_t data_check_present; 
75  
76 
//! Bitmask of which parameter sets are conveyed in a decoding parameter block.

77 
uint8_t param_presence_flags; 
78 
#define PARAM_BLOCKSIZE (1 << 7) 
79 
#define PARAM_MATRIX (1 << 6) 
80 
#define PARAM_OUTSHIFT (1 << 5) 
81 
#define PARAM_QUANTSTEP (1 << 4) 
82 
#define PARAM_FIR (1 << 3) 
83 
#define PARAM_IIR (1 << 2) 
84 
#define PARAM_HUFFOFFSET (1 << 1) 
85 
#define PARAM_PRESENCE (1 << 0) 
86 
//@}

87  
88 
//@{

89 
/** matrix data */

90  
91 
//! Number of matrices to be applied.

92 
uint8_t num_primitive_matrices; 
93  
94 
//! matrix output channel

95 
uint8_t matrix_out_ch[MAX_MATRICES]; 
96  
97 
//! Whether the LSBs of the matrix output are encoded in the bitstream.

98 
uint8_t lsb_bypass[MAX_MATRICES]; 
99 
//! Matrix coefficients, stored as 2.14 fixed point.

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

102 
uint8_t matrix_noise_shift[MAX_MATRICES]; 
103 
//@}

104  
105 
//! Left shift to apply to Huffmandecoded residuals.

106 
uint8_t quant_step_size[MAX_CHANNELS]; 
107  
108 
//! number of PCM samples in current audio block

109 
uint16_t blocksize; 
110 
//! Number of PCM samples decoded so far in this frame.

111 
uint16_t blockpos; 
112  
113 
//! Left shift to apply to decoded PCM values to get final 24bit output.

114 
int8_t output_shift[MAX_CHANNELS]; 
115  
116 
//! Running XOR of all output samples.

117 
int32_t lossless_check_data; 
118  
119 
} SubStream; 
120  
121 
typedef struct MLPDecodeContext { 
122 
AVCodecContext *avctx; 
123  
124 
//! Current access unit being read has a major sync.

125 
int is_major_sync_unit;

126  
127 
//! Set if a valid major sync block has been read. Otherwise no decoding is possible.

128 
uint8_t params_valid; 
129  
130 
//! Number of substreams contained within this stream.

131 
uint8_t num_substreams; 
132  
133 
//! Index of the last substream to decode  further substreams are skipped.

134 
uint8_t max_decoded_substream; 
135  
136 
//! Stream needs channel reordering to comply with FFmpeg's channel order

137 
uint8_t needs_reordering; 
138  
139 
//! number of PCM samples contained in each frame

140 
int access_unit_size;

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

142 
int access_unit_size_pow2;

143  
144 
SubStream substream[MAX_SUBSTREAMS]; 
145  
146 
int matrix_changed;

147 
int filter_changed[MAX_CHANNELS][NUM_FILTERS];

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

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

183 
int sign_shift = lsb_bits + (cp>codebook ? 2  cp>codebook : 1); 
184 
int32_t sign_huff_offset = cp>huff_offset; 
185  
186 
if (cp>codebook > 0) 
187 
sign_huff_offset = 7 << lsb_bits;

188  
189 
if (sign_shift >= 0) 
190 
sign_huff_offset = 1 << sign_shift;

191  
192 
return sign_huff_offset;

193 
} 
194  
195 
/** Read a sample, consisting of either, both or neither of entropycoded MSBs

196 
* and plain LSBs. */

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

206 
m>bypassed_lsbs[pos + s>blockpos][mat] = get_bits1(gbp); 
207  
208 
for (channel = s>min_channel; channel <= s>max_channel; channel++) {

209 
ChannelParams *cp = &s>channel_params[channel]; 
210 
int codebook = cp>codebook;

211 
int quant_step_size = s>quant_step_size[channel];

212 
int lsb_bits = cp>huff_lsbs  quant_step_size;

213 
int result = 0; 
214  
215 
if (codebook > 0) 
216 
result = get_vlc2(gbp, huff_vlc[codebook1].table,

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

238  
239 
init_static(); 
240 
m>avctx = avctx; 
241 
for (substr = 0; substr < MAX_SUBSTREAMS; substr++) 
242 
m>substream[substr].lossless_check_data = 0xffffffff;

243 
dsputil_init(&m>dsp, avctx); 
244  
245 
return 0; 
246 
} 
247  
248 
/** Read a major sync info header  contains high level information about

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

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

251 
*/

252  
253 
static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb) 
254 
{ 
255 
MLPHeaderInfo mh; 
256 
int substr;

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

263 
return 1; 
264 
} 
265 
if (mh.group2_bits > mh.group1_bits) {

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

268 
return 1; 
269 
} 
270  
271 
if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {

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

274 
return 1; 
275 
} 
276  
277 
if (mh.group1_samplerate == 0) { 
278 
av_log(m>avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");

279 
return 1; 
280 
} 
281 
if (mh.group1_samplerate > MAX_SAMPLERATE) {

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

284 
mh.group1_samplerate, MAX_SAMPLERATE); 
285 
return 1; 
286 
} 
287 
if (mh.access_unit_size > MAX_BLOCKSIZE) {

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

290 
mh.access_unit_size, MAX_BLOCKSIZE); 
291 
return 1; 
292 
} 
293 
if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {

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

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

304 
return 1; 
305 
} 
306 
if (mh.num_substreams > MAX_SUBSTREAMS) {

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

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

310 
return 1; 
311 
} 
312  
313 
m>access_unit_size = mh.access_unit_size; 
314 
m>access_unit_size_pow2 = mh.access_unit_size_pow2; 
315  
316 
m>num_substreams = mh.num_substreams; 
317 
m>max_decoded_substream = m>num_substreams  1;

318  
319 
m>avctx>sample_rate = mh.group1_samplerate; 
320 
m>avctx>frame_size = mh.access_unit_size; 
321  
322 
m>avctx>bits_per_raw_sample = mh.group1_bits; 
323 
if (mh.group1_bits > 16) 
324 
m>avctx>sample_fmt = AV_SAMPLE_FMT_S32; 
325 
else

326 
m>avctx>sample_fmt = AV_SAMPLE_FMT_S16; 
327  
328 
m>params_valid = 1;

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

331  
332 
if (mh.stream_type == 0xbb) { 
333 
/* MLP stream */

334 
m>avctx>channel_layout = ff_mlp_layout[mh.channels_mlp]; 
335 
} else { /* mh.stream_type == 0xba */ 
336 
/* TrueHD stream */

337 
if (mh.channels_thd_stream2) {

338 
m>avctx>channel_layout = ff_truehd_layout(mh.channels_thd_stream2); 
339 
} else {

340 
m>avctx>channel_layout = ff_truehd_layout(mh.channels_thd_stream1); 
341 
} 
342 
if (m>avctx>channels &&

343 
av_get_channel_layout_nb_channels(m>avctx>channel_layout) != m>avctx>channels) { 
344 
m>avctx>channel_layout = 0;

345 
av_log_ask_for_sample(m>avctx, "Unknown channel layout.");

346 
} 
347 
} 
348  
349 
m>needs_reordering = mh.channels_mlp >= 18 && mh.channels_mlp <= 20; 
350  
351 
return 0; 
352 
} 
353  
354 
/** Read a restart header from a block in a substream. This contains parameters

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

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

357  
358 
static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp, 
359 
const uint8_t *buf, unsigned int substr) 
360 
{ 
361 
SubStream *s = &m>substream[substr]; 
362 
unsigned int ch; 
363 
int sync_word, tmp;

364 
uint8_t checksum; 
365 
uint8_t lossless_check; 
366 
int start_count = get_bits_count(gbp);

367 
const int max_matrix_channel = m>avctx>codec_id == CODEC_ID_MLP 
368 
? MAX_MATRIX_CHANNEL_MLP 
369 
: MAX_MATRIX_CHANNEL_TRUEHD; 
370  
371 
sync_word = get_bits(gbp, 13);

372  
373 
if (sync_word != 0x31ea >> 1) { 
374 
av_log(m>avctx, AV_LOG_ERROR, 
375 
"restart header sync incorrect (got 0x%04x)\n", sync_word);

376 
return 1; 
377 
} 
378  
379 
s>noise_type = get_bits1(gbp); 
380  
381 
if (m>avctx>codec_id == CODEC_ID_MLP && s>noise_type) {

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

383 
return 1; 
384 
} 
385  
386 
skip_bits(gbp, 16); /* Output timestamp */ 
387  
388 
s>min_channel = get_bits(gbp, 4);

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

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

391  
392 
if (s>max_matrix_channel > max_matrix_channel) {

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

395 
max_matrix_channel); 
396 
return 1; 
397 
} 
398  
399 
if (s>max_channel != s>max_matrix_channel) {

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

402 
return 1; 
403 
} 
404  
405 
/* This should happen for TrueHD streams with >6 channels and MLP's noise

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

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

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

410 
"by the decoder. %s\n", s>max_channel+2, sample_message); 
411 
return 1; 
412 
} 
413  
414 
if (s>min_channel > s>max_channel) {

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

417 
return 1; 
418 
} 
419  
420 
if (m>avctx>request_channels > 0 
421 
&& s>max_channel + 1 >= m>avctx>request_channels

422 
&& substr < m>max_decoded_substream) { 
423 
av_log(m>avctx, AV_LOG_DEBUG, 
424 
"Extracting %d channel downmix from substream %d. "

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

426 
s>max_channel + 1, substr);

427 
m>max_decoded_substream = substr; 
428 
} 
429  
430 
s>noise_shift = get_bits(gbp, 4);

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

432  
433 
skip_bits(gbp, 19);

434  
435 
s>data_check_present = get_bits1(gbp); 
436 
lossless_check = get_bits(gbp, 8);

437 
if (substr == m>max_decoded_substream

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

439 
tmp = xor_32_to_8(s>lossless_check_data); 
440 
if (tmp != lossless_check)

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

443 
lossless_check, tmp); 
444 
} 
445  
446 
skip_bits(gbp, 16);

447  
448 
memset(s>ch_assign, 0, sizeof(s>ch_assign)); 
449  
450 
for (ch = 0; ch <= s>max_matrix_channel; ch++) { 
451 
int ch_assign = get_bits(gbp, 6); 
452 
if (ch_assign > s>max_matrix_channel) {

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

455 
ch, ch_assign, sample_message); 
456 
return 1; 
457 
} 
458 
s>ch_assign[ch_assign] = ch; 
459 
} 
460  
461 
if (m>avctx>codec_id == CODEC_ID_MLP && m>needs_reordering) {

462 
if (m>avctx>channel_layout == (AV_CH_LAYOUT_2_2AV_CH_LOW_FREQUENCY) 

463 
m>avctx>channel_layout == AV_CH_LAYOUT_5POINT0) { 
464 
int i = s>ch_assign[4]; 
465 
s>ch_assign[4] = s>ch_assign[3]; 
466 
s>ch_assign[3] = s>ch_assign[2]; 
467 
s>ch_assign[2] = i;

468 
} else if (m>avctx>channel_layout == AV_CH_LAYOUT_5POINT1) { 
469 
FFSWAP(int, s>ch_assign[2], s>ch_assign[4]); 
470 
FFSWAP(int, s>ch_assign[3], s>ch_assign[5]); 
471 
} 
472 
} 
473 
if (m>avctx>codec_id == CODEC_ID_TRUEHD &&

474 
m>avctx>channel_layout == AV_CH_LAYOUT_7POINT1) { 
475 
FFSWAP(int, s>ch_assign[4], s>ch_assign[6]); 
476 
FFSWAP(int, s>ch_assign[5], s>ch_assign[7]); 
477 
} 
478  
479 
checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp)  start_count); 
480  
481 
if (checksum != get_bits(gbp, 8)) 
482 
av_log(m>avctx, AV_LOG_ERROR, "restart header checksum error\n");

483  
484 
/* Set default decoding parameters. */

485 
s>param_presence_flags = 0xff;

486 
s>num_primitive_matrices = 0;

487 
s>blocksize = 8;

488 
s>lossless_check_data = 0;

489  
490 
memset(s>output_shift , 0, sizeof(s>output_shift )); 
491 
memset(s>quant_step_size, 0, sizeof(s>quant_step_size)); 
492  
493 
for (ch = s>min_channel; ch <= s>max_channel; ch++) {

494 
ChannelParams *cp = &s>channel_params[ch]; 
495 
cp>filter_params[FIR].order = 0;

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

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

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

499  
500 
/* Default audio coding is 24bit raw PCM. */

501 
cp>huff_offset = 0;

502 
cp>sign_huff_offset = (1) << 23; 
503 
cp>codebook = 0;

504 
cp>huff_lsbs = 24;

505 
} 
506  
507 
if (substr == m>max_decoded_substream)

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

509  
510 
return 0; 
511 
} 
512  
513 
/** Read parameters for one of the prediction filters. */

514  
515 
static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp, 
516 
unsigned int substr, unsigned int channel, 
517 
unsigned int filter) 
518 
{ 
519 
SubStream *s = &m>substream[substr]; 
520 
FilterParams *fp = &s>channel_params[channel].filter_params[filter]; 
521 
const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER; 
522 
const char fchar = filter ? 'I' : 'F'; 
523 
int i, order;

524  
525 
// Filter is 0 for FIR, 1 for IIR.

526 
assert(filter < 2);

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

530 
return 1; 
531 
} 
532  
533 
order = get_bits(gbp, 4);

534 
if (order > max_order) {

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

537 
fchar, order, max_order); 
538 
return 1; 
539 
} 
540 
fp>order = order; 
541  
542 
if (order > 0) { 
543 
int32_t *fcoeff = s>channel_params[channel].coeff[filter]; 
544 
int coeff_bits, coeff_shift;

545  
546 
fp>shift = get_bits(gbp, 4);

547  
548 
coeff_bits = get_bits(gbp, 5);

549 
coeff_shift = get_bits(gbp, 3);

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

553 
fchar); 
554 
return 1; 
555 
} 
556 
if (coeff_bits + coeff_shift > 16) { 
557 
av_log(m>avctx, AV_LOG_ERROR, 
558 
"Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",

559 
fchar); 
560 
return 1; 
561 
} 
562  
563 
for (i = 0; i < order; i++) 
564 
fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift; 
565  
566 
if (get_bits1(gbp)) {

567 
int state_bits, state_shift;

568  
569 
if (filter == FIR) {

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

572 
return 1; 
573 
} 
574  
575 
state_bits = get_bits(gbp, 4);

576 
state_shift = get_bits(gbp, 4);

577  
578 
/* TODO: Check validity of state data. */

579  
580 
for (i = 0; i < order; i++) 
581 
fp>state[i] = get_sbits(gbp, state_bits) << state_shift; 
582 
} 
583 
} 
584  
585 
return 0; 
586 
} 
587  
588 
/** Read parameters for primitive matrices. */

589  
590 
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp) 
591 
{ 
592 
SubStream *s = &m>substream[substr]; 
593 
unsigned int mat, ch; 
594 
const int max_primitive_matrices = m>avctx>codec_id == CODEC_ID_MLP 
595 
? MAX_MATRICES_MLP 
596 
: MAX_MATRICES_TRUEHD; 
597  
598 
if (m>matrix_changed++ > 1) { 
599 
av_log(m>avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");

600 
return 1; 
601 
} 
602  
603 
s>num_primitive_matrices = get_bits(gbp, 4);

604  
605 
if (s>num_primitive_matrices > max_primitive_matrices) {

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

608 
max_primitive_matrices); 
609 
return 1; 
610 
} 
611  
612 
for (mat = 0; mat < s>num_primitive_matrices; mat++) { 
613 
int frac_bits, max_chan;

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

615 
frac_bits = get_bits(gbp, 4);

616 
s>lsb_bypass [mat] = get_bits1(gbp); 
617  
618 
if (s>matrix_out_ch[mat] > s>max_matrix_channel) {

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

621 
s>matrix_out_ch[mat]); 
622 
return 1; 
623 
} 
624 
if (frac_bits > 14) { 
625 
av_log(m>avctx, AV_LOG_ERROR, 
626 
"Too many fractional bits specified.\n");

627 
return 1; 
628 
} 
629  
630 
max_chan = s>max_matrix_channel; 
631 
if (!s>noise_type)

632 
max_chan+=2;

633  
634 
for (ch = 0; ch <= max_chan; ch++) { 
635 
int coeff_val = 0; 
636 
if (get_bits1(gbp))

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

638  
639 
s>matrix_coeff[mat][ch] = coeff_val << (14  frac_bits);

640 
} 
641  
642 
if (s>noise_type)

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

644 
else

645 
s>matrix_noise_shift[mat] = 0;

646 
} 
647  
648 
return 0; 
649 
} 
650  
651 
/** Read channel parameters. */

652  
653 
static int read_channel_params(MLPDecodeContext *m, unsigned int substr, 
654 
GetBitContext *gbp, unsigned int ch) 
655 
{ 
656 
SubStream *s = &m>substream[substr]; 
657 
ChannelParams *cp = &s>channel_params[ch]; 
658 
FilterParams *fir = &cp>filter_params[FIR]; 
659 
FilterParams *iir = &cp>filter_params[IIR]; 
660  
661 
if (s>param_presence_flags & PARAM_FIR)

662 
if (get_bits1(gbp))

663 
if (read_filter_params(m, gbp, substr, ch, FIR) < 0) 
664 
return 1; 
665  
666 
if (s>param_presence_flags & PARAM_IIR)

667 
if (get_bits1(gbp))

668 
if (read_filter_params(m, gbp, substr, ch, IIR) < 0) 
669 
return 1; 
670  
671 
if (fir>order + iir>order > 8) { 
672 
av_log(m>avctx, AV_LOG_ERROR, "Total filter orders too high.\n");

673 
return 1; 
674 
} 
675  
676 
if (fir>order && iir>order &&

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

680 
return 1; 
681 
} 
682 
/* The FIR and IIR filters must have the same precision.

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

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

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

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

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

688 
fir>shift = iir>shift; 
689  
690 
if (s>param_presence_flags & PARAM_HUFFOFFSET)

691 
if (get_bits1(gbp))

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

693  
694 
cp>codebook = get_bits(gbp, 2);

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

696  
697 
if (cp>huff_lsbs > 24) { 
698 
av_log(m>avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");

699 
return 1; 
700 
} 
701  
702 
cp>sign_huff_offset = calculate_sign_huff(m, substr, ch); 
703  
704 
return 0; 
705 
} 
706  
707 
/** Read decoding parameters that change more often than those in the restart

708 
* header. */

709  
710 
static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp, 
711 
unsigned int substr) 
712 
{ 
713 
SubStream *s = &m>substream[substr]; 
714 
unsigned int ch; 
715  
716 
if (s>param_presence_flags & PARAM_PRESENCE)

717 
if (get_bits1(gbp))

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

719  
720 
if (s>param_presence_flags & PARAM_BLOCKSIZE)

721 
if (get_bits1(gbp)) {

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

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

725 
s>blocksize = 0;

726 
return 1; 
727 
} 
728 
} 
729  
730 
if (s>param_presence_flags & PARAM_MATRIX)

731 
if (get_bits1(gbp))

732 
if (read_matrix_params(m, substr, gbp) < 0) 
733 
return 1; 
734  
735 
if (s>param_presence_flags & PARAM_OUTSHIFT)

736 
if (get_bits1(gbp))

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

739  
740 
if (s>param_presence_flags & PARAM_QUANTSTEP)

741 
if (get_bits1(gbp))

742 
for (ch = 0; ch <= s>max_channel; ch++) { 
743 
ChannelParams *cp = &s>channel_params[ch]; 
744  
745 
s>quant_step_size[ch] = get_bits(gbp, 4);

746  
747 
cp>sign_huff_offset = calculate_sign_huff(m, substr, ch); 
748 
} 
749  
750 
for (ch = s>min_channel; ch <= s>max_channel; ch++)

751 
if (get_bits1(gbp))

752 
if (read_channel_params(m, substr, gbp, ch) < 0) 
753 
return 1; 
754  
755 
return 0; 
756 
} 
757  
758 
#define MSB_MASK(bits) (1u << bits) 
759  
760 
/** Generate PCM samples using the prediction filters and residual values

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

762  
763 
static void filter_channel(MLPDecodeContext *m, unsigned int substr, 
764 
unsigned int channel) 
765 
{ 
766 
SubStream *s = &m>substream[substr]; 
767 
const int32_t *fircoeff = s>channel_params[channel].coeff[FIR];

768 
int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER]; 
769 
int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE; 
770 
int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE; 
771 
FilterParams *fir = &s>channel_params[channel].filter_params[FIR]; 
772 
FilterParams *iir = &s>channel_params[channel].filter_params[IIR]; 
773 
unsigned int filter_shift = fir>shift; 
774 
int32_t mask = MSB_MASK(s>quant_step_size[channel]); 
775  
776 
memcpy(firbuf, fir>state, MAX_FIR_ORDER * sizeof(int32_t));

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

778  
779 
m>dsp.mlp_filter_channel(firbuf, fircoeff, 
780 
fir>order, iir>order, 
781 
filter_shift, mask, s>blocksize, 
782 
&m>sample_buffer[s>blockpos][channel]); 
783  
784 
memcpy(fir>state, firbuf  s>blocksize, MAX_FIR_ORDER * sizeof(int32_t));

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

786 
} 
787  
788 
/** Read a block of PCM residual data (or actual if no filtering active). */

789  
790 
static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp, 
791 
unsigned int substr) 
792 
{ 
793 
SubStream *s = &m>substream[substr]; 
794 
unsigned int i, ch, expected_stream_pos = 0; 
795  
796 
if (s>data_check_present) {

797 
expected_stream_pos = get_bits_count(gbp); 
798 
expected_stream_pos += get_bits(gbp, 16);

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

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

801 
} 
802  
803 
if (s>blockpos + s>blocksize > m>access_unit_size) {

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

805 
return 1; 
806 
} 
807  
808 
memset(&m>bypassed_lsbs[s>blockpos][0], 0, 
809 
s>blocksize * sizeof(m>bypassed_lsbs[0])); 
810  
811 
for (i = 0; i < s>blocksize; i++) 
812 
if (read_huff_channels(m, gbp, substr, i) < 0) 
813 
return 1; 
814  
815 
for (ch = s>min_channel; ch <= s>max_channel; ch++)

816 
filter_channel(m, substr, ch); 
817  
818 
s>blockpos += s>blocksize; 
819  
820 
if (s>data_check_present) {

821 
if (get_bits_count(gbp) != expected_stream_pos)

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

823 
skip_bits(gbp, 8);

824 
} 
825  
826 
return 0; 
827 
} 
828  
829 
/** Data table used for TrueHD noise generation function. */

830  
831 
static const int8_t noise_table[256] = { 
832 
30, 51, 22, 54, 3, 7, 4, 38, 14, 55, 46, 81, 22, 58, 3, 2, 
833 
52, 31, 7, 51, 15, 44, 74, 30, 85, 17, 10, 33, 18, 80, 28, 62, 
834 
10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, 2, 5, 
835 
51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40, 
836 
38, 16, 10, 28, 92, 22, 18, 29, 10, 5, 13, 49, 19, 24, 70, 34, 
837 
61, 48, 30, 14, 6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30, 
838 
67, 44, 9, 50, 11, 43, 40, 32, 59, 82, 13, 49, 14, 55, 60, 36, 
839 
48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, 2, 84, 69, 
840 
0, 72, 37, 57, 27, 41, 15, 16, 35, 31, 14, 61, 24, 0, 27, 24, 
841 
16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, 20, 8, 20, 
842 
13, 28, 3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, 23, 
843 
89, 18, 74, 21, 38, 12, 19, 12, 19, 8, 15, 33, 4, 57, 9, 8, 
844 
36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40, 
845 
39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, 1, 32, 37, 
846 
45, 5, 53, 6, 7, 36, 50, 23, 6, 32, 9, 21, 18, 71, 27, 52, 
847 
25, 31, 35, 42, 1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70, 
848 
}; 
849  
850 
/** Noise generation functions.

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

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

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

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

855 
* dithering? */

856  
857 
/** Generate two channels of noise, used in the matrix when

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

859  
860 
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr) 
861 
{ 
862 
SubStream *s = &m>substream[substr]; 
863 
unsigned int i; 
864 
uint32_t seed = s>noisegen_seed; 
865 
unsigned int maxchan = s>max_matrix_channel; 
866  
867 
for (i = 0; i < s>blockpos; i++) { 
868 
uint16_t seed_shr7 = seed >> 7;

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

871  
872 
seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5); 
873 
} 
874  
875 
s>noisegen_seed = seed; 
876 
} 
877  
878 
/** Generate a block of noise, used when restart sync word == 0x31eb. */

879  
880 
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr) 
881 
{ 
882 
SubStream *s = &m>substream[substr]; 
883 
unsigned int i; 
884 
uint32_t seed = s>noisegen_seed; 
885  
886 
for (i = 0; i < m>access_unit_size_pow2; i++) { 
887 
uint8_t seed_shr15 = seed >> 15;

888 
m>noise_buffer[i] = noise_table[seed_shr15]; 
889 
seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5); 
890 
} 
891  
892 
s>noisegen_seed = seed; 
893 
} 
894  
895  
896 
/** Apply the channel matrices in turn to reconstruct the original audio

897 
* samples. */

898  
899 
static void rematrix_channels(MLPDecodeContext *m, unsigned int substr) 
900 
{ 
901 
SubStream *s = &m>substream[substr]; 
902 
unsigned int mat, src_ch, i; 
903 
unsigned int maxchan; 
904  
905 
maxchan = s>max_matrix_channel; 
906 
if (!s>noise_type) {

907 
generate_2_noise_channels(m, substr); 
908 
maxchan += 2;

909 
} else {

910 
fill_noise_buffer(m, substr); 
911 
} 
912  
913 
for (mat = 0; mat < s>num_primitive_matrices; mat++) { 
914 
int matrix_noise_shift = s>matrix_noise_shift[mat];

915 
unsigned int dest_ch = s>matrix_out_ch[mat]; 
916 
int32_t mask = MSB_MASK(s>quant_step_size[dest_ch]); 
917 
int32_t *coeffs = s>matrix_coeff[mat]; 
918 
int index = s>num_primitive_matrices  mat;

919 
int index2 = 2 * index + 1; 
920  
921 
/* TODO: DSPContext? */

922  
923 
for (i = 0; i < s>blockpos; i++) { 
924 
int32_t bypassed_lsb = m>bypassed_lsbs[i][mat]; 
925 
int32_t *samples = m>sample_buffer[i]; 
926 
int64_t accum = 0;

927  
928 
for (src_ch = 0; src_ch <= maxchan; src_ch++) 
929 
accum += (int64_t) samples[src_ch] * coeffs[src_ch]; 
930  
931 
if (matrix_noise_shift) {

932 
index &= m>access_unit_size_pow2  1;

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

934 
index += index2; 
935 
} 
936  
937 
samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;

938 
} 
939 
} 
940 
} 
941  
942 
/** Write the audio data into the output buffer. */

943  
944 
static int output_data_internal(MLPDecodeContext *m, unsigned int substr, 
945 
uint8_t *data, unsigned int *data_size, int is32) 
946 
{ 
947 
SubStream *s = &m>substream[substr]; 
948 
unsigned int i, out_ch = 0; 
949 
int32_t *data_32 = (int32_t*) data; 
950 
int16_t *data_16 = (int16_t*) data; 
951  
952 
if (*data_size < (s>max_channel + 1) * s>blockpos * (is32 ? 4 : 2)) 
953 
return 1; 
954  
955 
for (i = 0; i < s>blockpos; i++) { 
956 
for (out_ch = 0; out_ch <= s>max_matrix_channel; out_ch++) { 
957 
int mat_ch = s>ch_assign[out_ch];

958 
int32_t sample = m>sample_buffer[i][mat_ch] 
959 
<< s>output_shift[mat_ch]; 
960 
s>lossless_check_data ^= (sample & 0xffffff) << mat_ch;

961 
if (is32) *data_32++ = sample << 8; 
962 
else *data_16++ = sample >> 8; 
963 
} 
964 
} 
965  
966 
*data_size = i * out_ch * (is32 ? 4 : 2); 
967  
968 
return 0; 
969 
} 
970  
971 
static int output_data(MLPDecodeContext *m, unsigned int substr, 
972 
uint8_t *data, unsigned int *data_size) 
973 
{ 
974 
if (m>avctx>sample_fmt == AV_SAMPLE_FMT_S32)

975 
return output_data_internal(m, substr, data, data_size, 1); 
976 
else

977 
return output_data_internal(m, substr, data, data_size, 0); 
978 
} 
979  
980  
981 
/** Read an access unit from the stream.

982 
* @return negative on error, 0 if not enough data is present in the input stream,

983 
* otherwise the number of bytes consumed. */

984  
985 
static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size, 
986 
AVPacket *avpkt) 
987 
{ 
988 
const uint8_t *buf = avpkt>data;

989 
int buf_size = avpkt>size;

990 
MLPDecodeContext *m = avctx>priv_data; 
991 
GetBitContext gb; 
992 
unsigned int length, substr; 
993 
unsigned int substream_start; 
994 
unsigned int header_size = 4; 
995 
unsigned int substr_header_size = 0; 
996 
uint8_t substream_parity_present[MAX_SUBSTREAMS]; 
997 
uint16_t substream_data_len[MAX_SUBSTREAMS]; 
998 
uint8_t parity_bits; 
999  
1000 
if (buf_size < 4) 
1001 
return 0; 
1002  
1003 
length = (AV_RB16(buf) & 0xfff) * 2; 
1004  
1005 
if (length < 4  length > buf_size) 
1006 
return 1; 
1007  
1008 
init_get_bits(&gb, (buf + 4), (length  4) * 8); 
1009  
1010 
m>is_major_sync_unit = 0;

1011 
if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) { 
1012 
if (read_major_sync(m, &gb) < 0) 
1013 
goto error;

1014 
m>is_major_sync_unit = 1;

1015 
header_size += 28;

1016 
} 
1017  
1018 
if (!m>params_valid) {

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

1021 
*data_size = 0;

1022 
return length;

1023 
} 
1024  
1025 
substream_start = 0;

1026  
1027 
for (substr = 0; substr < m>num_substreams; substr++) { 
1028 
int extraword_present, checkdata_present, end, nonrestart_substr;

1029  
1030 
extraword_present = get_bits1(&gb); 
1031 
nonrestart_substr = get_bits1(&gb); 
1032 
checkdata_present = get_bits1(&gb); 
1033 
skip_bits1(&gb); 
1034  
1035 
end = get_bits(&gb, 12) * 2; 
1036  
1037 
substr_header_size += 2;

1038  
1039 
if (extraword_present) {

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

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

1042 
goto error;

1043 
} 
1044 
skip_bits(&gb, 16);

1045 
substr_header_size += 2;

1046 
} 
1047  
1048 
if (!(nonrestart_substr ^ m>is_major_sync_unit)) {

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

1050 
goto error;

1051 
} 
1052  
1053 
if (end + header_size + substr_header_size > length) {

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

1056 
"packet.\n", substr);

1057 
end = length  header_size  substr_header_size; 
1058 
} 
1059  
1060 
if (end < substream_start) {

1061 
av_log(avctx, AV_LOG_ERROR, 
1062 
"Indicated end offset of substream %d data "

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

1064 
substr); 
1065 
goto error;

1066 
} 
1067  
1068 
if (substr > m>max_decoded_substream)

1069 
continue;

1070  
1071 
substream_parity_present[substr] = checkdata_present; 
1072 
substream_data_len[substr] = end  substream_start; 
1073 
substream_start = end; 
1074 
} 
1075  
1076 
parity_bits = ff_mlp_calculate_parity(buf, 4);

1077 
parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size); 
1078  
1079 
if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) { 
1080 
av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");

1081 
goto error;

1082 
} 
1083  
1084 
buf += header_size + substr_header_size; 
1085  
1086 
for (substr = 0; substr <= m>max_decoded_substream; substr++) { 
1087 
SubStream *s = &m>substream[substr]; 
1088 
init_get_bits(&gb, buf, substream_data_len[substr] * 8);

1089  
1090 
m>matrix_changed = 0;

1091 
memset(m>filter_changed, 0, sizeof(m>filter_changed)); 
1092  
1093 
s>blockpos = 0;

1094 
do {

1095 
if (get_bits1(&gb)) {

1096 
if (get_bits1(&gb)) {

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

1098 
if (read_restart_header(m, &gb, buf, substr) < 0) 
1099 
goto next_substr;

1100 
s>restart_seen = 1;

1101 
} 
1102  
1103 
if (!s>restart_seen)

1104 
goto next_substr;

1105 
if (read_decoding_params(m, &gb, substr) < 0) 
1106 
goto next_substr;

1107 
} 
1108  
1109 
if (!s>restart_seen)

1110 
goto next_substr;

1111  
1112 
if (read_block_data(m, &gb, substr) < 0) 
1113 
return 1; 
1114  
1115 
if (get_bits_count(&gb) >= substream_data_len[substr] * 8) 
1116 
goto substream_length_mismatch;

1117  
1118 
} while (!get_bits1(&gb));

1119  
1120 
skip_bits(&gb, (get_bits_count(&gb)) & 15);

1121  
1122 
if (substream_data_len[substr] * 8  get_bits_count(&gb) >= 32) { 
1123 
int shorten_by;

1124  
1125 
if (get_bits(&gb, 16) != 0xD234) 
1126 
return 1; 
1127  
1128 
shorten_by = get_bits(&gb, 16);

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

1131 
else if (m>avctx>codec_id == CODEC_ID_MLP && shorten_by != 0xD234) 
1132 
return 1; 
1133  
1134 
if (substr == m>max_decoded_substream)

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

1136 
} 
1137  
1138 
if (substream_parity_present[substr]) {

1139 
uint8_t parity, checksum; 
1140  
1141 
if (substream_data_len[substr] * 8  get_bits_count(&gb) != 16) 
1142 
goto substream_length_mismatch;

1143  
1144 
parity = ff_mlp_calculate_parity(buf, substream_data_len[substr]  2);

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

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

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

1151 
} 
1152  
1153 
if (substream_data_len[substr] * 8 != get_bits_count(&gb)) 
1154 
goto substream_length_mismatch;

1155  
1156 
next_substr:

1157 
if (!s>restart_seen)

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

1160  
1161 
buf += substream_data_len[substr]; 
1162 
} 
1163  
1164 
rematrix_channels(m, m>max_decoded_substream); 
1165  
1166 
if (output_data(m, m>max_decoded_substream, data, data_size) < 0) 
1167 
return 1; 
1168  
1169 
return length;

1170  
1171 
substream_length_mismatch:

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

1173 
return 1; 
1174  
1175 
error:

1176 
m>params_valid = 0;

1177 
return 1; 
1178 
} 
1179  
1180 
AVCodec ff_mlp_decoder = { 
1181 
"mlp",

1182 
AVMEDIA_TYPE_AUDIO, 
1183 
CODEC_ID_MLP, 
1184 
sizeof(MLPDecodeContext),

1185 
mlp_decode_init, 
1186 
NULL,

1187 
NULL,

1188 
read_access_unit, 
1189 
.long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),

1190 
}; 
1191  
1192 
#if CONFIG_TRUEHD_DECODER

1193 
AVCodec ff_truehd_decoder = { 
1194 
"truehd",

1195 
AVMEDIA_TYPE_AUDIO, 
1196 
CODEC_ID_TRUEHD, 
1197 
sizeof(MLPDecodeContext),

1198 
mlp_decode_init, 
1199 
NULL,

1200 
NULL,

1201 
read_access_unit, 
1202 
.long_name = NULL_IF_CONFIG_SMALL("TrueHD"),

1203 
}; 
1204 
#endif /* CONFIG_TRUEHD_DECODER */ 