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