truehd: tune VLC decoding for ARM.
[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
c68fafe0 135 /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
b517af05
RP
136 uint8_t params_valid;
137
c68fafe0 138 /// Number of substreams contained within this stream.
b517af05
RP
139 uint8_t num_substreams;
140
c68fafe0 141 /// Index of the last substream to decode - further substreams are skipped.
b517af05
RP
142 uint8_t max_decoded_substream;
143
c68fafe0 144 /// number of PCM samples contained in each frame
b517af05 145 int access_unit_size;
c68fafe0 146 /// next power of two above the number of samples in each frame
b517af05
RP
147 int access_unit_size_pow2;
148
149 SubStream substream[MAX_SUBSTREAMS];
150
75428fa4
RP
151 int matrix_changed;
152 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
153
b517af05
RP
154 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
155 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
420df930 156 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
bf4f19dc 157
2d6caade 158 MLPDSPContext dsp;
b517af05
RP
159} MLPDecodeContext;
160
3ffcccb4
TW
161static const uint64_t thd_channel_order[] = {
162 AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT, // LR
163 AV_CH_FRONT_CENTER, // C
164 AV_CH_LOW_FREQUENCY, // LFE
165 AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT, // LRs
166 AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT, // LRvh
167 AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
168 AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT, // LRrs
169 AV_CH_BACK_CENTER, // Cs
170 AV_CH_TOP_CENTER, // Ts
171 AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
172 AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT, // LRw
173 AV_CH_TOP_FRONT_CENTER, // Cvh
174 AV_CH_LOW_FREQUENCY_2, // LFE2
175};
176
177static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
178 int index)
179{
180 int i;
181
182 if (av_get_channel_layout_nb_channels(channel_layout) <= index)
183 return 0;
184
185 for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
186 if (channel_layout & thd_channel_order[i] && !index--)
187 return thd_channel_order[i];
188 return 0;
189}
190
b517af05
RP
191static VLC huff_vlc[3];
192
b517af05
RP
193/** Initialize static data, constant between all invocations of the codec. */
194
dc8a7c93 195static av_cold void init_static(void)
b517af05 196{
7fd88069 197 if (!huff_vlc[0].bits) {
52ae1e86
RP
198 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
199 &ff_mlp_huffman_tables[0][0][1], 2, 1,
fcf5fc44 200 &ff_mlp_huffman_tables[0][0][0], 2, 1, VLC_STATIC_SIZE);
52ae1e86
RP
201 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
202 &ff_mlp_huffman_tables[1][0][1], 2, 1,
fcf5fc44 203 &ff_mlp_huffman_tables[1][0][0], 2, 1, VLC_STATIC_SIZE);
52ae1e86
RP
204 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
205 &ff_mlp_huffman_tables[2][0][1], 2, 1,
fcf5fc44 206 &ff_mlp_huffman_tables[2][0][0], 2, 1, VLC_STATIC_SIZE);
7fd88069 207 }
b517af05 208
ce15710f 209 ff_mlp_init_crc();
b517af05
RP
210}
211
212static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
213 unsigned int substr, unsigned int ch)
214{
215 SubStream *s = &m->substream[substr];
22fb814c 216 ChannelParams *cp = &s->channel_params[ch];
f53acb7b
RP
217 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
218 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
219 int32_t sign_huff_offset = cp->huff_offset;
b517af05 220
f53acb7b 221 if (cp->codebook > 0)
b517af05
RP
222 sign_huff_offset -= 7 << lsb_bits;
223
224 if (sign_shift >= 0)
225 sign_huff_offset -= 1 << sign_shift;
226
227 return sign_huff_offset;
228}
229
230/** Read a sample, consisting of either, both or neither of entropy-coded MSBs
231 * and plain LSBs. */
232
233static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
234 unsigned int substr, unsigned int pos)
235{
236 SubStream *s = &m->substream[substr];
237 unsigned int mat, channel;
238
239 for (mat = 0; mat < s->num_primitive_matrices; mat++)
240 if (s->lsb_bypass[mat])
241 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
242
243 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
22fb814c 244 ChannelParams *cp = &s->channel_params[channel];
f53acb7b 245 int codebook = cp->codebook;
b517af05 246 int quant_step_size = s->quant_step_size[channel];
f53acb7b 247 int lsb_bits = cp->huff_lsbs - quant_step_size;
b517af05
RP
248 int result = 0;
249
250 if (codebook > 0)
251 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
252 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
253
254 if (result < 0)
82be06bb 255 return AVERROR_INVALIDDATA;
b517af05
RP
256
257 if (lsb_bits > 0)
258 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
259
f53acb7b 260 result += cp->sign_huff_offset;
b517af05
RP
261 result <<= quant_step_size;
262
263 m->sample_buffer[pos + s->blockpos][channel] = result;
264 }
265
266 return 0;
267}
268
269static av_cold int mlp_decode_init(AVCodecContext *avctx)
270{
271 MLPDecodeContext *m = avctx->priv_data;
272 int substr;
273
274 init_static();
275 m->avctx = avctx;
276 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
277 m->substream[substr].lossless_check_data = 0xffffffff;
2d6caade 278 ff_mlpdsp_init(&m->dsp);
ee1a8f62 279
b517af05
RP
280 return 0;
281}
282
283/** Read a major sync info header - contains high level information about
284 * the stream - sample rate, channel arrangement etc. Most of this
285 * information is not actually necessary for decoding, only for playback.
286 */
287
288static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
289{
290 MLPHeaderInfo mh;
82be06bb 291 int substr, ret;
b517af05 292
82be06bb
JR
293 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
294 return ret;
b517af05
RP
295
296 if (mh.group1_bits == 0) {
9906a2be 297 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
82be06bb 298 return AVERROR_INVALIDDATA;
b517af05
RP
299 }
300 if (mh.group2_bits > mh.group1_bits) {
301 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 302 "Channel group 2 cannot have more bits per sample than group 1.\n");
82be06bb 303 return AVERROR_INVALIDDATA;
b517af05
RP
304 }
305
306 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
307 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 308 "Channel groups with differing sample rates are not currently supported.\n");
82be06bb 309 return AVERROR_INVALIDDATA;
b517af05
RP
310 }
311
312 if (mh.group1_samplerate == 0) {
9906a2be 313 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
82be06bb 314 return AVERROR_INVALIDDATA;
b517af05
RP
315 }
316 if (mh.group1_samplerate > MAX_SAMPLERATE) {
317 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 318 "Sampling rate %d is greater than the supported maximum (%d).\n",
b517af05 319 mh.group1_samplerate, MAX_SAMPLERATE);
82be06bb 320 return AVERROR_INVALIDDATA;
b517af05
RP
321 }
322 if (mh.access_unit_size > MAX_BLOCKSIZE) {
323 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 324 "Block size %d is greater than the supported maximum (%d).\n",
b517af05 325 mh.access_unit_size, MAX_BLOCKSIZE);
82be06bb 326 return AVERROR_INVALIDDATA;
b517af05
RP
327 }
328 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
329 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 330 "Block size pow2 %d is greater than the supported maximum (%d).\n",
b517af05 331 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
82be06bb 332 return AVERROR_INVALIDDATA;
b517af05
RP
333 }
334
335 if (mh.num_substreams == 0)
82be06bb 336 return AVERROR_INVALIDDATA;
36ef5369 337 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
932cee5d 338 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
82be06bb 339 return AVERROR_INVALIDDATA;
932cee5d 340 }
b517af05 341 if (mh.num_substreams > MAX_SUBSTREAMS) {
6d97484d
DB
342 avpriv_request_sample(m->avctx,
343 "%d substreams (more than the "
344 "maximum supported by the decoder)",
345 mh.num_substreams);
ca085e66 346 return AVERROR_PATCHWELCOME;
b517af05
RP
347 }
348
349 m->access_unit_size = mh.access_unit_size;
350 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
351
352 m->num_substreams = mh.num_substreams;
353 m->max_decoded_substream = m->num_substreams - 1;
354
355 m->avctx->sample_rate = mh.group1_samplerate;
356 m->avctx->frame_size = mh.access_unit_size;
357
97679e6e 358 m->avctx->bits_per_raw_sample = mh.group1_bits;
c687643c 359 if (mh.group1_bits > 16)
5d6e4c16 360 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
ee1a8f62 361 else
5d6e4c16 362 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
b517af05
RP
363
364 m->params_valid = 1;
365 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
366 m->substream[substr].restart_seen = 0;
367
99ccd2ba
TW
368 /* Set the layout for each substream. When there's more than one, the first
369 * substream is Stereo. Subsequent substreams' layouts are indicated in the
370 * major sync. */
371 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
372 if ((substr = (mh.num_substreams > 1)))
373 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
374 m->substream[substr].ch_layout = mh.channel_layout_mlp;
375 } else {
376 if ((substr = (mh.num_substreams > 1)))
377 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
378 if (mh.num_substreams > 2)
379 if (mh.channel_layout_thd_stream2)
380 m->substream[2].ch_layout = mh.channel_layout_thd_stream2;
381 else
382 m->substream[2].ch_layout = mh.channel_layout_thd_stream1;
383 m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;
384 }
385
4b7f1a7c
TW
386 /* Parse the TrueHD decoder channel modifiers and set each substream's
387 * AVMatrixEncoding accordingly.
388 *
389 * The meaning of the modifiers depends on the channel layout:
390 *
391 * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
392 *
393 * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
394 *
395 * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
396 * layouts with an Ls/Rs channel pair
397 */
398 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
399 m->substream[substr].matrix_encoding = AV_MATRIX_ENCODING_NONE;
400 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
401 if (mh.num_substreams > 2 &&
402 mh.channel_layout_thd_stream2 & AV_CH_SIDE_LEFT &&
403 mh.channel_layout_thd_stream2 & AV_CH_SIDE_RIGHT &&
404 mh.channel_modifier_thd_stream2 == THD_CH_MODIFIER_SURROUNDEX)
405 m->substream[2].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
406
407 if (mh.num_substreams > 1 &&
408 mh.channel_layout_thd_stream1 & AV_CH_SIDE_LEFT &&
409 mh.channel_layout_thd_stream1 & AV_CH_SIDE_RIGHT &&
410 mh.channel_modifier_thd_stream1 == THD_CH_MODIFIER_SURROUNDEX)
411 m->substream[1].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
412
413 if (mh.num_substreams > 0)
414 switch (mh.channel_modifier_thd_stream0) {
415 case THD_CH_MODIFIER_LTRT:
416 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
417 break;
418 case THD_CH_MODIFIER_LBINRBIN:
419 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
420 break;
421 default:
422 break;
423 }
424 }
425
b517af05
RP
426 return 0;
427}
428
429/** Read a restart header from a block in a substream. This contains parameters
430 * required to decode the audio that do not change very often. Generally
431 * (always) present only in blocks following a major sync. */
432
433static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
434 const uint8_t *buf, unsigned int substr)
435{
436 SubStream *s = &m->substream[substr];
437 unsigned int ch;
438 int sync_word, tmp;
439 uint8_t checksum;
440 uint8_t lossless_check;
441 int start_count = get_bits_count(gbp);
e9d394f3
LB
442 int min_channel, max_channel, max_matrix_channel;
443 const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
444 ? MAX_MATRIX_CHANNEL_MLP
445 : MAX_MATRIX_CHANNEL_TRUEHD;
b517af05
RP
446
447 sync_word = get_bits(gbp, 13);
448
e8d341ce 449 if (sync_word != 0x31ea >> 1) {
b517af05 450 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 451 "restart header sync incorrect (got 0x%04x)\n", sync_word);
82be06bb 452 return AVERROR_INVALIDDATA;
b517af05 453 }
b517af05 454
e8d341ce
RP
455 s->noise_type = get_bits1(gbp);
456
36ef5369 457 if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
e8d341ce 458 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
82be06bb 459 return AVERROR_INVALIDDATA;
e8d341ce
RP
460 }
461
b517af05
RP
462 skip_bits(gbp, 16); /* Output timestamp */
463
e9d394f3
LB
464 min_channel = get_bits(gbp, 4);
465 max_channel = get_bits(gbp, 4);
466 max_matrix_channel = get_bits(gbp, 4);
b517af05 467
e9d394f3 468 if (max_matrix_channel > std_max_matrix_channel) {
868170c4
RP
469 av_log(m->avctx, AV_LOG_ERROR,
470 "Max matrix channel cannot be greater than %d.\n",
471 max_matrix_channel);
82be06bb 472 return AVERROR_INVALIDDATA;
868170c4
RP
473 }
474
e9d394f3 475 if (max_channel != max_matrix_channel) {
868170c4
RP
476 av_log(m->avctx, AV_LOG_ERROR,
477 "Max channel must be equal max matrix channel.\n");
82be06bb 478 return AVERROR_INVALIDDATA;
868170c4
RP
479 }
480
e2822726
RP
481 /* This should happen for TrueHD streams with >6 channels and MLP's noise
482 * type. It is not yet known if this is allowed. */
483 if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
6d97484d
DB
484 avpriv_request_sample(m->avctx,
485 "%d channels (more than the "
486 "maximum supported by the decoder)",
487 s->max_channel + 2);
ca085e66 488 return AVERROR_PATCHWELCOME;
e2822726
RP
489 }
490
e9d394f3 491 if (min_channel > max_channel) {
b517af05
RP
492 av_log(m->avctx, AV_LOG_ERROR,
493 "Substream min channel cannot be greater than max channel.\n");
82be06bb 494 return AVERROR_INVALIDDATA;
b517af05
RP
495 }
496
e9d394f3
LB
497 s->min_channel = min_channel;
498 s->max_channel = max_channel;
499 s->max_matrix_channel = max_matrix_channel;
500
ed1b0113 501#if FF_API_REQUEST_CHANNELS
7950e519 502FF_DISABLE_DEPRECATION_WARNINGS
ed1b0113
TW
503 if (m->avctx->request_channels > 0 &&
504 m->avctx->request_channels <= s->max_channel + 1 &&
505 m->max_decoded_substream > substr) {
d780511b 506 av_log(m->avctx, AV_LOG_DEBUG,
ed1b0113 507 "Extracting %d-channel downmix from substream %d. "
b517af05
RP
508 "Further substreams will be skipped.\n",
509 s->max_channel + 1, substr);
510 m->max_decoded_substream = substr;
ed1b0113 511 } else
7950e519 512FF_ENABLE_DEPRECATION_WARNINGS
ed1b0113 513#endif
f90a4bfc 514 if (m->avctx->request_channel_layout && (s->ch_layout & m->avctx->request_channel_layout) ==
c0c45188 515 m->avctx->request_channel_layout && m->max_decoded_substream > substr) {
ed1b0113
TW
516 av_log(m->avctx, AV_LOG_DEBUG,
517 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
518 "Further substreams will be skipped.\n",
519 s->max_channel + 1, s->ch_layout, substr);
520 m->max_decoded_substream = substr;
b517af05
RP
521 }
522
523 s->noise_shift = get_bits(gbp, 4);
524 s->noisegen_seed = get_bits(gbp, 23);
525
526 skip_bits(gbp, 19);
527
528 s->data_check_present = get_bits1(gbp);
529 lossless_check = get_bits(gbp, 8);
530 if (substr == m->max_decoded_substream
531 && s->lossless_check_data != 0xffffffff) {
a7cc783d 532 tmp = xor_32_to_8(s->lossless_check_data);
b517af05
RP
533 if (tmp != lossless_check)
534 av_log(m->avctx, AV_LOG_WARNING,
9906a2be 535 "Lossless check failed - expected %02x, calculated %02x.\n",
b517af05 536 lossless_check, tmp);
b517af05
RP
537 }
538
539 skip_bits(gbp, 16);
540
9731e7f1
RP
541 memset(s->ch_assign, 0, sizeof(s->ch_assign));
542
b517af05
RP
543 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
544 int ch_assign = get_bits(gbp, 6);
3ffcccb4
TW
545 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
546 uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
547 ch_assign);
548 ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
549 channel);
550 }
9731e7f1 551 if (ch_assign > s->max_matrix_channel) {
6d97484d
DB
552 avpriv_request_sample(m->avctx,
553 "Assignment of matrix channel %d to invalid output channel %d",
554 ch, ch_assign);
ca085e66 555 return AVERROR_PATCHWELCOME;
b517af05 556 }
9731e7f1 557 s->ch_assign[ch_assign] = ch;
b517af05
RP
558 }
559
ce15710f 560 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
b517af05
RP
561
562 if (checksum != get_bits(gbp, 8))
9906a2be 563 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
b517af05 564
9906a2be 565 /* Set default decoding parameters. */
b517af05
RP
566 s->param_presence_flags = 0xff;
567 s->num_primitive_matrices = 0;
568 s->blocksize = 8;
569 s->lossless_check_data = 0;
570
571 memset(s->output_shift , 0, sizeof(s->output_shift ));
572 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
573
574 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
22fb814c 575 ChannelParams *cp = &s->channel_params[ch];
f53acb7b
RP
576 cp->filter_params[FIR].order = 0;
577 cp->filter_params[IIR].order = 0;
578 cp->filter_params[FIR].shift = 0;
579 cp->filter_params[IIR].shift = 0;
b517af05 580
9906a2be 581 /* Default audio coding is 24-bit raw PCM. */
f53acb7b
RP
582 cp->huff_offset = 0;
583 cp->sign_huff_offset = (-1) << 23;
584 cp->codebook = 0;
585 cp->huff_lsbs = 24;
b517af05
RP
586 }
587
1fd2deed
TW
588 if (substr == m->max_decoded_substream) {
589 m->avctx->channels = s->max_matrix_channel + 1;
590 m->avctx->channel_layout = s->ch_layout;
591 }
b517af05
RP
592
593 return 0;
594}
595
596/** Read parameters for one of the prediction filters. */
597
598static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
22fb814c
NB
599 unsigned int substr, unsigned int channel,
600 unsigned int filter)
b517af05 601{
22fb814c
NB
602 SubStream *s = &m->substream[substr];
603 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
0c5670a0 604 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
b517af05
RP
605 const char fchar = filter ? 'I' : 'F';
606 int i, order;
607
9906a2be 608 // Filter is 0 for FIR, 1 for IIR.
b517af05
RP
609 assert(filter < 2);
610
5d9e4eaa
RP
611 if (m->filter_changed[channel][filter]++ > 1) {
612 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
82be06bb 613 return AVERROR_INVALIDDATA;
5d9e4eaa 614 }
75428fa4 615
b517af05 616 order = get_bits(gbp, 4);
0c5670a0 617 if (order > max_order) {
b517af05 618 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 619 "%cIR filter order %d is greater than maximum %d.\n",
0c5670a0 620 fchar, order, max_order);
82be06bb 621 return AVERROR_INVALIDDATA;
b517af05 622 }
d6aa052d 623 fp->order = order;
b517af05
RP
624
625 if (order > 0) {
22fb814c 626 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
b517af05
RP
627 int coeff_bits, coeff_shift;
628
d6aa052d 629 fp->shift = get_bits(gbp, 4);
b517af05
RP
630
631 coeff_bits = get_bits(gbp, 5);
632 coeff_shift = get_bits(gbp, 3);
633 if (coeff_bits < 1 || coeff_bits > 16) {
634 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 635 "%cIR filter coeff_bits must be between 1 and 16.\n",
b517af05 636 fchar);
82be06bb 637 return AVERROR_INVALIDDATA;
b517af05
RP
638 }
639 if (coeff_bits + coeff_shift > 16) {
640 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 641 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
b517af05 642 fchar);
82be06bb 643 return AVERROR_INVALIDDATA;
b517af05
RP
644 }
645
646 for (i = 0; i < order; i++)
13bd2044 647 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
b517af05
RP
648
649 if (get_bits1(gbp)) {
650 int state_bits, state_shift;
651
652 if (filter == FIR) {
653 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 654 "FIR filter has state data specified.\n");
82be06bb 655 return AVERROR_INVALIDDATA;
b517af05
RP
656 }
657
658 state_bits = get_bits(gbp, 4);
659 state_shift = get_bits(gbp, 4);
660
9906a2be 661 /* TODO: Check validity of state data. */
b517af05
RP
662
663 for (i = 0; i < order; i++)
db01fa13 664 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
b517af05
RP
665 }
666 }
667
668 return 0;
669}
670
f8e6293b
RP
671/** Read parameters for primitive matrices. */
672
95c14b1e 673static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
f8e6293b 674{
95c14b1e 675 SubStream *s = &m->substream[substr];
f8e6293b 676 unsigned int mat, ch;
36ef5369 677 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
309616b2
RP
678 ? MAX_MATRICES_MLP
679 : MAX_MATRICES_TRUEHD;
f8e6293b 680
5d9e4eaa
RP
681 if (m->matrix_changed++ > 1) {
682 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
82be06bb 683 return AVERROR_INVALIDDATA;
5d9e4eaa
RP
684 }
685
f8e6293b
RP
686 s->num_primitive_matrices = get_bits(gbp, 4);
687
309616b2
RP
688 if (s->num_primitive_matrices > max_primitive_matrices) {
689 av_log(m->avctx, AV_LOG_ERROR,
690 "Number of primitive matrices cannot be greater than %d.\n",
691 max_primitive_matrices);
82be06bb 692 return AVERROR_INVALIDDATA;
309616b2
RP
693 }
694
f8e6293b
RP
695 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
696 int frac_bits, max_chan;
697 s->matrix_out_ch[mat] = get_bits(gbp, 4);
698 frac_bits = get_bits(gbp, 4);
699 s->lsb_bypass [mat] = get_bits1(gbp);
700
0091d8a1 701 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
f8e6293b
RP
702 av_log(m->avctx, AV_LOG_ERROR,
703 "Invalid channel %d specified as output from matrix.\n",
704 s->matrix_out_ch[mat]);
82be06bb 705 return AVERROR_INVALIDDATA;
f8e6293b
RP
706 }
707 if (frac_bits > 14) {
708 av_log(m->avctx, AV_LOG_ERROR,
709 "Too many fractional bits specified.\n");
82be06bb 710 return AVERROR_INVALIDDATA;
f8e6293b
RP
711 }
712
713 max_chan = s->max_matrix_channel;
714 if (!s->noise_type)
715 max_chan+=2;
716
717 for (ch = 0; ch <= max_chan; ch++) {
718 int coeff_val = 0;
719 if (get_bits1(gbp))
720 coeff_val = get_sbits(gbp, frac_bits + 2);
721
722 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
723 }
724
725 if (s->noise_type)
726 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
727 else
728 s->matrix_noise_shift[mat] = 0;
729 }
730
731 return 0;
732}
733
43ee5fe0
RP
734/** Read channel parameters. */
735
736static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
737 GetBitContext *gbp, unsigned int ch)
738{
22fb814c
NB
739 SubStream *s = &m->substream[substr];
740 ChannelParams *cp = &s->channel_params[ch];
43ee5fe0
RP
741 FilterParams *fir = &cp->filter_params[FIR];
742 FilterParams *iir = &cp->filter_params[IIR];
82be06bb 743 int ret;
43ee5fe0
RP
744
745 if (s->param_presence_flags & PARAM_FIR)
746 if (get_bits1(gbp))
82be06bb
JR
747 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
748 return ret;
43ee5fe0
RP
749
750 if (s->param_presence_flags & PARAM_IIR)
751 if (get_bits1(gbp))
82be06bb
JR
752 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
753 return ret;
43ee5fe0 754
125cf771
RP
755 if (fir->order + iir->order > 8) {
756 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
82be06bb 757 return AVERROR_INVALIDDATA;
125cf771
RP
758 }
759
43ee5fe0
RP
760 if (fir->order && iir->order &&
761 fir->shift != iir->shift) {
762 av_log(m->avctx, AV_LOG_ERROR,
763 "FIR and IIR filters must use the same precision.\n");
82be06bb 764 return AVERROR_INVALIDDATA;
43ee5fe0
RP
765 }
766 /* The FIR and IIR filters must have the same precision.
aff42ee0
RP
767 * To simplify the filtering code, only the precision of the
768 * FIR filter is considered. If only the IIR filter is employed,
769 * the FIR filter precision is set to that of the IIR filter, so
770 * that the filtering code can use it. */
43ee5fe0
RP
771 if (!fir->order && iir->order)
772 fir->shift = iir->shift;
773
774 if (s->param_presence_flags & PARAM_HUFFOFFSET)
775 if (get_bits1(gbp))
776 cp->huff_offset = get_sbits(gbp, 15);
777
778 cp->codebook = get_bits(gbp, 2);
779 cp->huff_lsbs = get_bits(gbp, 5);
780
125cf771
RP
781 if (cp->huff_lsbs > 24) {
782 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
82be06bb 783 return AVERROR_INVALIDDATA;
125cf771 784 }
43ee5fe0 785
125cf771 786 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
43ee5fe0
RP
787
788 return 0;
789}
790
b517af05
RP
791/** Read decoding parameters that change more often than those in the restart
792 * header. */
793
794static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
795 unsigned int substr)
796{
797 SubStream *s = &m->substream[substr];
f8e6293b 798 unsigned int ch;
82be06bb 799 int ret;
b517af05 800
cbf3cf19 801 if (s->param_presence_flags & PARAM_PRESENCE)
f95f6ab9
RP
802 if (get_bits1(gbp))
803 s->param_presence_flags = get_bits(gbp, 8);
b517af05
RP
804
805 if (s->param_presence_flags & PARAM_BLOCKSIZE)
806 if (get_bits1(gbp)) {
807 s->blocksize = get_bits(gbp, 9);
b864098c
RP
808 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
809 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
b517af05 810 s->blocksize = 0;
82be06bb 811 return AVERROR_INVALIDDATA;
b517af05
RP
812 }
813 }
814
815 if (s->param_presence_flags & PARAM_MATRIX)
f95f6ab9 816 if (get_bits1(gbp))
82be06bb
JR
817 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
818 return ret;
b517af05
RP
819
820 if (s->param_presence_flags & PARAM_OUTSHIFT)
821 if (get_bits1(gbp))
f95f6ab9 822 for (ch = 0; ch <= s->max_matrix_channel; ch++)
af048026 823 s->output_shift[ch] = get_sbits(gbp, 4);
b517af05
RP
824
825 if (s->param_presence_flags & PARAM_QUANTSTEP)
826 if (get_bits1(gbp))
827 for (ch = 0; ch <= s->max_channel; ch++) {
22fb814c 828 ChannelParams *cp = &s->channel_params[ch];
f53acb7b 829
b517af05 830 s->quant_step_size[ch] = get_bits(gbp, 4);
b517af05 831
f53acb7b 832 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
b517af05
RP
833 }
834
835 for (ch = s->min_channel; ch <= s->max_channel; ch++)
f95f6ab9 836 if (get_bits1(gbp))
82be06bb
JR
837 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
838 return ret;
b517af05
RP
839
840 return 0;
841}
842
843#define MSB_MASK(bits) (-1u << bits)
844
845/** Generate PCM samples using the prediction filters and residual values
846 * read from the data stream, and update the filter state. */
847
848static void filter_channel(MLPDecodeContext *m, unsigned int substr,
849 unsigned int channel)
850{
851 SubStream *s = &m->substream[substr];
22fb814c 852 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
13bd2044
RP
853 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
854 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
855 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
22fb814c
NB
856 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
857 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
e71365f4 858 unsigned int filter_shift = fir->shift;
b517af05 859 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
b517af05 860
77b12f80
RP
861 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
862 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
b517af05 863
13bd2044
RP
864 m->dsp.mlp_filter_channel(firbuf, fircoeff,
865 fir->order, iir->order,
bf4f19dc
RP
866 filter_shift, mask, s->blocksize,
867 &m->sample_buffer[s->blockpos][channel]);
b517af05 868
bf4f19dc
RP
869 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
870 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
b517af05
RP
871}
872
873/** Read a block of PCM residual data (or actual if no filtering active). */
874
875static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
876 unsigned int substr)
877{
878 SubStream *s = &m->substream[substr];
879 unsigned int i, ch, expected_stream_pos = 0;
82be06bb 880 int ret;
b517af05
RP
881
882 if (s->data_check_present) {
883 expected_stream_pos = get_bits_count(gbp);
884 expected_stream_pos += get_bits(gbp, 16);
6d97484d
DB
885 avpriv_request_sample(m->avctx,
886 "Substreams with VLC block size check info");
b517af05
RP
887 }
888
889 if (s->blockpos + s->blocksize > m->access_unit_size) {
9906a2be 890 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
82be06bb 891 return AVERROR_INVALIDDATA;
b517af05
RP
892 }
893
894 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
895 s->blocksize * sizeof(m->bypassed_lsbs[0]));
896
f95f6ab9 897 for (i = 0; i < s->blocksize; i++)
82be06bb
JR
898 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
899 return ret;
b517af05 900
f95f6ab9 901 for (ch = s->min_channel; ch <= s->max_channel; ch++)
b517af05 902 filter_channel(m, substr, ch);
b517af05
RP
903
904 s->blockpos += s->blocksize;
905
906 if (s->data_check_present) {
907 if (get_bits_count(gbp) != expected_stream_pos)
9906a2be 908 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
b517af05
RP
909 skip_bits(gbp, 8);
910 }
911
912 return 0;
913}
914
9906a2be 915/** Data table used for TrueHD noise generation function. */
b517af05
RP
916
917static const int8_t noise_table[256] = {
918 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
919 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
920 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
921 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
922 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
923 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
924 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
925 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
926 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
927 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
928 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
929 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
930 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
931 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
932 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
933 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
934};
935
936/** Noise generation functions.
937 * I'm not sure what these are for - they seem to be some kind of pseudorandom
938 * sequence generators, used to generate noise data which is used when the
939 * channels are rematrixed. I'm not sure if they provide a practical benefit
940 * to compression, or just obfuscate the decoder. Are they for some kind of
941 * dithering? */
942
943/** Generate two channels of noise, used in the matrix when
944 * restart sync word == 0x31ea. */
945
946static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
947{
948 SubStream *s = &m->substream[substr];
949 unsigned int i;
950 uint32_t seed = s->noisegen_seed;
951 unsigned int maxchan = s->max_matrix_channel;
952
953 for (i = 0; i < s->blockpos; i++) {
954 uint16_t seed_shr7 = seed >> 7;
955 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
956 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
957
958 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
959 }
960
961 s->noisegen_seed = seed;
962}
963
964/** Generate a block of noise, used when restart sync word == 0x31eb. */
965
966static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
967{
968 SubStream *s = &m->substream[substr];
969 unsigned int i;
970 uint32_t seed = s->noisegen_seed;
971
972 for (i = 0; i < m->access_unit_size_pow2; i++) {
973 uint8_t seed_shr15 = seed >> 15;
974 m->noise_buffer[i] = noise_table[seed_shr15];
975 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
976 }
977
978 s->noisegen_seed = seed;
979}
980
981
982/** Apply the channel matrices in turn to reconstruct the original audio
983 * samples. */
984
985static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
986{
987 SubStream *s = &m->substream[substr];
4e5aa080 988 unsigned int mat;
b517af05
RP
989 unsigned int maxchan;
990
991 maxchan = s->max_matrix_channel;
992 if (!s->noise_type) {
993 generate_2_noise_channels(m, substr);
994 maxchan += 2;
995 } else {
996 fill_noise_buffer(m, substr);
997 }
998
999 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
b517af05 1000 unsigned int dest_ch = s->matrix_out_ch[mat];
4e5aa080
BA
1001 m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1002 s->matrix_coeff[mat],
1003 &m->bypassed_lsbs[0][mat],
1004 m->noise_buffer,
1005 s->num_primitive_matrices - mat,
1006 dest_ch,
1007 s->blockpos,
1008 maxchan,
1009 s->matrix_noise_shift[mat],
1010 m->access_unit_size_pow2,
1011 MSB_MASK(s->quant_step_size[dest_ch]));
b517af05
RP
1012 }
1013}
1014
1015/** Write the audio data into the output buffer. */
1016
e1b8d88d 1017static int output_data(MLPDecodeContext *m, unsigned int substr,
dc33fbbf 1018 AVFrame *frame, int *got_frame_ptr)
b517af05 1019{
0eea2129 1020 AVCodecContext *avctx = m->avctx;
b517af05 1021 SubStream *s = &m->substream[substr];
9731e7f1 1022 unsigned int i, out_ch = 0;
0eea2129
JR
1023 int32_t *data_32;
1024 int16_t *data_16;
1025 int ret;
e1b8d88d 1026 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
b517af05 1027
caa84585
JR
1028 if (m->avctx->channels != s->max_matrix_channel + 1) {
1029 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1030 return AVERROR_INVALIDDATA;
1031 }
0dff40bf
AK
1032
1033 if (!s->blockpos) {
1034 av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1035 return AVERROR_INVALIDDATA;
1036 }
caa84585 1037
0eea2129 1038 /* get output buffer */
dc33fbbf 1039 frame->nb_samples = s->blockpos;
759001c5 1040 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
0eea2129
JR
1041 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1042 return ret;
1043 }
dc33fbbf
JR
1044 data_32 = (int32_t *)frame->data[0];
1045 data_16 = (int16_t *)frame->data[0];
b517af05
RP
1046
1047 for (i = 0; i < s->blockpos; i++) {
9731e7f1
RP
1048 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
1049 int mat_ch = s->ch_assign[out_ch];
1050 int32_t sample = m->sample_buffer[i][mat_ch]
1051 << s->output_shift[mat_ch];
1052 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
b517af05
RP
1053 if (is32) *data_32++ = sample << 8;
1054 else *data_16++ = sample >> 8;
1055 }
1056 }
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;
b517af05
RP
1102 header_size += 28;
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,
0eea2129 1275 .capabilities = 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,
0eea2129 1287 .capabilities = CODEC_CAP_DR1,
9ba4821d
RP
1288};
1289#endif /* CONFIG_TRUEHD_DECODER */