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
30 #include "libavutil/internal.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/channel_layout.h"
35 #include "libavutil/crc.h"
37 #include "mlp_parser.h"
41 /** number of bits used for VLC lookup - longest Huffman code is 9 */
44 typedef struct SubStream {
45 /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
49 /** restart header data */
50 /// The type of noise to be used in the rematrix stage.
53 /// The index of the first channel coded in this substream.
55 /// The index of the last channel coded in this substream.
57 /// The number of channels input into the rematrix stage.
58 uint8_t max_matrix_channel;
59 /// For each channel output by the matrix, the output channel to map it to
60 uint8_t ch_assign[MAX_CHANNELS];
61 /// The channel layout for this substream
64 /// Channel coding parameters for channels in the substream
65 ChannelParams channel_params[MAX_CHANNELS];
67 /// The left shift applied to random noise in 0x31ea substreams.
69 /// The current seed value for the pseudorandom noise generator(s).
70 uint32_t noisegen_seed;
72 /// Set if the substream contains extra info to check the size of VLC blocks.
73 uint8_t data_check_present;
75 /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
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)
84 #define PARAM_PRESENCE (1 << 0)
90 /// Number of matrices to be applied.
91 uint8_t num_primitive_matrices;
93 /// matrix output channel
94 uint8_t matrix_out_ch[MAX_MATRICES];
96 /// Whether the LSBs of the matrix output are encoded in the bitstream.
97 uint8_t lsb_bypass[MAX_MATRICES];
98 /// Matrix coefficients, stored as 2.14 fixed point.
99 int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
100 /// Left shift to apply to noise values in 0x31eb substreams.
101 uint8_t matrix_noise_shift[MAX_MATRICES];
104 /// Left shift to apply to Huffman-decoded residuals.
105 uint8_t quant_step_size[MAX_CHANNELS];
107 /// number of PCM samples in current audio block
109 /// Number of PCM samples decoded so far in this frame.
112 /// Left shift to apply to decoded PCM values to get final 24-bit output.
113 int8_t output_shift[MAX_CHANNELS];
115 /// Running XOR of all output samples.
116 int32_t lossless_check_data;
120 typedef struct MLPDecodeContext {
121 AVCodecContext *avctx;
123 /// Current access unit being read has a major sync.
124 int is_major_sync_unit;
126 /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
127 uint8_t params_valid;
129 /// Number of substreams contained within this stream.
130 uint8_t num_substreams;
132 /// Index of the last substream to decode - further substreams are skipped.
133 uint8_t max_decoded_substream;
135 /// Stream needs channel reordering to comply with FFmpeg's channel order
136 uint8_t needs_reordering;
138 /// number of PCM samples contained in each frame
139 int access_unit_size;
140 /// next power of two above the number of samples in each frame
141 int access_unit_size_pow2;
143 SubStream substream[MAX_SUBSTREAMS];
146 int filter_changed[MAX_CHANNELS][NUM_FILTERS];
148 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];
149 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
150 int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
155 static const uint64_t thd_channel_order[] = {
156 AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT, // LR
157 AV_CH_FRONT_CENTER, // C
158 AV_CH_LOW_FREQUENCY, // LFE
159 AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT, // LRs
160 AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT, // LRvh
161 AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
162 AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT, // LRrs
163 AV_CH_BACK_CENTER, // Cs
164 AV_CH_TOP_CENTER, // Ts
165 AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
166 AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT, // LRw
167 AV_CH_TOP_FRONT_CENTER, // Cvh
168 AV_CH_LOW_FREQUENCY_2, // LFE2
171 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
176 if (av_get_channel_layout_nb_channels(channel_layout) <= index)
179 for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
180 if (channel_layout & thd_channel_order[i] && !index--)
181 return thd_channel_order[i];
185 static VLC huff_vlc[3];
187 /** Initialize static data, constant between all invocations of the codec. */
189 static av_cold void init_static(void)
191 if (!huff_vlc[0].bits) {
192 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
193 &ff_mlp_huffman_tables[0][0][1], 2, 1,
194 &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
195 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
196 &ff_mlp_huffman_tables[1][0][1], 2, 1,
197 &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
198 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
199 &ff_mlp_huffman_tables[2][0][1], 2, 1,
200 &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
206 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
207 unsigned int substr, unsigned int ch)
209 SubStream *s = &m->substream[substr];
210 ChannelParams *cp = &s->channel_params[ch];
211 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
212 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
213 int32_t sign_huff_offset = cp->huff_offset;
215 if (cp->codebook > 0)
216 sign_huff_offset -= 7 << lsb_bits;
219 sign_huff_offset -= 1 << sign_shift;
221 return sign_huff_offset;
224 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
227 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
228 unsigned int substr, unsigned int pos)
230 SubStream *s = &m->substream[substr];
231 unsigned int mat, channel;
233 for (mat = 0; mat < s->num_primitive_matrices; mat++)
234 if (s->lsb_bypass[mat])
235 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
237 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
238 ChannelParams *cp = &s->channel_params[channel];
239 int codebook = cp->codebook;
240 int quant_step_size = s->quant_step_size[channel];
241 int lsb_bits = cp->huff_lsbs - quant_step_size;
245 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
246 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
249 return AVERROR_INVALIDDATA;
252 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
254 result += cp->sign_huff_offset;
255 result <<= quant_step_size;
257 m->sample_buffer[pos + s->blockpos][channel] = result;
263 static av_cold int mlp_decode_init(AVCodecContext *avctx)
265 MLPDecodeContext *m = avctx->priv_data;
270 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
271 m->substream[substr].lossless_check_data = 0xffffffff;
272 ff_mlpdsp_init(&m->dsp);
277 /** Read a major sync info header - contains high level information about
278 * the stream - sample rate, channel arrangement etc. Most of this
279 * information is not actually necessary for decoding, only for playback.
282 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
287 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
290 if (mh.group1_bits == 0) {
291 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
292 return AVERROR_INVALIDDATA;
294 if (mh.group2_bits > mh.group1_bits) {
295 av_log(m->avctx, AV_LOG_ERROR,
296 "Channel group 2 cannot have more bits per sample than group 1.\n");
297 return AVERROR_INVALIDDATA;
300 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
301 av_log(m->avctx, AV_LOG_ERROR,
302 "Channel groups with differing sample rates are not currently supported.\n");
303 return AVERROR_INVALIDDATA;
306 if (mh.group1_samplerate == 0) {
307 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
308 return AVERROR_INVALIDDATA;
310 if (mh.group1_samplerate > MAX_SAMPLERATE) {
311 av_log(m->avctx, AV_LOG_ERROR,
312 "Sampling rate %d is greater than the supported maximum (%d).\n",
313 mh.group1_samplerate, MAX_SAMPLERATE);
314 return AVERROR_INVALIDDATA;
316 if (mh.access_unit_size > MAX_BLOCKSIZE) {
317 av_log(m->avctx, AV_LOG_ERROR,
318 "Block size %d is greater than the supported maximum (%d).\n",
319 mh.access_unit_size, MAX_BLOCKSIZE);
320 return AVERROR_INVALIDDATA;
322 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
323 av_log(m->avctx, AV_LOG_ERROR,
324 "Block size pow2 %d is greater than the supported maximum (%d).\n",
325 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
326 return AVERROR_INVALIDDATA;
329 if (mh.num_substreams == 0)
330 return AVERROR_INVALIDDATA;
331 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
332 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
333 return AVERROR_INVALIDDATA;
335 if (mh.num_substreams > MAX_SUBSTREAMS) {
336 avpriv_request_sample(m->avctx,
337 "%d substreams (more than the "
338 "maximum supported by the decoder)",
340 return AVERROR_PATCHWELCOME;
343 m->access_unit_size = mh.access_unit_size;
344 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
346 m->num_substreams = mh.num_substreams;
347 m->max_decoded_substream = m->num_substreams - 1;
349 m->avctx->sample_rate = mh.group1_samplerate;
350 m->avctx->frame_size = mh.access_unit_size;
352 m->avctx->bits_per_raw_sample = mh.group1_bits;
353 if (mh.group1_bits > 16)
354 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
356 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
359 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
360 m->substream[substr].restart_seen = 0;
362 /* Set the layout for each substream. When there's more than one, the first
363 * substream is Stereo. Subsequent substreams' layouts are indicated in the
365 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
366 if ((substr = (mh.num_substreams > 1)))
367 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
368 m->substream[substr].ch_layout = mh.channel_layout_mlp;
370 if ((substr = (mh.num_substreams > 1)))
371 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
372 if (mh.num_substreams > 2)
373 if (mh.channel_layout_thd_stream2)
374 m->substream[2].ch_layout = mh.channel_layout_thd_stream2;
376 m->substream[2].ch_layout = mh.channel_layout_thd_stream1;
377 m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;
379 if (m->avctx->channels<=2 && m->substream[substr].ch_layout == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
380 av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
381 m->max_decoded_substream = 0;
382 if (m->avctx->channels==2)
383 m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
387 m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
392 /** Read a restart header from a block in a substream. This contains parameters
393 * required to decode the audio that do not change very often. Generally
394 * (always) present only in blocks following a major sync. */
396 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
397 const uint8_t *buf, unsigned int substr)
399 SubStream *s = &m->substream[substr];
403 uint8_t lossless_check;
404 int start_count = get_bits_count(gbp);
405 int min_channel, max_channel, max_matrix_channel;
406 const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
407 ? MAX_MATRIX_CHANNEL_MLP
408 : MAX_MATRIX_CHANNEL_TRUEHD;
410 sync_word = get_bits(gbp, 13);
412 if (sync_word != 0x31ea >> 1) {
413 av_log(m->avctx, AV_LOG_ERROR,
414 "restart header sync incorrect (got 0x%04x)\n", sync_word);
415 return AVERROR_INVALIDDATA;
418 s->noise_type = get_bits1(gbp);
420 if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
421 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
422 return AVERROR_INVALIDDATA;
425 skip_bits(gbp, 16); /* Output timestamp */
427 min_channel = get_bits(gbp, 4);
428 max_channel = get_bits(gbp, 4);
429 max_matrix_channel = get_bits(gbp, 4);
431 if (max_matrix_channel > std_max_matrix_channel) {
432 av_log(m->avctx, AV_LOG_ERROR,
433 "Max matrix channel cannot be greater than %d.\n",
434 std_max_matrix_channel);
435 return AVERROR_INVALIDDATA;
438 if (max_channel != max_matrix_channel) {
439 av_log(m->avctx, AV_LOG_ERROR,
440 "Max channel must be equal max matrix channel.\n");
441 return AVERROR_INVALIDDATA;
444 /* This should happen for TrueHD streams with >6 channels and MLP's noise
445 * type. It is not yet known if this is allowed. */
446 if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
447 avpriv_request_sample(m->avctx,
448 "%d channels (more than the "
449 "maximum supported by the decoder)",
451 return AVERROR_PATCHWELCOME;
454 if (min_channel > max_channel) {
455 av_log(m->avctx, AV_LOG_ERROR,
456 "Substream min channel cannot be greater than max channel.\n");
457 return AVERROR_INVALIDDATA;
460 s->min_channel = min_channel;
461 s->max_channel = max_channel;
462 s->max_matrix_channel = max_matrix_channel;
464 #if FF_API_REQUEST_CHANNELS
465 FF_DISABLE_DEPRECATION_WARNINGS
466 if (m->avctx->request_channels > 0 &&
467 m->avctx->request_channels <= s->max_channel + 1 &&
468 m->max_decoded_substream > substr) {
469 av_log(m->avctx, AV_LOG_DEBUG,
470 "Extracting %d-channel downmix from substream %d. "
471 "Further substreams will be skipped.\n",
472 s->max_channel + 1, substr);
473 m->max_decoded_substream = substr;
474 FF_ENABLE_DEPRECATION_WARNINGS
477 if (m->avctx->request_channel_layout == s->ch_layout &&
478 m->max_decoded_substream > substr) {
479 av_log(m->avctx, AV_LOG_DEBUG,
480 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
481 "Further substreams will be skipped.\n",
482 s->max_channel + 1, s->ch_layout, substr);
483 m->max_decoded_substream = substr;
486 s->noise_shift = get_bits(gbp, 4);
487 s->noisegen_seed = get_bits(gbp, 23);
491 s->data_check_present = get_bits1(gbp);
492 lossless_check = get_bits(gbp, 8);
493 if (substr == m->max_decoded_substream
494 && s->lossless_check_data != 0xffffffff) {
495 tmp = xor_32_to_8(s->lossless_check_data);
496 if (tmp != lossless_check)
497 av_log(m->avctx, AV_LOG_WARNING,
498 "Lossless check failed - expected %02x, calculated %02x.\n",
499 lossless_check, tmp);
504 memset(s->ch_assign, 0, sizeof(s->ch_assign));
506 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
507 int ch_assign = get_bits(gbp, 6);
508 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
509 uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
511 ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
514 if ((unsigned)ch_assign > s->max_matrix_channel) {
515 avpriv_request_sample(m->avctx,
516 "Assignment of matrix channel %d to invalid output channel %d",
518 return AVERROR_PATCHWELCOME;
520 s->ch_assign[ch_assign] = ch;
523 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
525 if (checksum != get_bits(gbp, 8))
526 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
528 /* Set default decoding parameters. */
529 s->param_presence_flags = 0xff;
530 s->num_primitive_matrices = 0;
532 s->lossless_check_data = 0;
534 memset(s->output_shift , 0, sizeof(s->output_shift ));
535 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
537 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
538 ChannelParams *cp = &s->channel_params[ch];
539 cp->filter_params[FIR].order = 0;
540 cp->filter_params[IIR].order = 0;
541 cp->filter_params[FIR].shift = 0;
542 cp->filter_params[IIR].shift = 0;
544 /* Default audio coding is 24-bit raw PCM. */
546 cp->sign_huff_offset = (-1) << 23;
551 if (substr == m->max_decoded_substream) {
552 m->avctx->channels = s->max_matrix_channel + 1;
553 m->avctx->channel_layout = s->ch_layout;
555 if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
556 if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
557 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
558 int i = s->ch_assign[4];
559 s->ch_assign[4] = s->ch_assign[3];
560 s->ch_assign[3] = s->ch_assign[2];
562 } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
563 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
564 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
573 /** Read parameters for one of the prediction filters. */
575 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
576 unsigned int substr, unsigned int channel,
579 SubStream *s = &m->substream[substr];
580 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
581 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
582 const char fchar = filter ? 'I' : 'F';
585 // Filter is 0 for FIR, 1 for IIR.
586 av_assert0(filter < 2);
588 if (m->filter_changed[channel][filter]++ > 1) {
589 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
590 return AVERROR_INVALIDDATA;
593 order = get_bits(gbp, 4);
594 if (order > max_order) {
595 av_log(m->avctx, AV_LOG_ERROR,
596 "%cIR filter order %d is greater than maximum %d.\n",
597 fchar, order, max_order);
598 return AVERROR_INVALIDDATA;
603 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
604 int coeff_bits, coeff_shift;
606 fp->shift = get_bits(gbp, 4);
608 coeff_bits = get_bits(gbp, 5);
609 coeff_shift = get_bits(gbp, 3);
610 if (coeff_bits < 1 || coeff_bits > 16) {
611 av_log(m->avctx, AV_LOG_ERROR,
612 "%cIR filter coeff_bits must be between 1 and 16.\n",
614 return AVERROR_INVALIDDATA;
616 if (coeff_bits + coeff_shift > 16) {
617 av_log(m->avctx, AV_LOG_ERROR,
618 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
620 return AVERROR_INVALIDDATA;
623 for (i = 0; i < order; i++)
624 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
626 if (get_bits1(gbp)) {
627 int state_bits, state_shift;
630 av_log(m->avctx, AV_LOG_ERROR,
631 "FIR filter has state data specified.\n");
632 return AVERROR_INVALIDDATA;
635 state_bits = get_bits(gbp, 4);
636 state_shift = get_bits(gbp, 4);
638 /* TODO: Check validity of state data. */
640 for (i = 0; i < order; i++)
641 fp->state[i] = state_bits ? get_sbits(gbp, state_bits) << state_shift : 0;
648 /** Read parameters for primitive matrices. */
650 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
652 SubStream *s = &m->substream[substr];
653 unsigned int mat, ch;
654 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
656 : MAX_MATRICES_TRUEHD;
658 if (m->matrix_changed++ > 1) {
659 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
660 return AVERROR_INVALIDDATA;
663 s->num_primitive_matrices = get_bits(gbp, 4);
665 if (s->num_primitive_matrices > max_primitive_matrices) {
666 av_log(m->avctx, AV_LOG_ERROR,
667 "Number of primitive matrices cannot be greater than %d.\n",
668 max_primitive_matrices);
669 return AVERROR_INVALIDDATA;
672 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
673 int frac_bits, max_chan;
674 s->matrix_out_ch[mat] = get_bits(gbp, 4);
675 frac_bits = get_bits(gbp, 4);
676 s->lsb_bypass [mat] = get_bits1(gbp);
678 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
679 av_log(m->avctx, AV_LOG_ERROR,
680 "Invalid channel %d specified as output from matrix.\n",
681 s->matrix_out_ch[mat]);
682 return AVERROR_INVALIDDATA;
684 if (frac_bits > 14) {
685 av_log(m->avctx, AV_LOG_ERROR,
686 "Too many fractional bits specified.\n");
687 return AVERROR_INVALIDDATA;
690 max_chan = s->max_matrix_channel;
694 for (ch = 0; ch <= max_chan; ch++) {
697 coeff_val = get_sbits(gbp, frac_bits + 2);
699 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
703 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
705 s->matrix_noise_shift[mat] = 0;
711 /** Read channel parameters. */
713 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
714 GetBitContext *gbp, unsigned int ch)
716 SubStream *s = &m->substream[substr];
717 ChannelParams *cp = &s->channel_params[ch];
718 FilterParams *fir = &cp->filter_params[FIR];
719 FilterParams *iir = &cp->filter_params[IIR];
722 if (s->param_presence_flags & PARAM_FIR)
724 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
727 if (s->param_presence_flags & PARAM_IIR)
729 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
732 if (fir->order + iir->order > 8) {
733 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
734 return AVERROR_INVALIDDATA;
737 if (fir->order && iir->order &&
738 fir->shift != iir->shift) {
739 av_log(m->avctx, AV_LOG_ERROR,
740 "FIR and IIR filters must use the same precision.\n");
741 return AVERROR_INVALIDDATA;
743 /* The FIR and IIR filters must have the same precision.
744 * To simplify the filtering code, only the precision of the
745 * FIR filter is considered. If only the IIR filter is employed,
746 * the FIR filter precision is set to that of the IIR filter, so
747 * that the filtering code can use it. */
748 if (!fir->order && iir->order)
749 fir->shift = iir->shift;
751 if (s->param_presence_flags & PARAM_HUFFOFFSET)
753 cp->huff_offset = get_sbits(gbp, 15);
755 cp->codebook = get_bits(gbp, 2);
756 cp->huff_lsbs = get_bits(gbp, 5);
758 if (cp->huff_lsbs > 24) {
759 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
761 return AVERROR_INVALIDDATA;
764 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
769 /** Read decoding parameters that change more often than those in the restart
772 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
775 SubStream *s = &m->substream[substr];
779 if (s->param_presence_flags & PARAM_PRESENCE)
781 s->param_presence_flags = get_bits(gbp, 8);
783 if (s->param_presence_flags & PARAM_BLOCKSIZE)
784 if (get_bits1(gbp)) {
785 s->blocksize = get_bits(gbp, 9);
786 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
787 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
789 return AVERROR_INVALIDDATA;
793 if (s->param_presence_flags & PARAM_MATRIX)
795 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
798 if (s->param_presence_flags & PARAM_OUTSHIFT)
800 for (ch = 0; ch <= s->max_matrix_channel; ch++)
801 s->output_shift[ch] = get_sbits(gbp, 4);
803 if (s->param_presence_flags & PARAM_QUANTSTEP)
805 for (ch = 0; ch <= s->max_channel; ch++) {
806 ChannelParams *cp = &s->channel_params[ch];
808 s->quant_step_size[ch] = get_bits(gbp, 4);
810 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
813 for (ch = s->min_channel; ch <= s->max_channel; ch++)
815 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
821 #define MSB_MASK(bits) (-1u << bits)
823 /** Generate PCM samples using the prediction filters and residual values
824 * read from the data stream, and update the filter state. */
826 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
827 unsigned int channel)
829 SubStream *s = &m->substream[substr];
830 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
831 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
832 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
833 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
834 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
835 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
836 unsigned int filter_shift = fir->shift;
837 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
839 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
840 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
842 m->dsp.mlp_filter_channel(firbuf, fircoeff,
843 fir->order, iir->order,
844 filter_shift, mask, s->blocksize,
845 &m->sample_buffer[s->blockpos][channel]);
847 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
848 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
851 /** Read a block of PCM residual data (or actual if no filtering active). */
853 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
856 SubStream *s = &m->substream[substr];
857 unsigned int i, ch, expected_stream_pos = 0;
860 if (s->data_check_present) {
861 expected_stream_pos = get_bits_count(gbp);
862 expected_stream_pos += get_bits(gbp, 16);
863 avpriv_request_sample(m->avctx,
864 "Substreams with VLC block size check info");
867 if (s->blockpos + s->blocksize > m->access_unit_size) {
868 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
869 return AVERROR_INVALIDDATA;
872 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
873 s->blocksize * sizeof(m->bypassed_lsbs[0]));
875 for (i = 0; i < s->blocksize; i++)
876 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
879 for (ch = s->min_channel; ch <= s->max_channel; ch++)
880 filter_channel(m, substr, ch);
882 s->blockpos += s->blocksize;
884 if (s->data_check_present) {
885 if (get_bits_count(gbp) != expected_stream_pos)
886 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
893 /** Data table used for TrueHD noise generation function. */
895 static const int8_t noise_table[256] = {
896 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
897 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
898 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
899 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
900 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
901 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
902 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
903 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
904 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
905 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
906 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
907 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
908 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
909 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
910 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
911 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
914 /** Noise generation functions.
915 * I'm not sure what these are for - they seem to be some kind of pseudorandom
916 * sequence generators, used to generate noise data which is used when the
917 * channels are rematrixed. I'm not sure if they provide a practical benefit
918 * to compression, or just obfuscate the decoder. Are they for some kind of
921 /** Generate two channels of noise, used in the matrix when
922 * restart sync word == 0x31ea. */
924 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
926 SubStream *s = &m->substream[substr];
928 uint32_t seed = s->noisegen_seed;
929 unsigned int maxchan = s->max_matrix_channel;
931 for (i = 0; i < s->blockpos; i++) {
932 uint16_t seed_shr7 = seed >> 7;
933 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
934 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
936 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
939 s->noisegen_seed = seed;
942 /** Generate a block of noise, used when restart sync word == 0x31eb. */
944 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
946 SubStream *s = &m->substream[substr];
948 uint32_t seed = s->noisegen_seed;
950 for (i = 0; i < m->access_unit_size_pow2; i++) {
951 uint8_t seed_shr15 = seed >> 15;
952 m->noise_buffer[i] = noise_table[seed_shr15];
953 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
956 s->noisegen_seed = seed;
960 /** Apply the channel matrices in turn to reconstruct the original audio
963 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
965 SubStream *s = &m->substream[substr];
966 unsigned int mat, src_ch, i;
967 unsigned int maxchan;
969 maxchan = s->max_matrix_channel;
970 if (!s->noise_type) {
971 generate_2_noise_channels(m, substr);
974 fill_noise_buffer(m, substr);
977 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
978 int matrix_noise_shift = s->matrix_noise_shift[mat];
979 unsigned int dest_ch = s->matrix_out_ch[mat];
980 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
981 int32_t *coeffs = s->matrix_coeff[mat];
982 int index = s->num_primitive_matrices - mat;
983 int index2 = 2 * index + 1;
985 /* TODO: DSPContext? */
987 for (i = 0; i < s->blockpos; i++) {
988 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
989 int32_t *samples = m->sample_buffer[i];
992 for (src_ch = 0; src_ch <= maxchan; src_ch++)
993 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
995 if (matrix_noise_shift) {
996 index &= m->access_unit_size_pow2 - 1;
997 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
1001 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
1006 /** Write the audio data into the output buffer. */
1008 static int output_data(MLPDecodeContext *m, unsigned int substr,
1009 AVFrame *frame, int *got_frame_ptr)
1011 AVCodecContext *avctx = m->avctx;
1012 SubStream *s = &m->substream[substr];
1013 unsigned int i, out_ch = 0;
1017 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1019 if (m->avctx->channels != s->max_matrix_channel + 1) {
1020 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1021 return AVERROR_INVALIDDATA;
1025 av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1026 return AVERROR_INVALIDDATA;
1029 /* get output buffer */
1030 frame->nb_samples = s->blockpos;
1031 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1033 data_32 = (int32_t *)frame->data[0];
1034 data_16 = (int16_t *)frame->data[0];
1036 for (i = 0; i < s->blockpos; i++) {
1037 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
1038 int mat_ch = s->ch_assign[out_ch];
1039 int32_t sample = m->sample_buffer[i][mat_ch]
1040 << s->output_shift[mat_ch];
1041 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
1042 if (is32) *data_32++ = sample << 8;
1043 else *data_16++ = sample >> 8;
1052 /** Read an access unit from the stream.
1053 * @return negative on error, 0 if not enough data is present in the input stream,
1054 * otherwise the number of bytes consumed. */
1056 static int read_access_unit(AVCodecContext *avctx, void* data,
1057 int *got_frame_ptr, AVPacket *avpkt)
1059 const uint8_t *buf = avpkt->data;
1060 int buf_size = avpkt->size;
1061 MLPDecodeContext *m = avctx->priv_data;
1063 unsigned int length, substr;
1064 unsigned int substream_start;
1065 unsigned int header_size = 4;
1066 unsigned int substr_header_size = 0;
1067 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1068 uint16_t substream_data_len[MAX_SUBSTREAMS];
1069 uint8_t parity_bits;
1073 return AVERROR_INVALIDDATA;
1075 length = (AV_RB16(buf) & 0xfff) * 2;
1077 if (length < 4 || length > buf_size)
1078 return AVERROR_INVALIDDATA;
1080 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1082 m->is_major_sync_unit = 0;
1083 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1084 if (read_major_sync(m, &gb) < 0)
1086 m->is_major_sync_unit = 1;
1090 if (!m->params_valid) {
1091 av_log(m->avctx, AV_LOG_WARNING,
1092 "Stream parameters not seen; skipping frame.\n");
1097 substream_start = 0;
1099 for (substr = 0; substr < m->num_substreams; substr++) {
1100 int extraword_present, checkdata_present, end, nonrestart_substr;
1102 extraword_present = get_bits1(&gb);
1103 nonrestart_substr = get_bits1(&gb);
1104 checkdata_present = get_bits1(&gb);
1107 end = get_bits(&gb, 12) * 2;
1109 substr_header_size += 2;
1111 if (extraword_present) {
1112 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1113 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1117 substr_header_size += 2;
1120 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1121 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1125 if (end + header_size + substr_header_size > length) {
1126 av_log(m->avctx, AV_LOG_ERROR,
1127 "Indicated length of substream %d data goes off end of "
1128 "packet.\n", substr);
1129 end = length - header_size - substr_header_size;
1132 if (end < substream_start) {
1133 av_log(avctx, AV_LOG_ERROR,
1134 "Indicated end offset of substream %d data "
1135 "is smaller than calculated start offset.\n",
1140 if (substr > m->max_decoded_substream)
1143 substream_parity_present[substr] = checkdata_present;
1144 substream_data_len[substr] = end - substream_start;
1145 substream_start = end;
1148 parity_bits = ff_mlp_calculate_parity(buf, 4);
1149 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1151 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1152 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1156 buf += header_size + substr_header_size;
1158 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1159 SubStream *s = &m->substream[substr];
1160 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1162 m->matrix_changed = 0;
1163 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1167 if (get_bits1(&gb)) {
1168 if (get_bits1(&gb)) {
1169 /* A restart header should be present. */
1170 if (read_restart_header(m, &gb, buf, substr) < 0)
1172 s->restart_seen = 1;
1175 if (!s->restart_seen)
1177 if (read_decoding_params(m, &gb, substr) < 0)
1181 if (!s->restart_seen)
1184 if ((ret = read_block_data(m, &gb, substr)) < 0)
1187 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1188 goto substream_length_mismatch;
1190 } while (!get_bits1(&gb));
1192 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1194 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1197 if (get_bits(&gb, 16) != 0xD234)
1198 return AVERROR_INVALIDDATA;
1200 shorten_by = get_bits(&gb, 16);
1201 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1202 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1203 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1204 return AVERROR_INVALIDDATA;
1206 if (substr == m->max_decoded_substream)
1207 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1210 if (substream_parity_present[substr]) {
1211 uint8_t parity, checksum;
1213 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1214 goto substream_length_mismatch;
1216 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1217 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1219 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1220 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1221 if ( get_bits(&gb, 8) != checksum)
1222 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1225 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1226 goto substream_length_mismatch;
1229 if (!s->restart_seen)
1230 av_log(m->avctx, AV_LOG_ERROR,
1231 "No restart header present in substream %d.\n", substr);
1233 buf += substream_data_len[substr];
1236 rematrix_channels(m, m->max_decoded_substream);
1238 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1243 substream_length_mismatch:
1244 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1245 return AVERROR_INVALIDDATA;
1248 m->params_valid = 0;
1249 return AVERROR_INVALIDDATA;
1252 #if CONFIG_MLP_DECODER
1253 AVCodec ff_mlp_decoder = {
1255 .type = AVMEDIA_TYPE_AUDIO,
1256 .id = AV_CODEC_ID_MLP,
1257 .priv_data_size = sizeof(MLPDecodeContext),
1258 .init = mlp_decode_init,
1259 .decode = read_access_unit,
1260 .capabilities = CODEC_CAP_DR1,
1261 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1264 #if CONFIG_TRUEHD_DECODER
1265 AVCodec ff_truehd_decoder = {
1267 .type = AVMEDIA_TYPE_AUDIO,
1268 .id = AV_CODEC_ID_TRUEHD,
1269 .priv_data_size = sizeof(MLPDecodeContext),
1270 .init = mlp_decode_init,
1271 .decode = read_access_unit,
1272 .capabilities = CODEC_CAP_DR1,
1273 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1275 #endif /* CONFIG_TRUEHD_DECODER */