optimize ac3_downmix.
[libav.git] / libavcodec / mlpdec.c
CommitLineData
b517af05
RP
1/*
2 * MLP decoder
3 * Copyright (c) 2007-2008 Ian Caulfield
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22/**
23 * @file mlpdec.c
24 * MLP decoder
25 */
26
0e74e1ff
DB
27#include <stdint.h>
28
b517af05
RP
29#include "avcodec.h"
30#include "libavutil/intreadwrite.h"
31#include "bitstream.h"
32#include "libavutil/crc.h"
33#include "parser.h"
34#include "mlp_parser.h"
35
36/** Maximum number of channels that can be decoded. */
37#define MAX_CHANNELS 16
38
9906a2be 39/** Maximum number of matrices used in decoding; most streams have one matrix
b517af05
RP
40 * per output channel, but some rematrix a channel (usually 0) more than once.
41 */
42
43#define MAX_MATRICES 15
44
45/** Maximum number of substreams that can be decoded. This could also be set
9906a2be 46 * higher, but I haven't seen any examples with more than two. */
b517af05
RP
47#define MAX_SUBSTREAMS 2
48
9906a2be 49/** maximum sample frequency seen in files */
b517af05
RP
50#define MAX_SAMPLERATE 192000
51
9906a2be 52/** maximum number of audio samples within one access unit */
b517af05 53#define MAX_BLOCKSIZE (40 * (MAX_SAMPLERATE / 48000))
9906a2be 54/** next power of two greater than MAX_BLOCKSIZE */
b517af05
RP
55#define MAX_BLOCKSIZE_POW2 (64 * (MAX_SAMPLERATE / 48000))
56
9906a2be 57/** number of allowed filters */
b517af05
RP
58#define NUM_FILTERS 2
59
9906a2be 60/** The maximum number of taps in either the IIR or FIR filter;
b517af05
RP
61 * I believe MLP actually specifies the maximum order for IIR filters as four,
62 * and that the sum of the orders of both filters must be <= 8. */
63#define MAX_FILTER_ORDER 8
64
9906a2be 65/** number of bits used for VLC lookup - longest Huffman code is 9 */
b517af05
RP
66#define VLC_BITS 9
67
68
69static const char* sample_message =
70 "Please file a bug report following the instructions at "
71 "http://ffmpeg.mplayerhq.hu/bugreports.html and include "
72 "a sample of this file.";
73
74typedef struct SubStream {
9906a2be 75 //! Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
b517af05
RP
76 uint8_t restart_seen;
77
78 //@{
79 /** restart header data */
80 //! The type of noise to be used in the rematrix stage.
81 uint16_t noise_type;
82
83 //! The index of the first channel coded in this substream.
84 uint8_t min_channel;
85 //! The index of the last channel coded in this substream.
86 uint8_t max_channel;
87 //! The number of channels input into the rematrix stage.
88 uint8_t max_matrix_channel;
89
90 //! The left shift applied to random noise in 0x31ea substreams.
91 uint8_t noise_shift;
92 //! The current seed value for the pseudorandom noise generator(s).
93 uint32_t noisegen_seed;
94
95 //! Set if the substream contains extra info to check the size of VLC blocks.
96 uint8_t data_check_present;
97
98 //! Bitmask of which parameter sets are conveyed in a decoding parameter block.
99 uint8_t param_presence_flags;
100#define PARAM_BLOCKSIZE (1 << 7)
101#define PARAM_MATRIX (1 << 6)
102#define PARAM_OUTSHIFT (1 << 5)
103#define PARAM_QUANTSTEP (1 << 4)
104#define PARAM_FIR (1 << 3)
105#define PARAM_IIR (1 << 2)
106#define PARAM_HUFFOFFSET (1 << 1)
107 //@}
108
109 //@{
110 /** matrix data */
111
112 //! Number of matrices to be applied.
113 uint8_t num_primitive_matrices;
114
115 //! matrix output channel
116 uint8_t matrix_out_ch[MAX_MATRICES];
117
118 //! Whether the LSBs of the matrix output are encoded in the bitstream.
119 uint8_t lsb_bypass[MAX_MATRICES];
120 //! Matrix coefficients, stored as 2.14 fixed point.
121 int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS+2];
122 //! Left shift to apply to noise values in 0x31eb substreams.
123 uint8_t matrix_noise_shift[MAX_MATRICES];
124 //@}
125
9906a2be 126 //! Left shift to apply to Huffman-decoded residuals.
b517af05
RP
127 uint8_t quant_step_size[MAX_CHANNELS];
128
9906a2be 129 //! number of PCM samples in current audio block
b517af05
RP
130 uint16_t blocksize;
131 //! Number of PCM samples decoded so far in this frame.
132 uint16_t blockpos;
133
134 //! Left shift to apply to decoded PCM values to get final 24-bit output.
135 int8_t output_shift[MAX_CHANNELS];
136
137 //! Running XOR of all output samples.
138 int32_t lossless_check_data;
139
140} SubStream;
141
d6aa052d
RP
142#define FIR 0
143#define IIR 1
144
145/** filter data */
146typedef struct {
147 //! number of taps in filter
148 uint8_t order;
149 //! Right shift to apply to output of filter.
150 uint8_t shift;
151
152 int32_t coeff[MAX_FILTER_ORDER];
153 int32_t state[MAX_FILTER_ORDER];
154} FilterParams;
155
b517af05
RP
156typedef struct MLPDecodeContext {
157 AVCodecContext *avctx;
158
159 //! Set if a valid major sync block has been read. Otherwise no decoding is possible.
160 uint8_t params_valid;
161
162 //! Number of substreams contained within this stream.
163 uint8_t num_substreams;
164
165 //! Index of the last substream to decode - further substreams are skipped.
166 uint8_t max_decoded_substream;
167
9906a2be 168 //! number of PCM samples contained in each frame
b517af05 169 int access_unit_size;
9906a2be 170 //! next power of two above the number of samples in each frame
b517af05
RP
171 int access_unit_size_pow2;
172
173 SubStream substream[MAX_SUBSTREAMS];
174
d6aa052d 175 FilterParams filter_params[MAX_CHANNELS][NUM_FILTERS];
b517af05
RP
176
177 //@{
9906a2be 178 /** sample data coding information */
b517af05
RP
179 //! Offset to apply to residual values.
180 int16_t huff_offset[MAX_CHANNELS];
9906a2be 181 //! sign/rounding-corrected version of huff_offset
b517af05
RP
182 int32_t sign_huff_offset[MAX_CHANNELS];
183 //! Which VLC codebook to use to read residuals.
184 uint8_t codebook[MAX_CHANNELS];
185 //! Size of residual suffix not encoded using VLC.
186 uint8_t huff_lsbs[MAX_CHANNELS];
187 //@}
188
189 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
190 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
191 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS+2];
192} MLPDecodeContext;
193
9906a2be 194/** Tables defining the Huffman codes.
b517af05
RP
195 * There are three entropy coding methods used in MLP (four if you count
196 * "none" as a method). These use the same sequences for codes starting with
197 * 00 or 01, but have different codes starting with 1. */
198
199static const uint8_t huffman_tables[3][18][2] = {
9906a2be 200 { /* Huffman table 0, -7 - +10 */
b517af05
RP
201 {0x01, 9}, {0x01, 8}, {0x01, 7}, {0x01, 6}, {0x01, 5}, {0x01, 4}, {0x01, 3},
202 {0x04, 3}, {0x05, 3}, {0x06, 3}, {0x07, 3},
203 {0x03, 3}, {0x05, 4}, {0x09, 5}, {0x11, 6}, {0x21, 7}, {0x41, 8}, {0x81, 9},
9906a2be 204 }, { /* Huffman table 1, -7 - +8 */
b517af05
RP
205 {0x01, 9}, {0x01, 8}, {0x01, 7}, {0x01, 6}, {0x01, 5}, {0x01, 4}, {0x01, 3},
206 {0x02, 2}, {0x03, 2},
207 {0x03, 3}, {0x05, 4}, {0x09, 5}, {0x11, 6}, {0x21, 7}, {0x41, 8}, {0x81, 9},
9906a2be 208 }, { /* Huffman table 2, -7 - +7 */
b517af05
RP
209 {0x01, 9}, {0x01, 8}, {0x01, 7}, {0x01, 6}, {0x01, 5}, {0x01, 4}, {0x01, 3},
210 {0x01, 1},
211 {0x03, 3}, {0x05, 4}, {0x09, 5}, {0x11, 6}, {0x21, 7}, {0x41, 8}, {0x81, 9},
212 }
213};
214
215static VLC huff_vlc[3];
216
217static int crc_init = 0;
218static AVCRC crc_63[1024];
219static AVCRC crc_1D[1024];
220
221
222/** Initialize static data, constant between all invocations of the codec. */
223
224static av_cold void init_static()
225{
226 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
227 &huffman_tables[0][0][1], 2, 1,
228 &huffman_tables[0][0][0], 2, 1, 512);
229 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
230 &huffman_tables[1][0][1], 2, 1,
231 &huffman_tables[1][0][0], 2, 1, 512);
232 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
233 &huffman_tables[2][0][1], 2, 1,
234 &huffman_tables[2][0][0], 2, 1, 512);
235
236 if (!crc_init) {
237 av_crc_init(crc_63, 0, 8, 0x63, sizeof(crc_63));
238 av_crc_init(crc_1D, 0, 8, 0x1D, sizeof(crc_1D));
239 crc_init = 1;
240 }
241}
242
243
9906a2be
DB
244/** MLP uses checksums that seem to be based on the standard CRC algorithm, but
245 * are not (in implementation terms, the table lookup and XOR are reversed).
b517af05
RP
246 * We can implement this behavior using a standard av_crc on all but the
247 * last element, then XOR that with the last element. */
248
249static uint8_t mlp_checksum8(const uint8_t *buf, unsigned int buf_size)
250{
251 uint8_t checksum = av_crc(crc_63, 0x3c, buf, buf_size - 1); // crc_63[0xa2] == 0x3c
252 checksum ^= buf[buf_size-1];
253 return checksum;
254}
255
256/** Calculate an 8-bit checksum over a restart header -- a non-multiple-of-8
257 * number of bits, starting two bits into the first byte of buf. */
258
259static uint8_t mlp_restart_checksum(const uint8_t *buf, unsigned int bit_size)
260{
261 int i;
262 int num_bytes = (bit_size + 2) / 8;
263
264 int crc = crc_1D[buf[0] & 0x3f];
265 crc = av_crc(crc_1D, crc, buf + 1, num_bytes - 2);
266 crc ^= buf[num_bytes - 1];
267
268 for (i = 0; i < ((bit_size + 2) & 7); i++) {
269 crc <<= 1;
270 if (crc & 0x100)
271 crc ^= 0x11D;
272 crc ^= (buf[num_bytes] >> (7 - i)) & 1;
273 }
274
275 return crc;
276}
277
278static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
279 unsigned int substr, unsigned int ch)
280{
281 SubStream *s = &m->substream[substr];
282 int lsb_bits = m->huff_lsbs[ch] - s->quant_step_size[ch];
283 int sign_shift = lsb_bits + (m->codebook[ch] ? 2 - m->codebook[ch] : -1);
284 int32_t sign_huff_offset = m->huff_offset[ch];
285
286 if (m->codebook[ch] > 0)
287 sign_huff_offset -= 7 << lsb_bits;
288
289 if (sign_shift >= 0)
290 sign_huff_offset -= 1 << sign_shift;
291
292 return sign_huff_offset;
293}
294
295/** Read a sample, consisting of either, both or neither of entropy-coded MSBs
296 * and plain LSBs. */
297
298static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
299 unsigned int substr, unsigned int pos)
300{
301 SubStream *s = &m->substream[substr];
302 unsigned int mat, channel;
303
304 for (mat = 0; mat < s->num_primitive_matrices; mat++)
305 if (s->lsb_bypass[mat])
306 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
307
308 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
309 int codebook = m->codebook[channel];
310 int quant_step_size = s->quant_step_size[channel];
311 int lsb_bits = m->huff_lsbs[channel] - quant_step_size;
312 int result = 0;
313
314 if (codebook > 0)
315 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
316 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
317
318 if (result < 0)
319 return -1;
320
321 if (lsb_bits > 0)
322 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
323
324 result += m->sign_huff_offset[channel];
325 result <<= quant_step_size;
326
327 m->sample_buffer[pos + s->blockpos][channel] = result;
328 }
329
330 return 0;
331}
332
333static av_cold int mlp_decode_init(AVCodecContext *avctx)
334{
335 MLPDecodeContext *m = avctx->priv_data;
336 int substr;
337
338 init_static();
339 m->avctx = avctx;
340 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
341 m->substream[substr].lossless_check_data = 0xffffffff;
fd76c37f 342 avctx->sample_fmt = SAMPLE_FMT_S16;
b517af05
RP
343 return 0;
344}
345
346/** Read a major sync info header - contains high level information about
347 * the stream - sample rate, channel arrangement etc. Most of this
348 * information is not actually necessary for decoding, only for playback.
349 */
350
351static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
352{
353 MLPHeaderInfo mh;
354 int substr;
355
356 if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
357 return -1;
358
359 if (mh.group1_bits == 0) {
9906a2be 360 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
b517af05
RP
361 return -1;
362 }
363 if (mh.group2_bits > mh.group1_bits) {
364 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 365 "Channel group 2 cannot have more bits per sample than group 1.\n");
b517af05
RP
366 return -1;
367 }
368
369 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
370 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 371 "Channel groups with differing sample rates are not currently supported.\n");
b517af05
RP
372 return -1;
373 }
374
375 if (mh.group1_samplerate == 0) {
9906a2be 376 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
b517af05
RP
377 return -1;
378 }
379 if (mh.group1_samplerate > MAX_SAMPLERATE) {
380 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 381 "Sampling rate %d is greater than the supported maximum (%d).\n",
b517af05
RP
382 mh.group1_samplerate, MAX_SAMPLERATE);
383 return -1;
384 }
385 if (mh.access_unit_size > MAX_BLOCKSIZE) {
386 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 387 "Block size %d is greater than the supported maximum (%d).\n",
b517af05
RP
388 mh.access_unit_size, MAX_BLOCKSIZE);
389 return -1;
390 }
391 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
392 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 393 "Block size pow2 %d is greater than the supported maximum (%d).\n",
b517af05
RP
394 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
395 return -1;
396 }
397
398 if (mh.num_substreams == 0)
399 return -1;
400 if (mh.num_substreams > MAX_SUBSTREAMS) {
401 av_log(m->avctx, AV_LOG_ERROR,
9906a2be
DB
402 "Number of substreams %d is larger than the maximum supported "
403 "by the decoder. %s\n", mh.num_substreams, sample_message);
b517af05
RP
404 return -1;
405 }
406
407 m->access_unit_size = mh.access_unit_size;
408 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
409
410 m->num_substreams = mh.num_substreams;
411 m->max_decoded_substream = m->num_substreams - 1;
412
413 m->avctx->sample_rate = mh.group1_samplerate;
414 m->avctx->frame_size = mh.access_unit_size;
415
416#ifdef CONFIG_AUDIO_NONSHORT
417 m->avctx->bits_per_sample = mh.group1_bits;
418 if (mh.group1_bits > 16) {
419 m->avctx->sample_fmt = SAMPLE_FMT_S32;
420 }
421#endif
422
423 m->params_valid = 1;
424 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
425 m->substream[substr].restart_seen = 0;
426
427 return 0;
428}
429
430/** Read a restart header from a block in a substream. This contains parameters
431 * required to decode the audio that do not change very often. Generally
432 * (always) present only in blocks following a major sync. */
433
434static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
435 const uint8_t *buf, unsigned int substr)
436{
437 SubStream *s = &m->substream[substr];
438 unsigned int ch;
439 int sync_word, tmp;
440 uint8_t checksum;
441 uint8_t lossless_check;
442 int start_count = get_bits_count(gbp);
443
444 sync_word = get_bits(gbp, 13);
445
446 if (sync_word != 0x31ea >> 1) {
447 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 448 "restart header sync incorrect (got 0x%04x)\n", sync_word);
b517af05
RP
449 return -1;
450 }
451 s->noise_type = get_bits1(gbp);
452
453 skip_bits(gbp, 16); /* Output timestamp */
454
455 s->min_channel = get_bits(gbp, 4);
456 s->max_channel = get_bits(gbp, 4);
457 s->max_matrix_channel = get_bits(gbp, 4);
458
459 if (s->min_channel > s->max_channel) {
460 av_log(m->avctx, AV_LOG_ERROR,
461 "Substream min channel cannot be greater than max channel.\n");
462 return -1;
463 }
464
465 if (m->avctx->request_channels > 0
466 && s->max_channel + 1 >= m->avctx->request_channels
467 && substr < m->max_decoded_substream) {
468 av_log(m->avctx, AV_LOG_INFO,
469 "Extracting %d channel downmix from substream %d. "
470 "Further substreams will be skipped.\n",
471 s->max_channel + 1, substr);
472 m->max_decoded_substream = substr;
473 }
474
475 s->noise_shift = get_bits(gbp, 4);
476 s->noisegen_seed = get_bits(gbp, 23);
477
478 skip_bits(gbp, 19);
479
480 s->data_check_present = get_bits1(gbp);
481 lossless_check = get_bits(gbp, 8);
482 if (substr == m->max_decoded_substream
483 && s->lossless_check_data != 0xffffffff) {
484 tmp = s->lossless_check_data;
485 tmp ^= tmp >> 16;
486 tmp ^= tmp >> 8;
487 tmp &= 0xff;
488 if (tmp != lossless_check)
489 av_log(m->avctx, AV_LOG_WARNING,
9906a2be 490 "Lossless check failed - expected %02x, calculated %02x.\n",
b517af05
RP
491 lossless_check, tmp);
492 else
9906a2be 493 dprintf(m->avctx, "Lossless check passed for substream %d (%x).\n",
b517af05
RP
494 substr, tmp);
495 }
496
497 skip_bits(gbp, 16);
498
499 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
500 int ch_assign = get_bits(gbp, 6);
501 dprintf(m->avctx, "ch_assign[%d][%d] = %d\n", substr, ch,
502 ch_assign);
503 if (ch_assign != ch) {
504 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 505 "Non-1:1 channel assignments are used in this stream. %s\n",
b517af05
RP
506 sample_message);
507 return -1;
508 }
509 }
510
511 checksum = mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
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++) {
d6aa052d
RP
526 m->filter_params[ch][FIR].order = 0;
527 m->filter_params[ch][IIR].order = 0;
528 m->filter_params[ch][FIR].shift = 0;
529 m->filter_params[ch][IIR].shift = 0;
b517af05 530
9906a2be 531 /* Default audio coding is 24-bit raw PCM. */
b517af05
RP
532 m->huff_offset [ch] = 0;
533 m->sign_huff_offset[ch] = (-1) << 23;
534 m->codebook [ch] = 0;
535 m->huff_lsbs [ch] = 24;
536 }
537
538 if (substr == m->max_decoded_substream) {
539 m->avctx->channels = s->max_channel + 1;
540 }
541
542 return 0;
543}
544
545/** Read parameters for one of the prediction filters. */
546
547static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
548 unsigned int channel, unsigned int filter)
549{
d6aa052d 550 FilterParams *fp = &m->filter_params[channel][filter];
b517af05
RP
551 const char fchar = filter ? 'I' : 'F';
552 int i, order;
553
9906a2be 554 // Filter is 0 for FIR, 1 for IIR.
b517af05
RP
555 assert(filter < 2);
556
557 order = get_bits(gbp, 4);
558 if (order > MAX_FILTER_ORDER) {
559 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 560 "%cIR filter order %d is greater than maximum %d.\n",
b517af05
RP
561 fchar, order, MAX_FILTER_ORDER);
562 return -1;
563 }
d6aa052d 564 fp->order = order;
b517af05
RP
565
566 if (order > 0) {
567 int coeff_bits, coeff_shift;
568
d6aa052d 569 fp->shift = get_bits(gbp, 4);
b517af05
RP
570
571 coeff_bits = get_bits(gbp, 5);
572 coeff_shift = get_bits(gbp, 3);
573 if (coeff_bits < 1 || coeff_bits > 16) {
574 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 575 "%cIR filter coeff_bits must be between 1 and 16.\n",
b517af05
RP
576 fchar);
577 return -1;
578 }
579 if (coeff_bits + coeff_shift > 16) {
580 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 581 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
b517af05
RP
582 fchar);
583 return -1;
584 }
585
586 for (i = 0; i < order; i++)
db01fa13 587 fp->coeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
b517af05
RP
588
589 if (get_bits1(gbp)) {
590 int state_bits, state_shift;
591
592 if (filter == FIR) {
593 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 594 "FIR filter has state data specified.\n");
b517af05
RP
595 return -1;
596 }
597
598 state_bits = get_bits(gbp, 4);
599 state_shift = get_bits(gbp, 4);
600
9906a2be 601 /* TODO: Check validity of state data. */
b517af05
RP
602
603 for (i = 0; i < order; i++)
db01fa13 604 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
b517af05
RP
605 }
606 }
607
608 return 0;
609}
610
611/** Read decoding parameters that change more often than those in the restart
612 * header. */
613
614static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
615 unsigned int substr)
616{
617 SubStream *s = &m->substream[substr];
618 unsigned int mat, ch;
619
620 if (get_bits1(gbp))
621 s->param_presence_flags = get_bits(gbp, 8);
622
623 if (s->param_presence_flags & PARAM_BLOCKSIZE)
624 if (get_bits1(gbp)) {
625 s->blocksize = get_bits(gbp, 9);
626 if (s->blocksize > MAX_BLOCKSIZE) {
9906a2be 627 av_log(m->avctx, AV_LOG_ERROR, "block size too large\n");
b517af05
RP
628 s->blocksize = 0;
629 return -1;
630 }
631 }
632
633 if (s->param_presence_flags & PARAM_MATRIX)
634 if (get_bits1(gbp)) {
635 s->num_primitive_matrices = get_bits(gbp, 4);
636
637 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
638 int frac_bits, max_chan;
639 s->matrix_out_ch[mat] = get_bits(gbp, 4);
640 frac_bits = get_bits(gbp, 4);
641 s->lsb_bypass [mat] = get_bits1(gbp);
642
643 if (s->matrix_out_ch[mat] > s->max_channel) {
644 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 645 "Invalid channel %d specified as output from matrix.\n",
b517af05
RP
646 s->matrix_out_ch[mat]);
647 return -1;
648 }
649 if (frac_bits > 14) {
650 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 651 "Too many fractional bits specified.\n");
b517af05
RP
652 return -1;
653 }
654
655 max_chan = s->max_matrix_channel;
656 if (!s->noise_type)
657 max_chan+=2;
658
659 for (ch = 0; ch <= max_chan; ch++) {
660 int coeff_val = 0;
661 if (get_bits1(gbp))
662 coeff_val = get_sbits(gbp, frac_bits + 2);
663
664 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
665 }
666
667 if (s->noise_type)
668 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
669 else
670 s->matrix_noise_shift[mat] = 0;
671 }
672 }
673
674 if (s->param_presence_flags & PARAM_OUTSHIFT)
675 if (get_bits1(gbp))
676 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
677 s->output_shift[ch] = get_bits(gbp, 4);
678 dprintf(m->avctx, "output shift[%d] = %d\n",
679 ch, s->output_shift[ch]);
680 /* TODO: validate */
681 }
682
683 if (s->param_presence_flags & PARAM_QUANTSTEP)
684 if (get_bits1(gbp))
685 for (ch = 0; ch <= s->max_channel; ch++) {
686 s->quant_step_size[ch] = get_bits(gbp, 4);
687 /* TODO: validate */
688
689 m->sign_huff_offset[ch] = calculate_sign_huff(m, substr, ch);
690 }
691
692 for (ch = s->min_channel; ch <= s->max_channel; ch++)
693 if (get_bits1(gbp)) {
d6aa052d
RP
694 FilterParams *fir = &m->filter_params[ch][FIR];
695 FilterParams *iir = &m->filter_params[ch][IIR];
696
b517af05
RP
697 if (s->param_presence_flags & PARAM_FIR)
698 if (get_bits1(gbp))
699 if (read_filter_params(m, gbp, ch, FIR) < 0)
700 return -1;
701
702 if (s->param_presence_flags & PARAM_IIR)
703 if (get_bits1(gbp))
704 if (read_filter_params(m, gbp, ch, IIR) < 0)
705 return -1;
706
d6aa052d
RP
707 if (fir->order && iir->order &&
708 fir->shift != iir->shift) {
b517af05 709 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 710 "FIR and IIR filters must use the same precision.\n");
b517af05
RP
711 return -1;
712 }
713 /* The FIR and IIR filters must have the same precision.
714 * To simplify the filtering code, only the precision of the
715 * FIR filter is considered. If only the IIR filter is employed,
716 * the FIR filter precision is set to that of the IIR filter, so
717 * that the filtering code can use it. */
d6aa052d
RP
718 if (!fir->order && iir->order)
719 fir->shift = iir->shift;
b517af05
RP
720
721 if (s->param_presence_flags & PARAM_HUFFOFFSET)
722 if (get_bits1(gbp))
723 m->huff_offset[ch] = get_sbits(gbp, 15);
724
725 m->codebook [ch] = get_bits(gbp, 2);
726 m->huff_lsbs[ch] = get_bits(gbp, 5);
727
728 m->sign_huff_offset[ch] = calculate_sign_huff(m, substr, ch);
729
730 /* TODO: validate */
731 }
732
733 return 0;
734}
735
736#define MSB_MASK(bits) (-1u << bits)
737
738/** Generate PCM samples using the prediction filters and residual values
739 * read from the data stream, and update the filter state. */
740
741static void filter_channel(MLPDecodeContext *m, unsigned int substr,
742 unsigned int channel)
743{
744 SubStream *s = &m->substream[substr];
745 int32_t filter_state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FILTER_ORDER];
d6aa052d
RP
746 FilterParams *fp[NUM_FILTERS] = { &m->filter_params[channel][FIR],
747 &m->filter_params[channel][IIR], };
748 unsigned int filter_shift = fp[FIR]->shift;
b517af05
RP
749 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
750 int index = MAX_BLOCKSIZE;
751 int j, i;
752
753 for (j = 0; j < NUM_FILTERS; j++) {
db01fa13 754 memcpy(&filter_state_buffer[j][MAX_BLOCKSIZE], &fp[j]->state[0],
b517af05
RP
755 MAX_FILTER_ORDER * sizeof(int32_t));
756 }
757
758 for (i = 0; i < s->blocksize; i++) {
759 int32_t residual = m->sample_buffer[i + s->blockpos][channel];
760 unsigned int order;
761 int64_t accum = 0;
762 int32_t result;
763
764 /* TODO: Move this code to DSPContext? */
765
766 for (j = 0; j < NUM_FILTERS; j++)
d6aa052d 767 for (order = 0; order < fp[j]->order; order++)
b517af05 768 accum += (int64_t)filter_state_buffer[j][index + order] *
db01fa13 769 fp[j]->coeff[order];
b517af05
RP
770
771 accum = accum >> filter_shift;
772 result = (accum + residual) & mask;
773
774 --index;
775
776 filter_state_buffer[FIR][index] = result;
777 filter_state_buffer[IIR][index] = result - accum;
778
779 m->sample_buffer[i + s->blockpos][channel] = result;
780 }
781
782 for (j = 0; j < NUM_FILTERS; j++) {
db01fa13 783 memcpy(&fp[j]->state[0], &filter_state_buffer[j][index],
b517af05
RP
784 MAX_FILTER_ORDER * sizeof(int32_t));
785 }
786}
787
788/** Read a block of PCM residual data (or actual if no filtering active). */
789
790static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
791 unsigned int substr)
792{
793 SubStream *s = &m->substream[substr];
794 unsigned int i, ch, expected_stream_pos = 0;
795
796 if (s->data_check_present) {
797 expected_stream_pos = get_bits_count(gbp);
798 expected_stream_pos += get_bits(gbp, 16);
799 av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
800 "we have not tested yet. %s\n", sample_message);
801 }
802
803 if (s->blockpos + s->blocksize > m->access_unit_size) {
9906a2be 804 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
b517af05
RP
805 return -1;
806 }
807
808 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
809 s->blocksize * sizeof(m->bypassed_lsbs[0]));
810
811 for (i = 0; i < s->blocksize; i++) {
812 if (read_huff_channels(m, gbp, substr, i) < 0)
813 return -1;
814 }
815
816 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
817 filter_channel(m, substr, ch);
818 }
819
820 s->blockpos += s->blocksize;
821
822 if (s->data_check_present) {
823 if (get_bits_count(gbp) != expected_stream_pos)
9906a2be 824 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
b517af05
RP
825 skip_bits(gbp, 8);
826 }
827
828 return 0;
829}
830
9906a2be 831/** Data table used for TrueHD noise generation function. */
b517af05
RP
832
833static const int8_t noise_table[256] = {
834 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
835 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
836 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
837 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
838 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
839 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
840 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
841 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
842 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
843 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
844 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
845 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
846 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
847 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
848 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
849 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
850};
851
852/** Noise generation functions.
853 * I'm not sure what these are for - they seem to be some kind of pseudorandom
854 * sequence generators, used to generate noise data which is used when the
855 * channels are rematrixed. I'm not sure if they provide a practical benefit
856 * to compression, or just obfuscate the decoder. Are they for some kind of
857 * dithering? */
858
859/** Generate two channels of noise, used in the matrix when
860 * restart sync word == 0x31ea. */
861
862static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
863{
864 SubStream *s = &m->substream[substr];
865 unsigned int i;
866 uint32_t seed = s->noisegen_seed;
867 unsigned int maxchan = s->max_matrix_channel;
868
869 for (i = 0; i < s->blockpos; i++) {
870 uint16_t seed_shr7 = seed >> 7;
871 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
872 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
873
874 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
875 }
876
877 s->noisegen_seed = seed;
878}
879
880/** Generate a block of noise, used when restart sync word == 0x31eb. */
881
882static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
883{
884 SubStream *s = &m->substream[substr];
885 unsigned int i;
886 uint32_t seed = s->noisegen_seed;
887
888 for (i = 0; i < m->access_unit_size_pow2; i++) {
889 uint8_t seed_shr15 = seed >> 15;
890 m->noise_buffer[i] = noise_table[seed_shr15];
891 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
892 }
893
894 s->noisegen_seed = seed;
895}
896
897
898/** Apply the channel matrices in turn to reconstruct the original audio
899 * samples. */
900
901static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
902{
903 SubStream *s = &m->substream[substr];
904 unsigned int mat, src_ch, i;
905 unsigned int maxchan;
906
907 maxchan = s->max_matrix_channel;
908 if (!s->noise_type) {
909 generate_2_noise_channels(m, substr);
910 maxchan += 2;
911 } else {
912 fill_noise_buffer(m, substr);
913 }
914
915 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
916 int matrix_noise_shift = s->matrix_noise_shift[mat];
917 unsigned int dest_ch = s->matrix_out_ch[mat];
918 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
919
920 /* TODO: DSPContext? */
921
922 for (i = 0; i < s->blockpos; i++) {
923 int64_t accum = 0;
924 for (src_ch = 0; src_ch <= maxchan; src_ch++) {
925 accum += (int64_t)m->sample_buffer[i][src_ch]
926 * s->matrix_coeff[mat][src_ch];
927 }
928 if (matrix_noise_shift) {
929 uint32_t index = s->num_primitive_matrices - mat;
930 index = (i * (index * 2 + 1) + index) & (m->access_unit_size_pow2 - 1);
931 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
932 }
933 m->sample_buffer[i][dest_ch] = ((accum >> 14) & mask)
934 + m->bypassed_lsbs[i][mat];
935 }
936 }
937}
938
939/** Write the audio data into the output buffer. */
940
941static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
942 uint8_t *data, unsigned int *data_size, int is32)
943{
944 SubStream *s = &m->substream[substr];
945 unsigned int i, ch = 0;
946 int32_t *data_32 = (int32_t*) data;
947 int16_t *data_16 = (int16_t*) data;
948
949 if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
950 return -1;
951
952 for (i = 0; i < s->blockpos; i++) {
953 for (ch = 0; ch <= s->max_channel; ch++) {
954 int32_t sample = m->sample_buffer[i][ch] << s->output_shift[ch];
955 s->lossless_check_data ^= (sample & 0xffffff) << ch;
956 if (is32) *data_32++ = sample << 8;
957 else *data_16++ = sample >> 8;
958 }
959 }
960
961 *data_size = i * ch * (is32 ? 4 : 2);
962
963 return 0;
964}
965
966static int output_data(MLPDecodeContext *m, unsigned int substr,
967 uint8_t *data, unsigned int *data_size)
968{
969 if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
970 return output_data_internal(m, substr, data, data_size, 1);
971 else
972 return output_data_internal(m, substr, data, data_size, 0);
973}
974
975
976/** XOR together all the bytes of a buffer.
977 * Does this belong in dspcontext? */
978
979static uint8_t calculate_parity(const uint8_t *buf, unsigned int buf_size)
980{
981 uint32_t scratch = 0;
982 const uint8_t *buf_end = buf + buf_size;
983
984 for (; buf < buf_end - 3; buf += 4)
985 scratch ^= *((const uint32_t*)buf);
986
987 scratch ^= scratch >> 16;
988 scratch ^= scratch >> 8;
989
990 for (; buf < buf_end; buf++)
991 scratch ^= *buf;
992
993 return scratch;
994}
995
996/** Read an access unit from the stream.
997 * Returns < 0 on error, 0 if not enough data is present in the input stream
998 * otherwise returns the number of bytes consumed. */
999
1000static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
1001 const uint8_t *buf, int buf_size)
1002{
1003 MLPDecodeContext *m = avctx->priv_data;
1004 GetBitContext gb;
1005 unsigned int length, substr;
1006 unsigned int substream_start;
1007 unsigned int header_size = 4;
1008 unsigned int substr_header_size = 0;
1009 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1010 uint16_t substream_data_len[MAX_SUBSTREAMS];
1011 uint8_t parity_bits;
1012
1013 if (buf_size < 4)
1014 return 0;
1015
1016 length = (AV_RB16(buf) & 0xfff) * 2;
1017
1018 if (length > buf_size)
1019 return -1;
1020
1021 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1022
1023 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
9906a2be 1024 dprintf(m->avctx, "Found major sync.\n");
b517af05
RP
1025 if (read_major_sync(m, &gb) < 0)
1026 goto error;
1027 header_size += 28;
1028 }
1029
1030 if (!m->params_valid) {
1031 av_log(m->avctx, AV_LOG_WARNING,
9906a2be 1032 "Stream parameters not seen; skipping frame.\n");
b517af05
RP
1033 *data_size = 0;
1034 return length;
1035 }
1036
1037 substream_start = 0;
1038
1039 for (substr = 0; substr < m->num_substreams; substr++) {
1040 int extraword_present, checkdata_present, end;
1041
1042 extraword_present = get_bits1(&gb);
1043 skip_bits1(&gb);
1044 checkdata_present = get_bits1(&gb);
1045 skip_bits1(&gb);
1046
1047 end = get_bits(&gb, 12) * 2;
1048
1049 substr_header_size += 2;
1050
1051 if (extraword_present) {
1052 skip_bits(&gb, 16);
1053 substr_header_size += 2;
1054 }
1055
1056 if (end + header_size + substr_header_size > length) {
1057 av_log(m->avctx, AV_LOG_ERROR,
1058 "Indicated length of substream %d data goes off end of "
1059 "packet.\n", substr);
1060 end = length - header_size - substr_header_size;
1061 }
1062
1063 if (end < substream_start) {
1064 av_log(avctx, AV_LOG_ERROR,
1065 "Indicated end offset of substream %d data "
1066 "is smaller than calculated start offset.\n",
1067 substr);
1068 goto error;
1069 }
1070
1071 if (substr > m->max_decoded_substream)
1072 continue;
1073
1074 substream_parity_present[substr] = checkdata_present;
1075 substream_data_len[substr] = end - substream_start;
1076 substream_start = end;
1077 }
1078
1079 parity_bits = calculate_parity(buf, 4);
1080 parity_bits ^= calculate_parity(buf + header_size, substr_header_size);
1081
1082 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1083 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1084 goto error;
1085 }
1086
1087 buf += header_size + substr_header_size;
1088
1089 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1090 SubStream *s = &m->substream[substr];
1091 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1092
1093 s->blockpos = 0;
1094 do {
1095 if (get_bits1(&gb)) {
1096 if (get_bits1(&gb)) {
9906a2be 1097 /* A restart header should be present. */
b517af05
RP
1098 if (read_restart_header(m, &gb, buf, substr) < 0)
1099 goto next_substr;
1100 s->restart_seen = 1;
1101 }
1102
1103 if (!s->restart_seen) {
1104 av_log(m->avctx, AV_LOG_ERROR,
1105 "No restart header present in substream %d.\n",
1106 substr);
1107 goto next_substr;
1108 }
1109
1110 if (read_decoding_params(m, &gb, substr) < 0)
1111 goto next_substr;
1112 }
1113
1114 if (!s->restart_seen) {
1115 av_log(m->avctx, AV_LOG_ERROR,
1116 "No restart header present in substream %d.\n",
1117 substr);
1118 goto next_substr;
1119 }
1120
1121 if (read_block_data(m, &gb, substr) < 0)
1122 return -1;
1123
1124 } while ((get_bits_count(&gb) < substream_data_len[substr] * 8)
1125 && get_bits1(&gb) == 0);
1126
1127 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
eb2cd99c 1128 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32 &&
b517af05
RP
1129 (show_bits_long(&gb, 32) == 0xd234d234 ||
1130 show_bits_long(&gb, 20) == 0xd234e)) {
1131 skip_bits(&gb, 18);
1132 if (substr == m->max_decoded_substream)
9906a2be 1133 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
b517af05
RP
1134
1135 if (get_bits1(&gb)) {
1136 int shorten_by = get_bits(&gb, 13);
1137 shorten_by = FFMIN(shorten_by, s->blockpos);
1138 s->blockpos -= shorten_by;
1139 } else
1140 skip_bits(&gb, 13);
1141 }
eb2cd99c
RP
1142 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 16 &&
1143 substream_parity_present[substr]) {
b517af05
RP
1144 uint8_t parity, checksum;
1145
1146 parity = calculate_parity(buf, substream_data_len[substr] - 2);
1147 if ((parity ^ get_bits(&gb, 8)) != 0xa9)
1148 av_log(m->avctx, AV_LOG_ERROR,
9906a2be 1149 "Substream %d parity check failed.\n", substr);
b517af05
RP
1150
1151 checksum = mlp_checksum8(buf, substream_data_len[substr] - 2);
1152 if (checksum != get_bits(&gb, 8))
9906a2be 1153 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n",
b517af05
RP
1154 substr);
1155 }
1156 if (substream_data_len[substr] * 8 != get_bits_count(&gb)) {
9906a2be 1157 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n",
b517af05
RP
1158 substr);
1159 return -1;
1160 }
1161
1162next_substr:
1163 buf += substream_data_len[substr];
1164 }
1165
1166 rematrix_channels(m, m->max_decoded_substream);
1167
1168 if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1169 return -1;
1170
1171 return length;
1172
1173error:
1174 m->params_valid = 0;
1175 return -1;
1176}
1177
1178AVCodec mlp_decoder = {
1179 "mlp",
1180 CODEC_TYPE_AUDIO,
1181 CODEC_ID_MLP,
1182 sizeof(MLPDecodeContext),
1183 mlp_decode_init,
1184 NULL,
1185 NULL,
1186 read_access_unit,
1187 .long_name = NULL_IF_CONFIG_SMALL("Meridian Lossless Packing"),
1188};
1189