3 * Copyright (c) 2007-2008 Ian Caulfield
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/channel_layout.h"
34 #include "libavutil/crc.h"
36 #include "mlp_parser.h"
40 /** number of bits used for VLC lookup - longest Huffman code is 9 */
43 typedef struct SubStream {
44 /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
48 /** restart header data */
49 /// The type of noise to be used in the rematrix stage.
52 /// The index of the first channel coded in this substream.
54 /// The index of the last channel coded in this substream.
56 /// The number of channels input into the rematrix stage.
57 uint8_t max_matrix_channel;
58 /// For each channel output by the matrix, the output channel to map it to
59 uint8_t ch_assign[MAX_CHANNELS];
60 /// The channel layout for this substream
63 /// Channel coding parameters for channels in the substream
64 ChannelParams channel_params[MAX_CHANNELS];
66 /// The left shift applied to random noise in 0x31ea substreams.
68 /// The current seed value for the pseudorandom noise generator(s).
69 uint32_t noisegen_seed;
71 /// Set if the substream contains extra info to check the size of VLC blocks.
72 uint8_t data_check_present;
74 /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
75 uint8_t param_presence_flags;
76 #define PARAM_BLOCKSIZE (1 << 7)
77 #define PARAM_MATRIX (1 << 6)
78 #define PARAM_OUTSHIFT (1 << 5)
79 #define PARAM_QUANTSTEP (1 << 4)
80 #define PARAM_FIR (1 << 3)
81 #define PARAM_IIR (1 << 2)
82 #define PARAM_HUFFOFFSET (1 << 1)
83 #define PARAM_PRESENCE (1 << 0)
89 /// Number of matrices to be applied.
90 uint8_t num_primitive_matrices;
92 /// matrix output channel
93 uint8_t matrix_out_ch[MAX_MATRICES];
95 /// Whether the LSBs of the matrix output are encoded in the bitstream.
96 uint8_t lsb_bypass[MAX_MATRICES];
97 /// Matrix coefficients, stored as 2.14 fixed point.
98 int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
99 /// Left shift to apply to noise values in 0x31eb substreams.
100 uint8_t matrix_noise_shift[MAX_MATRICES];
103 /// Left shift to apply to Huffman-decoded residuals.
104 uint8_t quant_step_size[MAX_CHANNELS];
106 /// number of PCM samples in current audio block
108 /// Number of PCM samples decoded so far in this frame.
111 /// Left shift to apply to decoded PCM values to get final 24-bit output.
112 int8_t output_shift[MAX_CHANNELS];
114 /// Running XOR of all output samples.
115 int32_t lossless_check_data;
119 typedef struct MLPDecodeContext {
120 AVCodecContext *avctx;
122 /// Current access unit being read has a major sync.
123 int is_major_sync_unit;
125 /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
126 uint8_t params_valid;
128 /// Number of substreams contained within this stream.
129 uint8_t num_substreams;
131 /// Index of the last substream to decode - further substreams are skipped.
132 uint8_t max_decoded_substream;
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 const uint64_t thd_channel_order[] = {
152 AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT, // LR
153 AV_CH_FRONT_CENTER, // C
154 AV_CH_LOW_FREQUENCY, // LFE
155 AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT, // LRs
156 AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT, // LRvh
157 AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
158 AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT, // LRrs
159 AV_CH_BACK_CENTER, // Cs
160 AV_CH_TOP_CENTER, // Ts
161 AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
162 AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT, // LRw
163 AV_CH_TOP_FRONT_CENTER, // Cvh
164 AV_CH_LOW_FREQUENCY_2, // LFE2
167 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
172 if (av_get_channel_layout_nb_channels(channel_layout) <= index)
175 for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
176 if (channel_layout & thd_channel_order[i] && !index--)
177 return thd_channel_order[i];
181 static VLC huff_vlc[3];
183 /** Initialize static data, constant between all invocations of the codec. */
185 static av_cold void init_static(void)
187 if (!huff_vlc[0].bits) {
188 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
189 &ff_mlp_huffman_tables[0][0][1], 2, 1,
190 &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
191 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
192 &ff_mlp_huffman_tables[1][0][1], 2, 1,
193 &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
194 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
195 &ff_mlp_huffman_tables[2][0][1], 2, 1,
196 &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
202 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
203 unsigned int substr, unsigned int ch)
205 SubStream *s = &m->substream[substr];
206 ChannelParams *cp = &s->channel_params[ch];
207 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
208 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
209 int32_t sign_huff_offset = cp->huff_offset;
211 if (cp->codebook > 0)
212 sign_huff_offset -= 7 << lsb_bits;
215 sign_huff_offset -= 1 << sign_shift;
217 return sign_huff_offset;
220 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
223 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
224 unsigned int substr, unsigned int pos)
226 SubStream *s = &m->substream[substr];
227 unsigned int mat, channel;
229 for (mat = 0; mat < s->num_primitive_matrices; mat++)
230 if (s->lsb_bypass[mat])
231 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
233 for (channel = s->min_channel; channel <= s->max_channel; channel++) {
234 ChannelParams *cp = &s->channel_params[channel];
235 int codebook = cp->codebook;
236 int quant_step_size = s->quant_step_size[channel];
237 int lsb_bits = cp->huff_lsbs - quant_step_size;
241 result = get_vlc2(gbp, huff_vlc[codebook-1].table,
242 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
245 return AVERROR_INVALIDDATA;
248 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
250 result += cp->sign_huff_offset;
251 result <<= quant_step_size;
253 m->sample_buffer[pos + s->blockpos][channel] = result;
259 static av_cold int mlp_decode_init(AVCodecContext *avctx)
261 MLPDecodeContext *m = avctx->priv_data;
266 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
267 m->substream[substr].lossless_check_data = 0xffffffff;
268 ff_mlpdsp_init(&m->dsp);
273 /** Read a major sync info header - contains high level information about
274 * the stream - sample rate, channel arrangement etc. Most of this
275 * information is not actually necessary for decoding, only for playback.
278 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
283 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
286 if (mh.group1_bits == 0) {
287 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
288 return AVERROR_INVALIDDATA;
290 if (mh.group2_bits > mh.group1_bits) {
291 av_log(m->avctx, AV_LOG_ERROR,
292 "Channel group 2 cannot have more bits per sample than group 1.\n");
293 return AVERROR_INVALIDDATA;
296 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
297 av_log(m->avctx, AV_LOG_ERROR,
298 "Channel groups with differing sample rates are not currently supported.\n");
299 return AVERROR_INVALIDDATA;
302 if (mh.group1_samplerate == 0) {
303 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
304 return AVERROR_INVALIDDATA;
306 if (mh.group1_samplerate > MAX_SAMPLERATE) {
307 av_log(m->avctx, AV_LOG_ERROR,
308 "Sampling rate %d is greater than the supported maximum (%d).\n",
309 mh.group1_samplerate, MAX_SAMPLERATE);
310 return AVERROR_INVALIDDATA;
312 if (mh.access_unit_size > MAX_BLOCKSIZE) {
313 av_log(m->avctx, AV_LOG_ERROR,
314 "Block size %d is greater than the supported maximum (%d).\n",
315 mh.access_unit_size, MAX_BLOCKSIZE);
316 return AVERROR_INVALIDDATA;
318 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
319 av_log(m->avctx, AV_LOG_ERROR,
320 "Block size pow2 %d is greater than the supported maximum (%d).\n",
321 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
322 return AVERROR_INVALIDDATA;
325 if (mh.num_substreams == 0)
326 return AVERROR_INVALIDDATA;
327 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
328 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
329 return AVERROR_INVALIDDATA;
331 if (mh.num_substreams > MAX_SUBSTREAMS) {
332 av_log_ask_for_sample(m->avctx,
333 "Number of substreams %d is larger than the maximum supported "
334 "by the decoder.\n", mh.num_substreams);
335 return AVERROR_PATCHWELCOME;
338 m->access_unit_size = mh.access_unit_size;
339 m->access_unit_size_pow2 = mh.access_unit_size_pow2;
341 m->num_substreams = mh.num_substreams;
342 m->max_decoded_substream = m->num_substreams - 1;
344 m->avctx->sample_rate = mh.group1_samplerate;
345 m->avctx->frame_size = mh.access_unit_size;
347 m->avctx->bits_per_raw_sample = mh.group1_bits;
348 if (mh.group1_bits > 16)
349 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
351 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
354 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
355 m->substream[substr].restart_seen = 0;
357 /* Set the layout for each substream. When there's more than one, the first
358 * substream is Stereo. Subsequent substreams' layouts are indicated in the
360 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
361 if ((substr = (mh.num_substreams > 1)))
362 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
363 m->substream[substr].ch_layout = mh.channel_layout_mlp;
365 if ((substr = (mh.num_substreams > 1)))
366 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
367 if (mh.num_substreams > 2)
368 if (mh.channel_layout_thd_stream2)
369 m->substream[2].ch_layout = mh.channel_layout_thd_stream2;
371 m->substream[2].ch_layout = mh.channel_layout_thd_stream1;
372 m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;
378 /** Read a restart header from a block in a substream. This contains parameters
379 * required to decode the audio that do not change very often. Generally
380 * (always) present only in blocks following a major sync. */
382 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
383 const uint8_t *buf, unsigned int substr)
385 SubStream *s = &m->substream[substr];
389 uint8_t lossless_check;
390 int start_count = get_bits_count(gbp);
391 const int max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
392 ? MAX_MATRIX_CHANNEL_MLP
393 : MAX_MATRIX_CHANNEL_TRUEHD;
395 sync_word = get_bits(gbp, 13);
397 if (sync_word != 0x31ea >> 1) {
398 av_log(m->avctx, AV_LOG_ERROR,
399 "restart header sync incorrect (got 0x%04x)\n", sync_word);
400 return AVERROR_INVALIDDATA;
403 s->noise_type = get_bits1(gbp);
405 if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
406 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
407 return AVERROR_INVALIDDATA;
410 skip_bits(gbp, 16); /* Output timestamp */
412 s->min_channel = get_bits(gbp, 4);
413 s->max_channel = get_bits(gbp, 4);
414 s->max_matrix_channel = get_bits(gbp, 4);
416 if (s->max_matrix_channel > max_matrix_channel) {
417 av_log(m->avctx, AV_LOG_ERROR,
418 "Max matrix channel cannot be greater than %d.\n",
420 return AVERROR_INVALIDDATA;
423 if (s->max_channel != s->max_matrix_channel) {
424 av_log(m->avctx, AV_LOG_ERROR,
425 "Max channel must be equal max matrix channel.\n");
426 return AVERROR_INVALIDDATA;
429 /* This should happen for TrueHD streams with >6 channels and MLP's noise
430 * type. It is not yet known if this is allowed. */
431 if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
432 av_log_ask_for_sample(m->avctx,
433 "Number of channels %d is larger than the maximum supported "
434 "by the decoder.\n", s->max_channel + 2);
435 return AVERROR_PATCHWELCOME;
438 if (s->min_channel > s->max_channel) {
439 av_log(m->avctx, AV_LOG_ERROR,
440 "Substream min channel cannot be greater than max channel.\n");
441 return AVERROR_INVALIDDATA;
444 #if FF_API_REQUEST_CHANNELS
445 if (m->avctx->request_channels > 0 &&
446 m->avctx->request_channels <= s->max_channel + 1 &&
447 m->max_decoded_substream > substr) {
448 av_log(m->avctx, AV_LOG_DEBUG,
449 "Extracting %d-channel downmix from substream %d. "
450 "Further substreams will be skipped.\n",
451 s->max_channel + 1, substr);
452 m->max_decoded_substream = substr;
455 if (m->avctx->request_channel_layout == s->ch_layout &&
456 m->max_decoded_substream > substr) {
457 av_log(m->avctx, AV_LOG_DEBUG,
458 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
459 "Further substreams will be skipped.\n",
460 s->max_channel + 1, s->ch_layout, substr);
461 m->max_decoded_substream = substr;
464 s->noise_shift = get_bits(gbp, 4);
465 s->noisegen_seed = get_bits(gbp, 23);
469 s->data_check_present = get_bits1(gbp);
470 lossless_check = get_bits(gbp, 8);
471 if (substr == m->max_decoded_substream
472 && s->lossless_check_data != 0xffffffff) {
473 tmp = xor_32_to_8(s->lossless_check_data);
474 if (tmp != lossless_check)
475 av_log(m->avctx, AV_LOG_WARNING,
476 "Lossless check failed - expected %02x, calculated %02x.\n",
477 lossless_check, tmp);
482 memset(s->ch_assign, 0, sizeof(s->ch_assign));
484 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
485 int ch_assign = get_bits(gbp, 6);
486 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
487 uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
489 ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
492 if (ch_assign > s->max_matrix_channel) {
493 av_log_ask_for_sample(m->avctx,
494 "Assignment of matrix channel %d to invalid output channel %d.\n",
496 return AVERROR_PATCHWELCOME;
498 s->ch_assign[ch_assign] = ch;
501 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
503 if (checksum != get_bits(gbp, 8))
504 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
506 /* Set default decoding parameters. */
507 s->param_presence_flags = 0xff;
508 s->num_primitive_matrices = 0;
510 s->lossless_check_data = 0;
512 memset(s->output_shift , 0, sizeof(s->output_shift ));
513 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
515 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
516 ChannelParams *cp = &s->channel_params[ch];
517 cp->filter_params[FIR].order = 0;
518 cp->filter_params[IIR].order = 0;
519 cp->filter_params[FIR].shift = 0;
520 cp->filter_params[IIR].shift = 0;
522 /* Default audio coding is 24-bit raw PCM. */
524 cp->sign_huff_offset = (-1) << 23;
529 if (substr == m->max_decoded_substream) {
530 m->avctx->channels = s->max_matrix_channel + 1;
531 m->avctx->channel_layout = s->ch_layout;
537 /** Read parameters for one of the prediction filters. */
539 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
540 unsigned int substr, unsigned int channel,
543 SubStream *s = &m->substream[substr];
544 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
545 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
546 const char fchar = filter ? 'I' : 'F';
549 // Filter is 0 for FIR, 1 for IIR.
552 if (m->filter_changed[channel][filter]++ > 1) {
553 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
554 return AVERROR_INVALIDDATA;
557 order = get_bits(gbp, 4);
558 if (order > max_order) {
559 av_log(m->avctx, AV_LOG_ERROR,
560 "%cIR filter order %d is greater than maximum %d.\n",
561 fchar, order, max_order);
562 return AVERROR_INVALIDDATA;
567 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
568 int coeff_bits, coeff_shift;
570 fp->shift = get_bits(gbp, 4);
572 coeff_bits = get_bits(gbp, 5);
573 coeff_shift = get_bits(gbp, 3);
574 if (coeff_bits < 1 || coeff_bits > 16) {
575 av_log(m->avctx, AV_LOG_ERROR,
576 "%cIR filter coeff_bits must be between 1 and 16.\n",
578 return AVERROR_INVALIDDATA;
580 if (coeff_bits + coeff_shift > 16) {
581 av_log(m->avctx, AV_LOG_ERROR,
582 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
584 return AVERROR_INVALIDDATA;
587 for (i = 0; i < order; i++)
588 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
590 if (get_bits1(gbp)) {
591 int state_bits, state_shift;
594 av_log(m->avctx, AV_LOG_ERROR,
595 "FIR filter has state data specified.\n");
596 return AVERROR_INVALIDDATA;
599 state_bits = get_bits(gbp, 4);
600 state_shift = get_bits(gbp, 4);
602 /* TODO: Check validity of state data. */
604 for (i = 0; i < order; i++)
605 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
612 /** Read parameters for primitive matrices. */
614 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
616 SubStream *s = &m->substream[substr];
617 unsigned int mat, ch;
618 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
620 : MAX_MATRICES_TRUEHD;
622 if (m->matrix_changed++ > 1) {
623 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
624 return AVERROR_INVALIDDATA;
627 s->num_primitive_matrices = get_bits(gbp, 4);
629 if (s->num_primitive_matrices > max_primitive_matrices) {
630 av_log(m->avctx, AV_LOG_ERROR,
631 "Number of primitive matrices cannot be greater than %d.\n",
632 max_primitive_matrices);
633 return AVERROR_INVALIDDATA;
636 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
637 int frac_bits, max_chan;
638 s->matrix_out_ch[mat] = get_bits(gbp, 4);
639 frac_bits = get_bits(gbp, 4);
640 s->lsb_bypass [mat] = get_bits1(gbp);
642 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
643 av_log(m->avctx, AV_LOG_ERROR,
644 "Invalid channel %d specified as output from matrix.\n",
645 s->matrix_out_ch[mat]);
646 return AVERROR_INVALIDDATA;
648 if (frac_bits > 14) {
649 av_log(m->avctx, AV_LOG_ERROR,
650 "Too many fractional bits specified.\n");
651 return AVERROR_INVALIDDATA;
654 max_chan = s->max_matrix_channel;
658 for (ch = 0; ch <= max_chan; ch++) {
661 coeff_val = get_sbits(gbp, frac_bits + 2);
663 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
667 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
669 s->matrix_noise_shift[mat] = 0;
675 /** Read channel parameters. */
677 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
678 GetBitContext *gbp, unsigned int ch)
680 SubStream *s = &m->substream[substr];
681 ChannelParams *cp = &s->channel_params[ch];
682 FilterParams *fir = &cp->filter_params[FIR];
683 FilterParams *iir = &cp->filter_params[IIR];
686 if (s->param_presence_flags & PARAM_FIR)
688 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
691 if (s->param_presence_flags & PARAM_IIR)
693 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
696 if (fir->order + iir->order > 8) {
697 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
698 return AVERROR_INVALIDDATA;
701 if (fir->order && iir->order &&
702 fir->shift != iir->shift) {
703 av_log(m->avctx, AV_LOG_ERROR,
704 "FIR and IIR filters must use the same precision.\n");
705 return AVERROR_INVALIDDATA;
707 /* The FIR and IIR filters must have the same precision.
708 * To simplify the filtering code, only the precision of the
709 * FIR filter is considered. If only the IIR filter is employed,
710 * the FIR filter precision is set to that of the IIR filter, so
711 * that the filtering code can use it. */
712 if (!fir->order && iir->order)
713 fir->shift = iir->shift;
715 if (s->param_presence_flags & PARAM_HUFFOFFSET)
717 cp->huff_offset = get_sbits(gbp, 15);
719 cp->codebook = get_bits(gbp, 2);
720 cp->huff_lsbs = get_bits(gbp, 5);
722 if (cp->huff_lsbs > 24) {
723 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
724 return AVERROR_INVALIDDATA;
727 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
732 /** Read decoding parameters that change more often than those in the restart
735 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
738 SubStream *s = &m->substream[substr];
742 if (s->param_presence_flags & PARAM_PRESENCE)
744 s->param_presence_flags = get_bits(gbp, 8);
746 if (s->param_presence_flags & PARAM_BLOCKSIZE)
747 if (get_bits1(gbp)) {
748 s->blocksize = get_bits(gbp, 9);
749 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
750 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
752 return AVERROR_INVALIDDATA;
756 if (s->param_presence_flags & PARAM_MATRIX)
758 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
761 if (s->param_presence_flags & PARAM_OUTSHIFT)
763 for (ch = 0; ch <= s->max_matrix_channel; ch++)
764 s->output_shift[ch] = get_sbits(gbp, 4);
766 if (s->param_presence_flags & PARAM_QUANTSTEP)
768 for (ch = 0; ch <= s->max_channel; ch++) {
769 ChannelParams *cp = &s->channel_params[ch];
771 s->quant_step_size[ch] = get_bits(gbp, 4);
773 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
776 for (ch = s->min_channel; ch <= s->max_channel; ch++)
778 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
784 #define MSB_MASK(bits) (-1u << bits)
786 /** Generate PCM samples using the prediction filters and residual values
787 * read from the data stream, and update the filter state. */
789 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
790 unsigned int channel)
792 SubStream *s = &m->substream[substr];
793 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
794 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
795 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
796 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
797 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
798 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
799 unsigned int filter_shift = fir->shift;
800 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
802 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
803 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
805 m->dsp.mlp_filter_channel(firbuf, fircoeff,
806 fir->order, iir->order,
807 filter_shift, mask, s->blocksize,
808 &m->sample_buffer[s->blockpos][channel]);
810 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
811 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
814 /** Read a block of PCM residual data (or actual if no filtering active). */
816 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
819 SubStream *s = &m->substream[substr];
820 unsigned int i, ch, expected_stream_pos = 0;
823 if (s->data_check_present) {
824 expected_stream_pos = get_bits_count(gbp);
825 expected_stream_pos += get_bits(gbp, 16);
826 av_log_ask_for_sample(m->avctx, "This file contains some features "
827 "we have not tested yet.\n");
830 if (s->blockpos + s->blocksize > m->access_unit_size) {
831 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
832 return AVERROR_INVALIDDATA;
835 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
836 s->blocksize * sizeof(m->bypassed_lsbs[0]));
838 for (i = 0; i < s->blocksize; i++)
839 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
842 for (ch = s->min_channel; ch <= s->max_channel; ch++)
843 filter_channel(m, substr, ch);
845 s->blockpos += s->blocksize;
847 if (s->data_check_present) {
848 if (get_bits_count(gbp) != expected_stream_pos)
849 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
856 /** Data table used for TrueHD noise generation function. */
858 static const int8_t noise_table[256] = {
859 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
860 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
861 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
862 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
863 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
864 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
865 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
866 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
867 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
868 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
869 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
870 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
871 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
872 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
873 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
874 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
877 /** Noise generation functions.
878 * I'm not sure what these are for - they seem to be some kind of pseudorandom
879 * sequence generators, used to generate noise data which is used when the
880 * channels are rematrixed. I'm not sure if they provide a practical benefit
881 * to compression, or just obfuscate the decoder. Are they for some kind of
884 /** Generate two channels of noise, used in the matrix when
885 * restart sync word == 0x31ea. */
887 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
889 SubStream *s = &m->substream[substr];
891 uint32_t seed = s->noisegen_seed;
892 unsigned int maxchan = s->max_matrix_channel;
894 for (i = 0; i < s->blockpos; i++) {
895 uint16_t seed_shr7 = seed >> 7;
896 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
897 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
899 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
902 s->noisegen_seed = seed;
905 /** Generate a block of noise, used when restart sync word == 0x31eb. */
907 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
909 SubStream *s = &m->substream[substr];
911 uint32_t seed = s->noisegen_seed;
913 for (i = 0; i < m->access_unit_size_pow2; i++) {
914 uint8_t seed_shr15 = seed >> 15;
915 m->noise_buffer[i] = noise_table[seed_shr15];
916 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
919 s->noisegen_seed = seed;
923 /** Apply the channel matrices in turn to reconstruct the original audio
926 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
928 SubStream *s = &m->substream[substr];
929 unsigned int mat, src_ch, i;
930 unsigned int maxchan;
932 maxchan = s->max_matrix_channel;
933 if (!s->noise_type) {
934 generate_2_noise_channels(m, substr);
937 fill_noise_buffer(m, substr);
940 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
941 int matrix_noise_shift = s->matrix_noise_shift[mat];
942 unsigned int dest_ch = s->matrix_out_ch[mat];
943 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
944 int32_t *coeffs = s->matrix_coeff[mat];
945 int index = s->num_primitive_matrices - mat;
946 int index2 = 2 * index + 1;
948 /* TODO: DSPContext? */
950 for (i = 0; i < s->blockpos; i++) {
951 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
952 int32_t *samples = m->sample_buffer[i];
955 for (src_ch = 0; src_ch <= maxchan; src_ch++)
956 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
958 if (matrix_noise_shift) {
959 index &= m->access_unit_size_pow2 - 1;
960 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
964 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
969 /** Write the audio data into the output buffer. */
971 static int output_data(MLPDecodeContext *m, unsigned int substr,
972 AVFrame *frame, int *got_frame_ptr)
974 AVCodecContext *avctx = m->avctx;
975 SubStream *s = &m->substream[substr];
976 unsigned int i, out_ch = 0;
980 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
982 if (m->avctx->channels != s->max_matrix_channel + 1) {
983 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
984 return AVERROR_INVALIDDATA;
988 av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
989 return AVERROR_INVALIDDATA;
992 /* get output buffer */
993 frame->nb_samples = s->blockpos;
994 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
995 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
998 data_32 = (int32_t *)frame->data[0];
999 data_16 = (int16_t *)frame->data[0];
1001 for (i = 0; i < s->blockpos; i++) {
1002 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
1003 int mat_ch = s->ch_assign[out_ch];
1004 int32_t sample = m->sample_buffer[i][mat_ch]
1005 << s->output_shift[mat_ch];
1006 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
1007 if (is32) *data_32++ = sample << 8;
1008 else *data_16++ = sample >> 8;
1017 /** Read an access unit from the stream.
1018 * @return negative on error, 0 if not enough data is present in the input stream,
1019 * otherwise the number of bytes consumed. */
1021 static int read_access_unit(AVCodecContext *avctx, void* data,
1022 int *got_frame_ptr, AVPacket *avpkt)
1024 const uint8_t *buf = avpkt->data;
1025 int buf_size = avpkt->size;
1026 MLPDecodeContext *m = avctx->priv_data;
1028 unsigned int length, substr;
1029 unsigned int substream_start;
1030 unsigned int header_size = 4;
1031 unsigned int substr_header_size = 0;
1032 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1033 uint16_t substream_data_len[MAX_SUBSTREAMS];
1034 uint8_t parity_bits;
1040 length = (AV_RB16(buf) & 0xfff) * 2;
1042 if (length < 4 || length > buf_size)
1043 return AVERROR_INVALIDDATA;
1045 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1047 m->is_major_sync_unit = 0;
1048 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1049 if (read_major_sync(m, &gb) < 0)
1051 m->is_major_sync_unit = 1;
1055 if (!m->params_valid) {
1056 av_log(m->avctx, AV_LOG_WARNING,
1057 "Stream parameters not seen; skipping frame.\n");
1062 substream_start = 0;
1064 for (substr = 0; substr < m->num_substreams; substr++) {
1065 int extraword_present, checkdata_present, end, nonrestart_substr;
1067 extraword_present = get_bits1(&gb);
1068 nonrestart_substr = get_bits1(&gb);
1069 checkdata_present = get_bits1(&gb);
1072 end = get_bits(&gb, 12) * 2;
1074 substr_header_size += 2;
1076 if (extraword_present) {
1077 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1078 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1082 substr_header_size += 2;
1085 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1086 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1090 if (end + header_size + substr_header_size > length) {
1091 av_log(m->avctx, AV_LOG_ERROR,
1092 "Indicated length of substream %d data goes off end of "
1093 "packet.\n", substr);
1094 end = length - header_size - substr_header_size;
1097 if (end < substream_start) {
1098 av_log(avctx, AV_LOG_ERROR,
1099 "Indicated end offset of substream %d data "
1100 "is smaller than calculated start offset.\n",
1105 if (substr > m->max_decoded_substream)
1108 substream_parity_present[substr] = checkdata_present;
1109 substream_data_len[substr] = end - substream_start;
1110 substream_start = end;
1113 parity_bits = ff_mlp_calculate_parity(buf, 4);
1114 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1116 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1117 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1121 buf += header_size + substr_header_size;
1123 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1124 SubStream *s = &m->substream[substr];
1125 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1127 m->matrix_changed = 0;
1128 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1132 if (get_bits1(&gb)) {
1133 if (get_bits1(&gb)) {
1134 /* A restart header should be present. */
1135 if (read_restart_header(m, &gb, buf, substr) < 0)
1137 s->restart_seen = 1;
1140 if (!s->restart_seen)
1142 if (read_decoding_params(m, &gb, substr) < 0)
1146 if (!s->restart_seen)
1149 if ((ret = read_block_data(m, &gb, substr)) < 0)
1152 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1153 goto substream_length_mismatch;
1155 } while (!get_bits1(&gb));
1157 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1159 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1162 if (get_bits(&gb, 16) != 0xD234)
1163 return AVERROR_INVALIDDATA;
1165 shorten_by = get_bits(&gb, 16);
1166 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1167 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1168 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1169 return AVERROR_INVALIDDATA;
1171 if (substr == m->max_decoded_substream)
1172 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1175 if (substream_parity_present[substr]) {
1176 uint8_t parity, checksum;
1178 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1179 goto substream_length_mismatch;
1181 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1182 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1184 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1185 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1186 if ( get_bits(&gb, 8) != checksum)
1187 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1190 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1191 goto substream_length_mismatch;
1194 if (!s->restart_seen)
1195 av_log(m->avctx, AV_LOG_ERROR,
1196 "No restart header present in substream %d.\n", substr);
1198 buf += substream_data_len[substr];
1201 rematrix_channels(m, m->max_decoded_substream);
1203 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1208 substream_length_mismatch:
1209 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1210 return AVERROR_INVALIDDATA;
1213 m->params_valid = 0;
1214 return AVERROR_INVALIDDATA;
1217 AVCodec ff_mlp_decoder = {
1219 .type = AVMEDIA_TYPE_AUDIO,
1220 .id = AV_CODEC_ID_MLP,
1221 .priv_data_size = sizeof(MLPDecodeContext),
1222 .init = mlp_decode_init,
1223 .decode = read_access_unit,
1224 .capabilities = CODEC_CAP_DR1,
1225 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1228 #if CONFIG_TRUEHD_DECODER
1229 AVCodec ff_truehd_decoder = {
1231 .type = AVMEDIA_TYPE_AUDIO,
1232 .id = AV_CODEC_ID_TRUEHD,
1233 .priv_data_size = sizeof(MLPDecodeContext),
1234 .init = mlp_decode_init,
1235 .decode = read_access_unit,
1236 .capabilities = CODEC_CAP_DR1,
1237 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1239 #endif /* CONFIG_TRUEHD_DECODER */