ffmpeg / libavcodec / mlpdec.c @ 868170c4
History  View  Annotate  Download (37.4 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 "libavutil/intreadwrite.h" 
31 
#include "get_bits.h" 
32 
#include "libavutil/crc.h" 
33 
#include "parser.h" 
34 
#include "mlp_parser.h" 
35 
#include "mlp.h" 
36  
37 
/** number of bits used for VLC lookup  longest Huffman code is 9 */

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

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

44 
"a sample of this file.";

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

48 
uint8_t restart_seen; 
49  
50 
//@{

51 
/** restart header data */

52 
//! The type of noise to be used in the rematrix stage.

53 
uint16_t noise_type; 
54  
55 
//! The index of the first channel coded in this substream.

56 
uint8_t min_channel; 
57 
//! The index of the last channel coded in this substream.

58 
uint8_t max_channel; 
59 
//! The number of channels input into the rematrix stage.

60 
uint8_t max_matrix_channel; 
61 
//! For each channel output by the matrix, the output channel to map it to

62 
uint8_t ch_assign[MAX_CHANNELS]; 
63  
64 
//! The left shift applied to random noise in 0x31ea substreams.

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

67 
uint32_t noisegen_seed; 
68  
69 
//! Set if the substream contains extra info to check the size of VLC blocks.

70 
uint8_t data_check_present; 
71  
72 
//! Bitmask of which parameter sets are conveyed in a decoding parameter block.

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

83  
84 
//@{

85 
/** matrix data */

86  
87 
//! Number of matrices to be applied.

88 
uint8_t num_primitive_matrices; 
89  
90 
//! matrix output channel

91 
uint8_t matrix_out_ch[MAX_MATRICES]; 
92  
93 
//! Whether the LSBs of the matrix output are encoded in the bitstream.

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

96 
int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS+2];

97 
//! Left shift to apply to noise values in 0x31eb substreams.

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

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

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

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

107 
uint16_t blockpos; 
108  
109 
//! Left shift to apply to decoded PCM values to get final 24bit output.

110 
int8_t output_shift[MAX_CHANNELS]; 
111  
112 
//! Running XOR of all output samples.

113 
int32_t lossless_check_data; 
114  
115 
} SubStream; 
116  
117 
typedef struct MLPDecodeContext { 
118 
AVCodecContext *avctx; 
119  
120 
//! Current access unit being read has a major sync.

121 
int is_major_sync_unit;

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

124 
uint8_t params_valid; 
125  
126 
//! Number of substreams contained within this stream.

127 
uint8_t num_substreams; 
128  
129 
//! Index of the last substream to decode  further substreams are skipped.

130 
uint8_t max_decoded_substream; 
131  
132 
//! number of PCM samples contained in each frame

133 
int access_unit_size;

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

135 
int access_unit_size_pow2;

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

142 
int filter_changed[MAX_CHANNELS][NUM_FILTERS];

143  
144 
int8_t noise_buffer[MAX_BLOCKSIZE_POW2]; 
145 
int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS]; 
146 
int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS+2];

147 
} MLPDecodeContext; 
148  
149 
static VLC huff_vlc[3]; 
150  
151 
/** Initialize static data, constant between all invocations of the codec. */

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

174 
int sign_shift = lsb_bits + (cp>codebook ? 2  cp>codebook : 1); 
175 
int32_t sign_huff_offset = cp>huff_offset; 
176  
177 
if (cp>codebook > 0) 
178 
sign_huff_offset = 7 << lsb_bits;

179  
180 
if (sign_shift >= 0) 
181 
sign_huff_offset = 1 << sign_shift;

182  
183 
return sign_huff_offset;

184 
} 
185  
186 
/** Read a sample, consisting of either, both or neither of entropycoded MSBs

187 
* and plain LSBs. */

188  
189 
static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp, 
190 
unsigned int substr, unsigned int pos) 
191 
{ 
192 
SubStream *s = &m>substream[substr]; 
193 
unsigned int mat, channel; 
194  
195 
for (mat = 0; mat < s>num_primitive_matrices; mat++) 
196 
if (s>lsb_bypass[mat])

197 
m>bypassed_lsbs[pos + s>blockpos][mat] = get_bits1(gbp); 
198  
199 
for (channel = s>min_channel; channel <= s>max_channel; channel++) {

200 
ChannelParams *cp = &m>channel_params[channel]; 
201 
int codebook = cp>codebook;

202 
int quant_step_size = s>quant_step_size[channel];

203 
int lsb_bits = cp>huff_lsbs  quant_step_size;

204 
int result = 0; 
205  
206 
if (codebook > 0) 
207 
result = get_vlc2(gbp, huff_vlc[codebook1].table,

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

229  
230 
init_static(); 
231 
m>avctx = avctx; 
232 
for (substr = 0; substr < MAX_SUBSTREAMS; substr++) 
233 
m>substream[substr].lossless_check_data = 0xffffffff;

234  
235 
return 0; 
236 
} 
237  
238 
/** Read a major sync info header  contains high level information about

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

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

241 
*/

242  
243 
static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb) 
244 
{ 
245 
MLPHeaderInfo mh; 
246 
int substr;

247  
248 
if (ff_mlp_read_major_sync(m>avctx, &mh, gb) != 0) 
249 
return 1; 
250  
251 
if (mh.group1_bits == 0) { 
252 
av_log(m>avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");

253 
return 1; 
254 
} 
255 
if (mh.group2_bits > mh.group1_bits) {

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

258 
return 1; 
259 
} 
260  
261 
if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {

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

264 
return 1; 
265 
} 
266  
267 
if (mh.group1_samplerate == 0) { 
268 
av_log(m>avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");

269 
return 1; 
270 
} 
271 
if (mh.group1_samplerate > MAX_SAMPLERATE) {

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

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

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

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

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

286 
mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2); 
287 
return 1; 
288 
} 
289  
290 
if (mh.num_substreams == 0) 
291 
return 1; 
292 
if (m>avctx>codec_id == CODEC_ID_MLP && mh.num_substreams > 2) { 
293 
av_log(m>avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");

294 
return 1; 
295 
} 
296 
if (mh.num_substreams > MAX_SUBSTREAMS) {

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

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

300 
return 1; 
301 
} 
302  
303 
m>access_unit_size = mh.access_unit_size; 
304 
m>access_unit_size_pow2 = mh.access_unit_size_pow2; 
305  
306 
m>num_substreams = mh.num_substreams; 
307 
m>max_decoded_substream = m>num_substreams  1;

308  
309 
m>avctx>sample_rate = mh.group1_samplerate; 
310 
m>avctx>frame_size = mh.access_unit_size; 
311  
312 
m>avctx>bits_per_raw_sample = mh.group1_bits; 
313 
if (mh.group1_bits > 16) 
314 
m>avctx>sample_fmt = SAMPLE_FMT_S32; 
315 
else

316 
m>avctx>sample_fmt = SAMPLE_FMT_S16; 
317  
318 
m>params_valid = 1;

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

321  
322 
return 0; 
323 
} 
324  
325 
/** Read a restart header from a block in a substream. This contains parameters

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

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

328  
329 
static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp, 
330 
const uint8_t *buf, unsigned int substr) 
331 
{ 
332 
SubStream *s = &m>substream[substr]; 
333 
unsigned int ch; 
334 
int sync_word, tmp;

335 
uint8_t checksum; 
336 
uint8_t lossless_check; 
337 
int start_count = get_bits_count(gbp);

338 
const int max_matrix_channel = m>avctx>codec_id == CODEC_ID_MLP 
339 
? MAX_MATRIX_CHANNEL_MLP 
340 
: MAX_MATRIX_CHANNEL_TRUEHD; 
341  
342 
sync_word = get_bits(gbp, 13);

343 
s>noise_type = get_bits1(gbp); 
344  
345 
if ((m>avctx>codec_id == CODEC_ID_MLP && s>noise_type) 

346 
sync_word != 0x31ea >> 1) { 
347 
av_log(m>avctx, AV_LOG_ERROR, 
348 
"restart header sync incorrect (got 0x%04x)\n", sync_word);

349 
return 1; 
350 
} 
351  
352 
skip_bits(gbp, 16); /* Output timestamp */ 
353  
354 
s>min_channel = get_bits(gbp, 4);

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

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

357  
358 
if (s>max_matrix_channel > max_matrix_channel) {

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

361 
max_matrix_channel); 
362 
return 1; 
363 
} 
364  
365 
if (s>max_channel != s>max_matrix_channel) {

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

368 
return 1; 
369 
} 
370  
371 
if (s>min_channel > s>max_channel) {

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

374 
return 1; 
375 
} 
376  
377 
if (m>avctx>request_channels > 0 
378 
&& s>max_channel + 1 >= m>avctx>request_channels

379 
&& substr < m>max_decoded_substream) { 
380 
av_log(m>avctx, AV_LOG_INFO, 
381 
"Extracting %d channel downmix from substream %d. "

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

383 
s>max_channel + 1, substr);

384 
m>max_decoded_substream = substr; 
385 
} 
386  
387 
s>noise_shift = get_bits(gbp, 4);

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

389  
390 
skip_bits(gbp, 19);

391  
392 
s>data_check_present = get_bits1(gbp); 
393 
lossless_check = get_bits(gbp, 8);

394 
if (substr == m>max_decoded_substream

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

396 
tmp = xor_32_to_8(s>lossless_check_data); 
397 
if (tmp != lossless_check)

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

400 
lossless_check, tmp); 
401 
} 
402  
403 
skip_bits(gbp, 16);

404  
405 
memset(s>ch_assign, 0, sizeof(s>ch_assign)); 
406  
407 
for (ch = 0; ch <= s>max_matrix_channel; ch++) { 
408 
int ch_assign = get_bits(gbp, 6); 
409 
if (ch_assign > s>max_matrix_channel) {

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

412 
ch, ch_assign, sample_message); 
413 
return 1; 
414 
} 
415 
s>ch_assign[ch_assign] = ch; 
416 
} 
417  
418 
checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp)  start_count); 
419  
420 
if (checksum != get_bits(gbp, 8)) 
421 
av_log(m>avctx, AV_LOG_ERROR, "restart header checksum error\n");

422  
423 
/* Set default decoding parameters. */

424 
s>param_presence_flags = 0xff;

425 
s>num_primitive_matrices = 0;

426 
s>blocksize = 8;

427 
s>lossless_check_data = 0;

428  
429 
memset(s>output_shift , 0, sizeof(s>output_shift )); 
430 
memset(s>quant_step_size, 0, sizeof(s>quant_step_size)); 
431  
432 
for (ch = s>min_channel; ch <= s>max_channel; ch++) {

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

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

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

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

438  
439 
/* Default audio coding is 24bit raw PCM. */

440 
cp>huff_offset = 0;

441 
cp>sign_huff_offset = (1) << 23; 
442 
cp>codebook = 0;

443 
cp>huff_lsbs = 24;

444 
} 
445  
446 
if (substr == m>max_decoded_substream)

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

448  
449 
return 0; 
450 
} 
451  
452 
/** Read parameters for one of the prediction filters. */

453  
454 
static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp, 
455 
unsigned int channel, unsigned int filter) 
456 
{ 
457 
FilterParams *fp = &m>channel_params[channel].filter_params[filter]; 
458 
const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER; 
459 
const char fchar = filter ? 'I' : 'F'; 
460 
int i, order;

461  
462 
// Filter is 0 for FIR, 1 for IIR.

463 
assert(filter < 2);

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

467 
return 1; 
468 
} 
469  
470 
order = get_bits(gbp, 4);

471 
if (order > max_order) {

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

474 
fchar, order, max_order); 
475 
return 1; 
476 
} 
477 
fp>order = order; 
478  
479 
if (order > 0) { 
480 
int coeff_bits, coeff_shift;

481  
482 
fp>shift = get_bits(gbp, 4);

483  
484 
coeff_bits = get_bits(gbp, 5);

485 
coeff_shift = get_bits(gbp, 3);

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

489 
fchar); 
490 
return 1; 
491 
} 
492 
if (coeff_bits + coeff_shift > 16) { 
493 
av_log(m>avctx, AV_LOG_ERROR, 
494 
"Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",

495 
fchar); 
496 
return 1; 
497 
} 
498  
499 
for (i = 0; i < order; i++) 
500 
fp>coeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift; 
501  
502 
if (get_bits1(gbp)) {

503 
int state_bits, state_shift;

504  
505 
if (filter == FIR) {

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

508 
return 1; 
509 
} 
510  
511 
state_bits = get_bits(gbp, 4);

512 
state_shift = get_bits(gbp, 4);

513  
514 
/* TODO: Check validity of state data. */

515  
516 
for (i = 0; i < order; i++) 
517 
fp>state[i] = get_sbits(gbp, state_bits) << state_shift; 
518 
} 
519 
} 
520  
521 
return 0; 
522 
} 
523  
524 
/** Read parameters for primitive matrices. */

525  
526 
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp) 
527 
{ 
528 
SubStream *s = &m>substream[substr]; 
529 
unsigned int mat, ch; 
530  
531 
if (m>matrix_changed++ > 1) { 
532 
av_log(m>avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");

533 
return 1; 
534 
} 
535  
536 
s>num_primitive_matrices = get_bits(gbp, 4);

537  
538 
for (mat = 0; mat < s>num_primitive_matrices; mat++) { 
539 
int frac_bits, max_chan;

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

541 
frac_bits = get_bits(gbp, 4);

542 
s>lsb_bypass [mat] = get_bits1(gbp); 
543  
544 
if (s>matrix_out_ch[mat] > s>max_matrix_channel) {

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

547 
s>matrix_out_ch[mat]); 
548 
return 1; 
549 
} 
550 
if (frac_bits > 14) { 
551 
av_log(m>avctx, AV_LOG_ERROR, 
552 
"Too many fractional bits specified.\n");

553 
return 1; 
554 
} 
555  
556 
max_chan = s>max_matrix_channel; 
557 
if (!s>noise_type)

558 
max_chan+=2;

559  
560 
for (ch = 0; ch <= max_chan; ch++) { 
561 
int coeff_val = 0; 
562 
if (get_bits1(gbp))

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

564  
565 
s>matrix_coeff[mat][ch] = coeff_val << (14  frac_bits);

566 
} 
567  
568 
if (s>noise_type)

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

570 
else

571 
s>matrix_noise_shift[mat] = 0;

572 
} 
573  
574 
return 0; 
575 
} 
576  
577 
/** Read channel parameters. */

578  
579 
static int read_channel_params(MLPDecodeContext *m, unsigned int substr, 
580 
GetBitContext *gbp, unsigned int ch) 
581 
{ 
582 
ChannelParams *cp = &m>channel_params[ch]; 
583 
FilterParams *fir = &cp>filter_params[FIR]; 
584 
FilterParams *iir = &cp>filter_params[IIR]; 
585 
SubStream *s = &m>substream[substr]; 
586  
587 
if (s>param_presence_flags & PARAM_FIR)

588 
if (get_bits1(gbp))

589 
if (read_filter_params(m, gbp, ch, FIR) < 0) 
590 
return 1; 
591  
592 
if (s>param_presence_flags & PARAM_IIR)

593 
if (get_bits1(gbp))

594 
if (read_filter_params(m, gbp, ch, IIR) < 0) 
595 
return 1; 
596  
597 
if (fir>order + iir>order > 8) { 
598 
av_log(m>avctx, AV_LOG_ERROR, "Total filter orders too high.\n");

599 
return 1; 
600 
} 
601  
602 
if (fir>order && iir>order &&

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

606 
return 1; 
607 
} 
608 
/* The FIR and IIR filters must have the same precision.

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

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

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

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

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

614 
fir>shift = iir>shift; 
615  
616 
if (s>param_presence_flags & PARAM_HUFFOFFSET)

617 
if (get_bits1(gbp))

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

619  
620 
cp>codebook = get_bits(gbp, 2);

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

622  
623 
if (cp>huff_lsbs > 24) { 
624 
av_log(m>avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");

625 
return 1; 
626 
} 
627  
628 
cp>sign_huff_offset = calculate_sign_huff(m, substr, ch); 
629  
630 
return 0; 
631 
} 
632  
633 
/** Read decoding parameters that change more often than those in the restart

634 
* header. */

635  
636 
static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp, 
637 
unsigned int substr) 
638 
{ 
639 
SubStream *s = &m>substream[substr]; 
640 
unsigned int ch; 
641  
642 
if (s>param_presence_flags & PARAM_PRESENCE)

643 
if (get_bits1(gbp))

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

645  
646 
if (s>param_presence_flags & PARAM_BLOCKSIZE)

647 
if (get_bits1(gbp)) {

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

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

651 
s>blocksize = 0;

652 
return 1; 
653 
} 
654 
} 
655  
656 
if (s>param_presence_flags & PARAM_MATRIX)

657 
if (get_bits1(gbp))

658 
if (read_matrix_params(m, substr, gbp) < 0) 
659 
return 1; 
660  
661 
if (s>param_presence_flags & PARAM_OUTSHIFT)

662 
if (get_bits1(gbp))

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

665  
666 
if (s>param_presence_flags & PARAM_QUANTSTEP)

667 
if (get_bits1(gbp))

668 
for (ch = 0; ch <= s>max_channel; ch++) { 
669 
ChannelParams *cp = &m>channel_params[ch]; 
670  
671 
s>quant_step_size[ch] = get_bits(gbp, 4);

672  
673 
cp>sign_huff_offset = calculate_sign_huff(m, substr, ch); 
674 
} 
675  
676 
for (ch = s>min_channel; ch <= s>max_channel; ch++)

677 
if (get_bits1(gbp))

678 
if (read_channel_params(m, substr, gbp, ch) < 0) 
679 
return 1; 
680  
681 
return 0; 
682 
} 
683  
684 
#define MSB_MASK(bits) (1u << bits) 
685  
686 
/** Generate PCM samples using the prediction filters and residual values

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

688  
689 
static void filter_channel(MLPDecodeContext *m, unsigned int substr, 
690 
unsigned int channel) 
691 
{ 
692 
SubStream *s = &m>substream[substr]; 
693 
int32_t firbuf[MAX_BLOCKSIZE + MAX_FIR_ORDER]; 
694 
int32_t iirbuf[MAX_BLOCKSIZE + MAX_IIR_ORDER]; 
695 
FilterParams *fir = &m>channel_params[channel].filter_params[FIR]; 
696 
FilterParams *iir = &m>channel_params[channel].filter_params[IIR]; 
697 
unsigned int filter_shift = fir>shift; 
698 
int32_t mask = MSB_MASK(s>quant_step_size[channel]); 
699 
int index = MAX_BLOCKSIZE;

700 
int i;

701  
702 
memcpy(&firbuf[index], fir>state, MAX_FIR_ORDER * sizeof(int32_t));

703 
memcpy(&iirbuf[index], iir>state, MAX_IIR_ORDER * sizeof(int32_t));

704  
705 
for (i = 0; i < s>blocksize; i++) { 
706 
int32_t residual = m>sample_buffer[i + s>blockpos][channel]; 
707 
unsigned int order; 
708 
int64_t accum = 0;

709 
int32_t result; 
710  
711 
/* TODO: Move this code to DSPContext? */

712  
713 
for (order = 0; order < fir>order; order++) 
714 
accum += (int64_t) firbuf[index + order] * fir>coeff[order]; 
715 
for (order = 0; order < iir>order; order++) 
716 
accum += (int64_t) iirbuf[index + order] * iir>coeff[order]; 
717  
718 
accum = accum >> filter_shift; 
719 
result = (accum + residual) & mask; 
720  
721 
index; 
722  
723 
firbuf[index] = result; 
724 
iirbuf[index] = result  accum; 
725  
726 
m>sample_buffer[i + s>blockpos][channel] = result; 
727 
} 
728  
729 
memcpy(fir>state, &firbuf[index], MAX_FIR_ORDER * sizeof(int32_t));

730 
memcpy(iir>state, &iirbuf[index], MAX_IIR_ORDER * sizeof(int32_t));

731 
} 
732  
733 
/** Read a block of PCM residual data (or actual if no filtering active). */

734  
735 
static 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) {

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

750 
return 1; 
751 
} 
752  
753 
memset(&m>bypassed_lsbs[s>blockpos][0], 0, 
754 
s>blocksize * sizeof(m>bypassed_lsbs[0])); 
755  
756 
for (i = 0; i < s>blocksize; i++) 
757 
if (read_huff_channels(m, gbp, substr, i) < 0) 
758 
return 1; 
759  
760 
for (ch = s>min_channel; ch <= s>max_channel; ch++)

761 
filter_channel(m, substr, ch); 
762  
763 
s>blockpos += s>blocksize; 
764  
765 
if (s>data_check_present) {

766 
if (get_bits_count(gbp) != expected_stream_pos)

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

768 
skip_bits(gbp, 8);

769 
} 
770  
771 
return 0; 
772 
} 
773  
774 
/** Data table used for TrueHD noise generation function. */

775  
776 
static 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  
805 
static 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  
825 
static 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  
844 
static 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]); 
862 
int32_t *coeffs = s>matrix_coeff[mat]; 
863 
int index = s>num_primitive_matrices  mat;

864 
int index2 = 2 * index + 1; 
865  
866 
/* TODO: DSPContext? */

867  
868 
for (i = 0; i < s>blockpos; i++) { 
869 
int32_t bypassed_lsb = m>bypassed_lsbs[i][mat]; 
870 
int32_t *samples = m>sample_buffer[i]; 
871 
int64_t accum = 0;

872  
873 
for (src_ch = 0; src_ch <= maxchan; src_ch++) 
874 
accum += (int64_t) samples[src_ch] * coeffs[src_ch]; 
875  
876 
if (matrix_noise_shift) {

877 
index &= m>access_unit_size_pow2  1;

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

879 
index += index2; 
880 
} 
881  
882 
samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;

883 
} 
884 
} 
885 
} 
886  
887 
/** Write the audio data into the output buffer. */

888  
889 
static 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]; 
893 
unsigned int i, out_ch = 0; 
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++) { 
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;

906 
if (is32) *data_32++ = sample << 8; 
907 
else *data_16++ = sample >> 8; 
908 
} 
909 
} 
910  
911 
*data_size = i * out_ch * (is32 ? 4 : 2); 
912  
913 
return 0; 
914 
} 
915  
916 
static 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  
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  
930 
static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size, 
931 
AVPacket *avpkt) 
932 
{ 
933 
const uint8_t *buf = avpkt>data;

934 
int buf_size = avpkt>size;

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  
955 
m>is_major_sync_unit = 0;

956 
if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) { 
957 
if (read_major_sync(m, &gb) < 0) 
958 
goto error;

959 
m>is_major_sync_unit = 1;

960 
header_size += 28;

961 
} 
962  
963 
if (!m>params_valid) {

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

966 
*data_size = 0;

967 
return length;

968 
} 
969  
970 
substream_start = 0;

971  
972 
for (substr = 0; substr < m>num_substreams; substr++) { 
973 
int extraword_present, checkdata_present, end, nonrestart_substr;

974  
975 
extraword_present = get_bits1(&gb); 
976 
nonrestart_substr = get_bits1(&gb); 
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) {

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 
} 
989 
skip_bits(&gb, 16);

990 
substr_header_size += 2;

991 
} 
992  
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  
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  
1021 
parity_bits = ff_mlp_calculate_parity(buf, 4);

1022 
parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size); 
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  
1035 
m>matrix_changed = 0;

1036 
memset(m>filter_changed, 0, sizeof(m>filter_changed)); 
1037  
1038 
s>blockpos = 0;

1039 
do {

1040 
if (get_bits1(&gb)) {

1041 
if (get_bits1(&gb)) {

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

1043 
if (read_restart_header(m, &gb, buf, substr) < 0) 
1044 
goto next_substr;

1045 
s>restart_seen = 1;

1046 
} 
1047  
1048 
if (!s>restart_seen)

1049 
goto next_substr;

1050 
if (read_decoding_params(m, &gb, substr) < 0) 
1051 
goto next_substr;

1052 
} 
1053  
1054 
if (!s>restart_seen)

1055 
goto next_substr;

1056  
1057 
if (read_block_data(m, &gb, substr) < 0) 
1058 
return 1; 
1059  
1060 
if (get_bits_count(&gb) >= substream_data_len[substr] * 8) 
1061 
goto substream_length_mismatch;

1062  
1063 
} while (!get_bits1(&gb));

1064  
1065 
skip_bits(&gb, (get_bits_count(&gb)) & 15);

1066  
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  
1079 
if (substr == m>max_decoded_substream)

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

1081 
} 
1082  
1083 
if (substream_parity_present[substr]) {

1084 
uint8_t parity, checksum; 
1085  
1086 
if (substream_data_len[substr] * 8  get_bits_count(&gb) != 16) 
1087 
goto substream_length_mismatch;

1088  
1089 
parity = ff_mlp_calculate_parity(buf, substream_data_len[substr]  2);

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

1091  
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);

1096 
} 
1097  
1098 
if (substream_data_len[substr] * 8 != get_bits_count(&gb)) 
1099 
goto substream_length_mismatch;

1100  
1101 
next_substr:

1102 
if (!s>restart_seen)

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

1105  
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  
1116 
substream_length_mismatch:

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

1118 
return 1; 
1119  
1120 
error:

1121 
m>params_valid = 0;

1122 
return 1; 
1123 
} 
1124  
1125 
#if CONFIG_MLP_DECODER

1126 
AVCodec 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, 
1135 
.long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),

1136 
}; 
1137 
#endif /* CONFIG_MLP_DECODER */ 
1138  
1139 
#if CONFIG_TRUEHD_DECODER

1140 
AVCodec 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 */ 