3 * Copyright (c) 2007-2008 Ian Caulfield
5 * This file is part of FFmpeg.
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.
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.
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
31 #include "libavutil/intreadwrite.h"
33 #include "libavutil/crc.h"
35 #include "mlp_parser.h"
38 /** number of bits used for VLC lookup - longest Huffman code is 9 */
41 typedef struct SubStream {
42 /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
46 /** restart header data */
47 /// The type of noise to be used in the rematrix stage.
50 /// The index of the first channel coded in this substream.
52 /// The index of the last channel coded in this substream.
54 /// The number of channels input into the rematrix stage.
55 uint8_t max_matrix_channel;
56 /// For each channel output by the matrix, the output channel to map it to
57 uint8_t ch_assign[MAX_CHANNELS];
59 /// Channel coding parameters for channels in the substream
60 ChannelParams channel_params[MAX_CHANNELS];
62 /// The left shift applied to random noise in 0x31ea substreams.
64 /// The current seed value for the pseudorandom noise generator(s).
65 uint32_t noisegen_seed;
67 /// Set if the substream contains extra info to check the size of VLC blocks.
68 uint8_t data_check_present;
70 /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
71 uint8_t param_presence_flags;
72 #define PARAM_BLOCKSIZE (1 << 7)
73 #define PARAM_MATRIX (1 << 6)
74 #define PARAM_OUTSHIFT (1 << 5)
75 #define PARAM_QUANTSTEP (1 << 4)
76 #define PARAM_FIR (1 << 3)
77 #define PARAM_IIR (1 << 2)
78 #define PARAM_HUFFOFFSET (1 << 1)
79 #define PARAM_PRESENCE (1 << 0)
85 /// Number of matrices to be applied.
86 uint8_t num_primitive_matrices;
88 /// matrix output channel
89 uint8_t matrix_out_ch[MAX_MATRICES];
91 /// Whether the LSBs of the matrix output are encoded in the bitstream.
92 uint8_t lsb_bypass[MAX_MATRICES];
93 /// Matrix coefficients, stored as 2.14 fixed point.
94 int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
95 /// Left shift to apply to noise values in 0x31eb substreams.
96 uint8_t matrix_noise_shift[MAX_MATRICES];
99 /// Left shift to apply to Huffman-decoded residuals.
100 uint8_t quant_step_size[MAX_CHANNELS];
102 /// number of PCM samples in current audio block
104 /// Number of PCM samples decoded so far in this frame.
107 /// Left shift to apply to decoded PCM values to get final 24-bit output.
108 int8_t output_shift[MAX_CHANNELS];
110 /// Running XOR of all output samples.
111 int32_t lossless_check_data;
115 typedef struct MLPDecodeContext {
116 AVCodecContext *avctx;
119 /// Current access unit being read has a major sync.
120 int is_major_sync_unit;
122 /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
123 uint8_t params_valid;
125 /// Number of substreams contained within this stream.
126 uint8_t num_substreams;
128 /// Index of the last substream to decode - further substreams are skipped.
129 uint8_t max_decoded_substream;
131 /// Stream needs channel reordering to comply with FFmpeg's channel order
132 uint8_t needs_reordering;
134 /// number of PCM samples contained in each frame
135 int access_unit_size;
136 /// next power of two above the number of samples in each frame
137 int access_unit_size_pow2;
139 SubStream substream[MAX_SUBSTREAMS];
142 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
144 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
145 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
146 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
151 static VLC huff_vlc[3];
153 /** Initialize static data, constant between all invocations of the codec. */
155 static av_cold void init_static(void)
157 if (!huff_vlc[0].bits) {
158 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
159 &ff_mlp_huffman_tables[0][0][1], 2, 1,
160 &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
161 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
162 &ff_mlp_huffman_tables[1][0][1], 2, 1,
163 &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
164 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
165 &ff_mlp_huffman_tables[2][0][1], 2, 1,
166 &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
172 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
173 unsigned int substr, unsigned int ch)
175 SubStream *s = &m->substream[substr];
176 ChannelParams *cp = &s->channel_params[ch];
177 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
178 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
179 int32_t sign_huff_offset = cp->huff_offset;
181 if (cp->codebook > 0)
182 sign_huff_offset -= 7 << lsb_bits;
185 sign_huff_offset -= 1 << sign_shift;
187 return sign_huff_offset;
190 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
193 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
194 unsigned int substr, unsigned int pos)
196 SubStream *s = &m->substream[substr];
197 unsigned int mat, channel;
199 for (mat = 0; mat < s->num_primitive_matrices; mat++)
200 if (s->lsb_bypass[mat])
201 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
203 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
204 ChannelParams *cp = &s->channel_params[channel];
205 int codebook = cp->codebook;
206 int quant_step_size = s->quant_step_size[channel];
207 int lsb_bits = cp->huff_lsbs - quant_step_size;
211 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
212 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
215 return AVERROR_INVALIDDATA;
218 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
220 result += cp->sign_huff_offset;
221 result <<= quant_step_size;
223 m->sample_buffer[pos + s->blockpos][channel] = result;
229 static av_cold int mlp_decode_init(AVCodecContext *avctx)
231 MLPDecodeContext *m = avctx->priv_data;
236 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
237 m->substream[substr].lossless_check_data = 0xffffffff;
238 ff_dsputil_init(&m->dsp, avctx);
240 avcodec_get_frame_defaults(&m->frame);
241 avctx->coded_frame = &m->frame;
246 /** Read a major sync info header - contains high level information about
247 * the stream - sample rate, channel arrangement etc. Most of this
248 * information is not actually necessary for decoding, only for playback.
251 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
256 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
259 if (mh.group1_bits == 0) {
260 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
261 return AVERROR_INVALIDDATA;
263 if (mh.group2_bits > mh.group1_bits) {
264 av_log(m->avctx, AV_LOG_ERROR,
265 "Channel group 2 cannot have more bits per sample than group 1.\n");
266 return AVERROR_INVALIDDATA;
269 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
270 av_log(m->avctx, AV_LOG_ERROR,
271 "Channel groups with differing sample rates are not currently supported.\n");
272 return AVERROR_INVALIDDATA;
275 if (mh.group1_samplerate == 0) {
276 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
277 return AVERROR_INVALIDDATA;
279 if (mh.group1_samplerate > MAX_SAMPLERATE) {
280 av_log(m->avctx, AV_LOG_ERROR,
281 "Sampling rate %d is greater than the supported maximum (%d).\n",
282 mh.group1_samplerate, MAX_SAMPLERATE);
283 return AVERROR_INVALIDDATA;
285 if (mh.access_unit_size > MAX_BLOCKSIZE) {
286 av_log(m->avctx, AV_LOG_ERROR,
287 "Block size %d is greater than the supported maximum (%d).\n",
288 mh.access_unit_size, MAX_BLOCKSIZE);
289 return AVERROR_INVALIDDATA;
291 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
292 av_log(m->avctx, AV_LOG_ERROR,
293 "Block size pow2 %d is greater than the supported maximum (%d).\n",
294 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
295 return AVERROR_INVALIDDATA;
298 if (mh.num_substreams == 0)
299 return AVERROR_INVALIDDATA;
300 if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
301 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
302 return AVERROR_INVALIDDATA;
304 if (mh.num_substreams > MAX_SUBSTREAMS) {
305 av_log_ask_for_sample(m->avctx,
306 "Number of substreams %d is larger than the maximum supported "
307 "by the decoder.\n", mh.num_substreams);
308 return AVERROR_PATCHWELCOME;
311 m->access_unit_size = mh.access_unit_size;
312 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
314 m->num_substreams = mh.num_substreams;
315 m->max_decoded_substream = m->num_substreams - 1;
317 m->avctx->sample_rate = mh.group1_samplerate;
318 m->avctx->frame_size = mh.access_unit_size;
320 m->avctx->bits_per_raw_sample = mh.group1_bits;
321 if (mh.group1_bits > 16)
322 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
324 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
327 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
328 m->substream[substr].restart_seen = 0;
330 if (mh.stream_type == 0xbb) {
332 m->avctx->channel_layout = ff_mlp_layout[mh.channels_mlp];
333 } else { /* mh.stream_type == 0xba */
335 if (mh.channels_thd_stream2) {
336 m->avctx->channel_layout = ff_truehd_layout(mh.channels_thd_stream2);
338 m->avctx->channel_layout = ff_truehd_layout(mh.channels_thd_stream1);
340 if (m->avctx->channels &&
341 !m->avctx->request_channels && !m->avctx->request_channel_layout &&
342 av_get_channel_layout_nb_channels(m->avctx->channel_layout) != m->avctx->channels) {
343 m->avctx->channel_layout = 0;
344 av_log_ask_for_sample(m->avctx, "Unknown channel layout.");
348 m->needs_reordering = mh.channels_mlp >= 18 && mh.channels_mlp <= 20;
353 /** Read a restart header from a block in a substream. This contains parameters
354 * required to decode the audio that do not change very often. Generally
355 * (always) present only in blocks following a major sync. */
357 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
358 const uint8_t *buf, unsigned int substr)
360 SubStream *s = &m->substream[substr];
364 uint8_t lossless_check;
365 int start_count = get_bits_count(gbp);
366 const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP
367 ? MAX_MATRIX_CHANNEL_MLP
368 : MAX_MATRIX_CHANNEL_TRUEHD;
370 sync_word = get_bits(gbp, 13);
372 if (sync_word != 0x31ea >> 1) {
373 av_log(m->avctx, AV_LOG_ERROR,
374 "restart header sync incorrect (got 0x%04x)\n", sync_word);
375 return AVERROR_INVALIDDATA;
378 s->noise_type = get_bits1(gbp);
380 if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) {
381 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
382 return AVERROR_INVALIDDATA;
385 skip_bits(gbp, 16); /* Output timestamp */
387 s->min_channel = get_bits(gbp, 4);
388 s->max_channel = get_bits(gbp, 4);
389 s->max_matrix_channel = get_bits(gbp, 4);
391 if (s->max_matrix_channel > max_matrix_channel) {
392 av_log(m->avctx, AV_LOG_ERROR,
393 "Max matrix channel cannot be greater than %d.\n",
395 return AVERROR_INVALIDDATA;
398 if (s->max_channel != s->max_matrix_channel) {
399 av_log(m->avctx, AV_LOG_ERROR,
400 "Max channel must be equal max matrix channel.\n");
401 return AVERROR_INVALIDDATA;
404 /* This should happen for TrueHD streams with >6 channels and MLP's noise
405 * type. It is not yet known if this is allowed. */
406 if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
407 av_log_ask_for_sample(m->avctx,
408 "Number of channels %d is larger than the maximum supported "
409 "by the decoder.\n", s->max_channel + 2);
410 return AVERROR_PATCHWELCOME;
413 if (s->min_channel > s->max_channel) {
414 av_log(m->avctx, AV_LOG_ERROR,
415 "Substream min channel cannot be greater than max channel.\n");
416 return AVERROR_INVALIDDATA;
419 if (m->avctx->request_channels > 0
420 && s->max_channel + 1 >= m->avctx->request_channels
421 && substr < m->max_decoded_substream) {
422 av_log(m->avctx, AV_LOG_DEBUG,
423 "Extracting %d channel downmix from substream %d. "
424 "Further substreams will be skipped.\n",
425 s->max_channel + 1, substr);
426 m->max_decoded_substream = substr;
429 s->noise_shift = get_bits(gbp, 4);
430 s->noisegen_seed = get_bits(gbp, 23);
434 s->data_check_present = get_bits1(gbp);
435 lossless_check = get_bits(gbp, 8);
436 if (substr == m->max_decoded_substream
437 && s->lossless_check_data != 0xffffffff) {
438 tmp = xor_32_to_8(s->lossless_check_data);
439 if (tmp != lossless_check)
440 av_log(m->avctx, AV_LOG_WARNING,
441 "Lossless check failed - expected %02x, calculated %02x.\n",
442 lossless_check, tmp);
447 memset(s->ch_assign, 0, sizeof(s->ch_assign));
449 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
450 int ch_assign = get_bits(gbp, 6);
451 if (ch_assign > s->max_matrix_channel) {
452 av_log_ask_for_sample(m->avctx,
453 "Assignment of matrix channel %d to invalid output channel %d.\n",
455 return AVERROR_PATCHWELCOME;
457 s->ch_assign[ch_assign] = ch;
460 if (m->avctx->codec_id == CODEC_ID_MLP && m->needs_reordering) {
461 if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
462 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
463 int i = s->ch_assign[4];
464 s->ch_assign[4] = s->ch_assign[3];
465 s->ch_assign[3] = s->ch_assign[2];
467 } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
468 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
469 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
472 if (m->avctx->codec_id == CODEC_ID_TRUEHD &&
473 (m->avctx->channel_layout == AV_CH_LAYOUT_7POINT1 ||
474 m->avctx->channel_layout == AV_CH_LAYOUT_7POINT1_WIDE)) {
475 FFSWAP(int, s->ch_assign[4], s->ch_assign[6]);
476 FFSWAP(int, s->ch_assign[5], s->ch_assign[7]);
477 } else if (m->avctx->codec_id == CODEC_ID_TRUEHD &&
478 (m->avctx->channel_layout == AV_CH_LAYOUT_6POINT1 ||
479 m->avctx->channel_layout == (AV_CH_LAYOUT_6POINT1 | AV_CH_TOP_CENTER) ||
480 m->avctx->channel_layout == (AV_CH_LAYOUT_6POINT1 | AV_CH_TOP_FRONT_CENTER))) {
481 int i = s->ch_assign[6];
482 s->ch_assign[6] = s->ch_assign[5];
483 s->ch_assign[5] = s->ch_assign[4];
487 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
489 if (checksum != get_bits(gbp, 8))
490 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
492 /* Set default decoding parameters. */
493 s->param_presence_flags = 0xff;
494 s->num_primitive_matrices = 0;
496 s->lossless_check_data = 0;
498 memset(s->output_shift , 0, sizeof(s->output_shift ));
499 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
501 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
502 ChannelParams *cp = &s->channel_params[ch];
503 cp->filter_params[FIR].order = 0;
504 cp->filter_params[IIR].order = 0;
505 cp->filter_params[FIR].shift = 0;
506 cp->filter_params[IIR].shift = 0;
508 /* Default audio coding is 24-bit raw PCM. */
510 cp->sign_huff_offset = (-1) << 23;
515 if (substr == m->max_decoded_substream)
516 m->avctx->channels = s->max_matrix_channel + 1;
521 /** Read parameters for one of the prediction filters. */
523 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
524 unsigned int substr, unsigned int channel,
527 SubStream *s = &m->substream[substr];
528 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
529 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
530 const char fchar = filter ? 'I' : 'F';
533 // Filter is 0 for FIR, 1 for IIR.
536 if (m->filter_changed[channel][filter]++ > 1) {
537 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
538 return AVERROR_INVALIDDATA;
541 order = get_bits(gbp, 4);
542 if (order > max_order) {
543 av_log(m->avctx, AV_LOG_ERROR,
544 "%cIR filter order %d is greater than maximum %d.\n",
545 fchar, order, max_order);
546 return AVERROR_INVALIDDATA;
551 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
552 int coeff_bits, coeff_shift;
554 fp->shift = get_bits(gbp, 4);
556 coeff_bits = get_bits(gbp, 5);
557 coeff_shift = get_bits(gbp, 3);
558 if (coeff_bits < 1 || coeff_bits > 16) {
559 av_log(m->avctx, AV_LOG_ERROR,
560 "%cIR filter coeff_bits must be between 1 and 16.\n",
562 return AVERROR_INVALIDDATA;
564 if (coeff_bits + coeff_shift > 16) {
565 av_log(m->avctx, AV_LOG_ERROR,
566 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
568 return AVERROR_INVALIDDATA;
571 for (i = 0; i < order; i++)
572 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
574 if (get_bits1(gbp)) {
575 int state_bits, state_shift;
578 av_log(m->avctx, AV_LOG_ERROR,
579 "FIR filter has state data specified.\n");
580 return AVERROR_INVALIDDATA;
583 state_bits = get_bits(gbp, 4);
584 state_shift = get_bits(gbp, 4);
586 /* TODO: Check validity of state data. */
588 for (i = 0; i < order; i++)
589 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
596 /** Read parameters for primitive matrices. */
598 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
600 SubStream *s = &m->substream[substr];
601 unsigned int mat, ch;
602 const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
604 : MAX_MATRICES_TRUEHD;
606 if (m->matrix_changed++ > 1) {
607 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
608 return AVERROR_INVALIDDATA;
611 s->num_primitive_matrices = get_bits(gbp, 4);
613 if (s->num_primitive_matrices > max_primitive_matrices) {
614 av_log(m->avctx, AV_LOG_ERROR,
615 "Number of primitive matrices cannot be greater than %d.\n",
616 max_primitive_matrices);
617 return AVERROR_INVALIDDATA;
620 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
621 int frac_bits, max_chan;
622 s->matrix_out_ch[mat] = get_bits(gbp, 4);
623 frac_bits = get_bits(gbp, 4);
624 s->lsb_bypass [mat] = get_bits1(gbp);
626 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
627 av_log(m->avctx, AV_LOG_ERROR,
628 "Invalid channel %d specified as output from matrix.\n",
629 s->matrix_out_ch[mat]);
630 return AVERROR_INVALIDDATA;
632 if (frac_bits > 14) {
633 av_log(m->avctx, AV_LOG_ERROR,
634 "Too many fractional bits specified.\n");
635 return AVERROR_INVALIDDATA;
638 max_chan = s->max_matrix_channel;
642 for (ch = 0; ch <= max_chan; ch++) {
645 coeff_val = get_sbits(gbp, frac_bits + 2);
647 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
651 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
653 s->matrix_noise_shift[mat] = 0;
659 /** Read channel parameters. */
661 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
662 GetBitContext *gbp, unsigned int ch)
664 SubStream *s = &m->substream[substr];
665 ChannelParams *cp = &s->channel_params[ch];
666 FilterParams *fir = &cp->filter_params[FIR];
667 FilterParams *iir = &cp->filter_params[IIR];
670 if (s->param_presence_flags & PARAM_FIR)
672 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
675 if (s->param_presence_flags & PARAM_IIR)
677 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
680 if (fir->order + iir->order > 8) {
681 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
682 return AVERROR_INVALIDDATA;
685 if (fir->order && iir->order &&
686 fir->shift != iir->shift) {
687 av_log(m->avctx, AV_LOG_ERROR,
688 "FIR and IIR filters must use the same precision.\n");
689 return AVERROR_INVALIDDATA;
691 /* The FIR and IIR filters must have the same precision.
692 * To simplify the filtering code, only the precision of the
693 * FIR filter is considered. If only the IIR filter is employed,
694 * the FIR filter precision is set to that of the IIR filter, so
695 * that the filtering code can use it. */
696 if (!fir->order && iir->order)
697 fir->shift = iir->shift;
699 if (s->param_presence_flags & PARAM_HUFFOFFSET)
701 cp->huff_offset = get_sbits(gbp, 15);
703 cp->codebook = get_bits(gbp, 2);
704 cp->huff_lsbs = get_bits(gbp, 5);
706 if (cp->huff_lsbs > 24) {
707 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
708 return AVERROR_INVALIDDATA;
711 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
716 /** Read decoding parameters that change more often than those in the restart
719 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
722 SubStream *s = &m->substream[substr];
726 if (s->param_presence_flags & PARAM_PRESENCE)
728 s->param_presence_flags = get_bits(gbp, 8);
730 if (s->param_presence_flags & PARAM_BLOCKSIZE)
731 if (get_bits1(gbp)) {
732 s->blocksize = get_bits(gbp, 9);
733 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
734 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
736 return AVERROR_INVALIDDATA;
740 if (s->param_presence_flags & PARAM_MATRIX)
742 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
745 if (s->param_presence_flags & PARAM_OUTSHIFT)
747 for (ch = 0; ch <= s->max_matrix_channel; ch++)
748 s->output_shift[ch] = get_sbits(gbp, 4);
750 if (s->param_presence_flags & PARAM_QUANTSTEP)
752 for (ch = 0; ch <= s->max_channel; ch++) {
753 ChannelParams *cp = &s->channel_params[ch];
755 s->quant_step_size[ch] = get_bits(gbp, 4);
757 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
760 for (ch = s->min_channel; ch <= s->max_channel; ch++)
762 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
768 #define MSB_MASK(bits) (-1u << bits)
770 /** Generate PCM samples using the prediction filters and residual values
771 * read from the data stream, and update the filter state. */
773 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
774 unsigned int channel)
776 SubStream *s = &m->substream[substr];
777 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
778 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
779 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
780 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
781 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
782 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
783 unsigned int filter_shift = fir->shift;
784 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
786 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
787 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
789 m->dsp.mlp_filter_channel(firbuf, fircoeff,
790 fir->order, iir->order,
791 filter_shift, mask, s->blocksize,
792 &m->sample_buffer[s->blockpos][channel]);
794 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
795 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
798 /** Read a block of PCM residual data (or actual if no filtering active). */
800 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
803 SubStream *s = &m->substream[substr];
804 unsigned int i, ch, expected_stream_pos = 0;
807 if (s->data_check_present) {
808 expected_stream_pos = get_bits_count(gbp);
809 expected_stream_pos += get_bits(gbp, 16);
810 av_log_ask_for_sample(m->avctx, "This file contains some features "
811 "we have not tested yet.\n");
814 if (s->blockpos + s->blocksize > m->access_unit_size) {
815 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
816 return AVERROR_INVALIDDATA;
819 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
820 s->blocksize * sizeof(m->bypassed_lsbs[0]));
822 for (i = 0; i < s->blocksize; i++)
823 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
826 for (ch = s->min_channel; ch <= s->max_channel; ch++)
827 filter_channel(m, substr, ch);
829 s->blockpos += s->blocksize;
831 if (s->data_check_present) {
832 if (get_bits_count(gbp) != expected_stream_pos)
833 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
840 /** Data table used for TrueHD noise generation function. */
842 static const int8_t noise_table[256] = {
843 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
844 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
845 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
846 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
847 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
848 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
849 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
850 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
851 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
852 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
853 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
854 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
855 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
856 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
857 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
858 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
861 /** Noise generation functions.
862 * I'm not sure what these are for - they seem to be some kind of pseudorandom
863 * sequence generators, used to generate noise data which is used when the
864 * channels are rematrixed. I'm not sure if they provide a practical benefit
865 * to compression, or just obfuscate the decoder. Are they for some kind of
868 /** Generate two channels of noise, used in the matrix when
869 * restart sync word == 0x31ea. */
871 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
873 SubStream *s = &m->substream[substr];
875 uint32_t seed = s->noisegen_seed;
876 unsigned int maxchan = s->max_matrix_channel;
878 for (i = 0; i < s->blockpos; i++) {
879 uint16_t seed_shr7 = seed >> 7;
880 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
881 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
883 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
886 s->noisegen_seed = seed;
889 /** Generate a block of noise, used when restart sync word == 0x31eb. */
891 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
893 SubStream *s = &m->substream[substr];
895 uint32_t seed = s->noisegen_seed;
897 for (i = 0; i < m->access_unit_size_pow2; i++) {
898 uint8_t seed_shr15 = seed >> 15;
899 m->noise_buffer[i] = noise_table[seed_shr15];
900 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
903 s->noisegen_seed = seed;
907 /** Apply the channel matrices in turn to reconstruct the original audio
910 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
912 SubStream *s = &m->substream[substr];
913 unsigned int mat, src_ch, i;
914 unsigned int maxchan;
916 maxchan = s->max_matrix_channel;
917 if (!s->noise_type) {
918 generate_2_noise_channels(m, substr);
921 fill_noise_buffer(m, substr);
924 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
925 int matrix_noise_shift = s->matrix_noise_shift[mat];
926 unsigned int dest_ch = s->matrix_out_ch[mat];
927 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
928 int32_t *coeffs = s->matrix_coeff[mat];
929 int index = s->num_primitive_matrices - mat;
930 int index2 = 2 * index + 1;
932 /* TODO: DSPContext? */
934 for (i = 0; i < s->blockpos; i++) {
935 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
936 int32_t *samples = m->sample_buffer[i];
939 for (src_ch = 0; src_ch <= maxchan; src_ch++)
940 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
942 if (matrix_noise_shift) {
943 index &= m->access_unit_size_pow2 - 1;
944 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
948 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
953 /** Write the audio data into the output buffer. */
955 static int output_data(MLPDecodeContext *m, unsigned int substr,
956 void *data, int *got_frame_ptr)
958 AVCodecContext *avctx = m->avctx;
959 SubStream *s = &m->substream[substr];
960 unsigned int i, out_ch = 0;
964 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
966 if (m->avctx->channels != s->max_matrix_channel + 1) {
967 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
968 return AVERROR_INVALIDDATA;
971 /* get output buffer */
972 m->frame.nb_samples = s->blockpos;
973 if ((ret = avctx->get_buffer(avctx, &m->frame)) < 0) {
974 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
977 data_32 = (int32_t *)m->frame.data[0];
978 data_16 = (int16_t *)m->frame.data[0];
980 for (i = 0; i < s->blockpos; i++) {
981 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
982 int mat_ch = s->ch_assign[out_ch];
983 int32_t sample = m->sample_buffer[i][mat_ch]
984 << s->output_shift[mat_ch];
985 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
986 if (is32) *data_32++ = sample << 8;
987 else *data_16++ = sample >> 8;
992 *(AVFrame *)data = m->frame;
997 /** Read an access unit from the stream.
998 * @return negative on error, 0 if not enough data is present in the input stream,
999 * otherwise the number of bytes consumed. */
1001 static int read_access_unit(AVCodecContext *avctx, void* data,
1002 int *got_frame_ptr, AVPacket *avpkt)
1004 const uint8_t *buf = avpkt->data;
1005 int buf_size = avpkt->size;
1006 MLPDecodeContext *m = avctx->priv_data;
1008 unsigned int length, substr;
1009 unsigned int substream_start;
1010 unsigned int header_size = 4;
1011 unsigned int substr_header_size = 0;
1012 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1013 uint16_t substream_data_len[MAX_SUBSTREAMS];
1014 uint8_t parity_bits;
1020 length = (AV_RB16(buf) & 0xfff) * 2;
1022 if (length < 4 || length > buf_size)
1023 return AVERROR_INVALIDDATA;
1025 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1027 m->is_major_sync_unit = 0;
1028 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1029 if (read_major_sync(m, &gb) < 0)
1031 m->is_major_sync_unit = 1;
1035 if (!m->params_valid) {
1036 av_log(m->avctx, AV_LOG_WARNING,
1037 "Stream parameters not seen; skipping frame.\n");
1042 substream_start = 0;
1044 for (substr = 0; substr < m->num_substreams; substr++) {
1045 int extraword_present, checkdata_present, end, nonrestart_substr;
1047 extraword_present = get_bits1(&gb);
1048 nonrestart_substr = get_bits1(&gb);
1049 checkdata_present = get_bits1(&gb);
1052 end = get_bits(&gb, 12) * 2;
1054 substr_header_size += 2;
1056 if (extraword_present) {
1057 if (m->avctx->codec_id == CODEC_ID_MLP) {
1058 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1062 substr_header_size += 2;
1065 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1066 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1070 if (end + header_size + substr_header_size > length) {
1071 av_log(m->avctx, AV_LOG_ERROR,
1072 "Indicated length of substream %d data goes off end of "
1073 "packet.\n", substr);
1074 end = length - header_size - substr_header_size;
1077 if (end < substream_start) {
1078 av_log(avctx, AV_LOG_ERROR,
1079 "Indicated end offset of substream %d data "
1080 "is smaller than calculated start offset.\n",
1085 if (substr > m->max_decoded_substream)
1088 substream_parity_present[substr] = checkdata_present;
1089 substream_data_len[substr] = end - substream_start;
1090 substream_start = end;
1093 parity_bits = ff_mlp_calculate_parity(buf, 4);
1094 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1096 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1097 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1101 buf += header_size + substr_header_size;
1103 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1104 SubStream *s = &m->substream[substr];
1105 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1107 m->matrix_changed = 0;
1108 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1112 if (get_bits1(&gb)) {
1113 if (get_bits1(&gb)) {
1114 /* A restart header should be present. */
1115 if (read_restart_header(m, &gb, buf, substr) < 0)
1117 s->restart_seen = 1;
1120 if (!s->restart_seen)
1122 if (read_decoding_params(m, &gb, substr) < 0)
1126 if (!s->restart_seen)
1129 if ((ret = read_block_data(m, &gb, substr)) < 0)
1132 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1133 goto substream_length_mismatch;
1135 } while (!get_bits1(&gb));
1137 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1139 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1142 if (get_bits(&gb, 16) != 0xD234)
1143 return AVERROR_INVALIDDATA;
1145 shorten_by = get_bits(&gb, 16);
1146 if (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by & 0x2000)
1147 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1148 else if (m->avctx->codec_id == CODEC_ID_MLP && shorten_by != 0xD234)
1149 return AVERROR_INVALIDDATA;
1151 if (substr == m->max_decoded_substream)
1152 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1155 if (substream_parity_present[substr]) {
1156 uint8_t parity, checksum;
1158 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1159 goto substream_length_mismatch;
1161 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1162 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1164 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1165 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1166 if ( get_bits(&gb, 8) != checksum)
1167 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1170 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1171 goto substream_length_mismatch;
1174 if (!s->restart_seen)
1175 av_log(m->avctx, AV_LOG_ERROR,
1176 "No restart header present in substream %d.\n", substr);
1178 buf += substream_data_len[substr];
1181 rematrix_channels(m, m->max_decoded_substream);
1183 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1188 substream_length_mismatch:
1189 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1190 return AVERROR_INVALIDDATA;
1193 m->params_valid = 0;
1194 return AVERROR_INVALIDDATA;
1197 AVCodec ff_mlp_decoder = {
1199 .type = AVMEDIA_TYPE_AUDIO,
1201 .priv_data_size = sizeof(MLPDecodeContext),
1202 .init = mlp_decode_init,
1203 .decode = read_access_unit,
1204 .capabilities = CODEC_CAP_DR1,
1205 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1208 #if CONFIG_TRUEHD_DECODER
1209 AVCodec ff_truehd_decoder = {
1211 .type = AVMEDIA_TYPE_AUDIO,
1212 .id = CODEC_ID_TRUEHD,
1213 .priv_data_size = sizeof(MLPDecodeContext),
1214 .init = mlp_decode_init,
1215 .decode = read_access_unit,
1216 .capabilities = CODEC_CAP_DR1,
1217 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1219 #endif /* CONFIG_TRUEHD_DECODER */