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