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