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