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 (mh.stream_type != 0xbb) {
367 avpriv_request_sample(m->avctx,
368 "unexpected stream_type %X in MLP",
370 return AVERROR_PATCHWELCOME;
372 if ((substr = (mh.num_substreams > 1)))
373 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
374 m->substream[substr].ch_layout = mh.channel_layout_mlp;
376 if (mh.stream_type != 0xba) {
377 avpriv_request_sample(m->avctx,
378 "unexpected stream_type %X in !MLP",
380 return AVERROR_PATCHWELCOME;
382 if ((substr = (mh.num_substreams > 1)))
383 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
384 if (mh.num_substreams > 2)
385 if (mh.channel_layout_thd_stream2)
386 m->substream[2].ch_layout = mh.channel_layout_thd_stream2;
388 m->substream[2].ch_layout = mh.channel_layout_thd_stream1;
389 m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;
391 if (m->avctx->channels<=2 && m->substream[substr].ch_layout == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
392 av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
393 m->max_decoded_substream = 0;
394 if (m->avctx->channels==2)
395 m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
399 m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
404 /** Read a restart header from a block in a substream. This contains parameters
405 * required to decode the audio that do not change very often. Generally
406 * (always) present only in blocks following a major sync. */
408 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
409 const uint8_t *buf, unsigned int substr)
411 SubStream *s = &m->substream[substr];
415 uint8_t lossless_check;
416 int start_count = get_bits_count(gbp);
417 int min_channel, max_channel, max_matrix_channel;
418 const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
419 ? MAX_MATRIX_CHANNEL_MLP
420 : MAX_MATRIX_CHANNEL_TRUEHD;
422 sync_word = get_bits(gbp, 13);
424 if (sync_word != 0x31ea >> 1) {
425 av_log(m->avctx, AV_LOG_ERROR,
426 "restart header sync incorrect (got 0x%04x)\n", sync_word);
427 return AVERROR_INVALIDDATA;
430 s->noise_type = get_bits1(gbp);
432 if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
433 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
434 return AVERROR_INVALIDDATA;
437 skip_bits(gbp, 16); /* Output timestamp */
439 min_channel = get_bits(gbp, 4);
440 max_channel = get_bits(gbp, 4);
441 max_matrix_channel = get_bits(gbp, 4);
443 if (max_matrix_channel > std_max_matrix_channel) {
444 av_log(m->avctx, AV_LOG_ERROR,
445 "Max matrix channel cannot be greater than %d.\n",
446 std_max_matrix_channel);
447 return AVERROR_INVALIDDATA;
450 if (max_channel != max_matrix_channel) {
451 av_log(m->avctx, AV_LOG_ERROR,
452 "Max channel must be equal max matrix channel.\n");
453 return AVERROR_INVALIDDATA;
456 /* This should happen for TrueHD streams with >6 channels and MLP's noise
457 * type. It is not yet known if this is allowed. */
458 if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
459 avpriv_request_sample(m->avctx,
460 "%d channels (more than the "
461 "maximum supported by the decoder)",
463 return AVERROR_PATCHWELCOME;
466 if (min_channel > max_channel) {
467 av_log(m->avctx, AV_LOG_ERROR,
468 "Substream min channel cannot be greater than max channel.\n");
469 return AVERROR_INVALIDDATA;
472 s->min_channel = min_channel;
473 s->max_channel = max_channel;
474 s->max_matrix_channel = max_matrix_channel;
476 #if FF_API_REQUEST_CHANNELS
477 FF_DISABLE_DEPRECATION_WARNINGS
478 if (m->avctx->request_channels > 0 &&
479 m->avctx->request_channels <= s->max_channel + 1 &&
480 m->max_decoded_substream > substr) {
481 av_log(m->avctx, AV_LOG_DEBUG,
482 "Extracting %d-channel downmix from substream %d. "
483 "Further substreams will be skipped.\n",
484 s->max_channel + 1, substr);
485 m->max_decoded_substream = substr;
486 FF_ENABLE_DEPRECATION_WARNINGS
489 if (m->avctx->request_channel_layout == s->ch_layout &&
490 m->max_decoded_substream > substr) {
491 av_log(m->avctx, AV_LOG_DEBUG,
492 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
493 "Further substreams will be skipped.\n",
494 s->max_channel + 1, s->ch_layout, substr);
495 m->max_decoded_substream = substr;
498 s->noise_shift = get_bits(gbp, 4);
499 s->noisegen_seed = get_bits(gbp, 23);
503 s->data_check_present = get_bits1(gbp);
504 lossless_check = get_bits(gbp, 8);
505 if (substr == m->max_decoded_substream
506 && s->lossless_check_data != 0xffffffff) {
507 tmp = xor_32_to_8(s->lossless_check_data);
508 if (tmp != lossless_check)
509 av_log(m->avctx, AV_LOG_WARNING,
510 "Lossless check failed - expected %02x, calculated %02x.\n",
511 lossless_check, tmp);
516 memset(s->ch_assign, 0, sizeof(s->ch_assign));
518 for (ch = 0; ch <= s->max_matrix_channel; ch++) {
519 int ch_assign = get_bits(gbp, 6);
520 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
521 uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
523 ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
526 if ((unsigned)ch_assign > s->max_matrix_channel) {
527 avpriv_request_sample(m->avctx,
528 "Assignment of matrix channel %d to invalid output channel %d",
530 return AVERROR_PATCHWELCOME;
532 s->ch_assign[ch_assign] = ch;
535 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
537 if (checksum != get_bits(gbp, 8))
538 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
540 /* Set default decoding parameters. */
541 s->param_presence_flags = 0xff;
542 s->num_primitive_matrices = 0;
544 s->lossless_check_data = 0;
546 memset(s->output_shift , 0, sizeof(s->output_shift ));
547 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
549 for (ch = s->min_channel; ch <= s->max_channel; ch++) {
550 ChannelParams *cp = &s->channel_params[ch];
551 cp->filter_params[FIR].order = 0;
552 cp->filter_params[IIR].order = 0;
553 cp->filter_params[FIR].shift = 0;
554 cp->filter_params[IIR].shift = 0;
556 /* Default audio coding is 24-bit raw PCM. */
558 cp->sign_huff_offset = (-1) << 23;
563 if (substr == m->max_decoded_substream) {
564 m->avctx->channels = s->max_matrix_channel + 1;
565 m->avctx->channel_layout = s->ch_layout;
567 if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
568 if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
569 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
570 int i = s->ch_assign[4];
571 s->ch_assign[4] = s->ch_assign[3];
572 s->ch_assign[3] = s->ch_assign[2];
574 } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
575 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
576 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
585 /** Read parameters for one of the prediction filters. */
587 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
588 unsigned int substr, unsigned int channel,
591 SubStream *s = &m->substream[substr];
592 FilterParams *fp = &s->channel_params[channel].filter_params[filter];
593 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
594 const char fchar = filter ? 'I' : 'F';
597 // Filter is 0 for FIR, 1 for IIR.
598 av_assert0(filter < 2);
600 if (m->filter_changed[channel][filter]++ > 1) {
601 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
602 return AVERROR_INVALIDDATA;
605 order = get_bits(gbp, 4);
606 if (order > max_order) {
607 av_log(m->avctx, AV_LOG_ERROR,
608 "%cIR filter order %d is greater than maximum %d.\n",
609 fchar, order, max_order);
610 return AVERROR_INVALIDDATA;
615 int32_t *fcoeff = s->channel_params[channel].coeff[filter];
616 int coeff_bits, coeff_shift;
618 fp->shift = get_bits(gbp, 4);
620 coeff_bits = get_bits(gbp, 5);
621 coeff_shift = get_bits(gbp, 3);
622 if (coeff_bits < 1 || coeff_bits > 16) {
623 av_log(m->avctx, AV_LOG_ERROR,
624 "%cIR filter coeff_bits must be between 1 and 16.\n",
626 return AVERROR_INVALIDDATA;
628 if (coeff_bits + coeff_shift > 16) {
629 av_log(m->avctx, AV_LOG_ERROR,
630 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
632 return AVERROR_INVALIDDATA;
635 for (i = 0; i < order; i++)
636 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
638 if (get_bits1(gbp)) {
639 int state_bits, state_shift;
642 av_log(m->avctx, AV_LOG_ERROR,
643 "FIR filter has state data specified.\n");
644 return AVERROR_INVALIDDATA;
647 state_bits = get_bits(gbp, 4);
648 state_shift = get_bits(gbp, 4);
650 /* TODO: Check validity of state data. */
652 for (i = 0; i < order; i++)
653 fp->state[i] = state_bits ? get_sbits(gbp, state_bits) << state_shift : 0;
660 /** Read parameters for primitive matrices. */
662 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
664 SubStream *s = &m->substream[substr];
665 unsigned int mat, ch;
666 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
668 : MAX_MATRICES_TRUEHD;
670 if (m->matrix_changed++ > 1) {
671 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
672 return AVERROR_INVALIDDATA;
675 s->num_primitive_matrices = get_bits(gbp, 4);
677 if (s->num_primitive_matrices > max_primitive_matrices) {
678 av_log(m->avctx, AV_LOG_ERROR,
679 "Number of primitive matrices cannot be greater than %d.\n",
680 max_primitive_matrices);
681 return AVERROR_INVALIDDATA;
684 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
685 int frac_bits, max_chan;
686 s->matrix_out_ch[mat] = get_bits(gbp, 4);
687 frac_bits = get_bits(gbp, 4);
688 s->lsb_bypass [mat] = get_bits1(gbp);
690 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
691 av_log(m->avctx, AV_LOG_ERROR,
692 "Invalid channel %d specified as output from matrix.\n",
693 s->matrix_out_ch[mat]);
694 return AVERROR_INVALIDDATA;
696 if (frac_bits > 14) {
697 av_log(m->avctx, AV_LOG_ERROR,
698 "Too many fractional bits specified.\n");
699 return AVERROR_INVALIDDATA;
702 max_chan = s->max_matrix_channel;
706 for (ch = 0; ch <= max_chan; ch++) {
709 coeff_val = get_sbits(gbp, frac_bits + 2);
711 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
715 s->matrix_noise_shift[mat] = get_bits(gbp, 4);
717 s->matrix_noise_shift[mat] = 0;
723 /** Read channel parameters. */
725 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
726 GetBitContext *gbp, unsigned int ch)
728 SubStream *s = &m->substream[substr];
729 ChannelParams *cp = &s->channel_params[ch];
730 FilterParams *fir = &cp->filter_params[FIR];
731 FilterParams *iir = &cp->filter_params[IIR];
734 if (s->param_presence_flags & PARAM_FIR)
736 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
739 if (s->param_presence_flags & PARAM_IIR)
741 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
744 if (fir->order + iir->order > 8) {
745 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
746 return AVERROR_INVALIDDATA;
749 if (fir->order && iir->order &&
750 fir->shift != iir->shift) {
751 av_log(m->avctx, AV_LOG_ERROR,
752 "FIR and IIR filters must use the same precision.\n");
753 return AVERROR_INVALIDDATA;
755 /* The FIR and IIR filters must have the same precision.
756 * To simplify the filtering code, only the precision of the
757 * FIR filter is considered. If only the IIR filter is employed,
758 * the FIR filter precision is set to that of the IIR filter, so
759 * that the filtering code can use it. */
760 if (!fir->order && iir->order)
761 fir->shift = iir->shift;
763 if (s->param_presence_flags & PARAM_HUFFOFFSET)
765 cp->huff_offset = get_sbits(gbp, 15);
767 cp->codebook = get_bits(gbp, 2);
768 cp->huff_lsbs = get_bits(gbp, 5);
770 if (cp->huff_lsbs > 24) {
771 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
773 return AVERROR_INVALIDDATA;
776 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
781 /** Read decoding parameters that change more often than those in the restart
784 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
787 SubStream *s = &m->substream[substr];
791 if (s->param_presence_flags & PARAM_PRESENCE)
793 s->param_presence_flags = get_bits(gbp, 8);
795 if (s->param_presence_flags & PARAM_BLOCKSIZE)
796 if (get_bits1(gbp)) {
797 s->blocksize = get_bits(gbp, 9);
798 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
799 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
801 return AVERROR_INVALIDDATA;
805 if (s->param_presence_flags & PARAM_MATRIX)
807 if ((ret = read_matrix_params(m, substr, gbp)) < 0)
810 if (s->param_presence_flags & PARAM_OUTSHIFT)
812 for (ch = 0; ch <= s->max_matrix_channel; ch++)
813 s->output_shift[ch] = get_sbits(gbp, 4);
815 if (s->param_presence_flags & PARAM_QUANTSTEP)
817 for (ch = 0; ch <= s->max_channel; ch++) {
818 ChannelParams *cp = &s->channel_params[ch];
820 s->quant_step_size[ch] = get_bits(gbp, 4);
822 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
825 for (ch = s->min_channel; ch <= s->max_channel; ch++)
827 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
833 #define MSB_MASK(bits) (-1u << bits)
835 /** Generate PCM samples using the prediction filters and residual values
836 * read from the data stream, and update the filter state. */
838 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
839 unsigned int channel)
841 SubStream *s = &m->substream[substr];
842 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
843 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
844 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
845 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
846 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
847 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
848 unsigned int filter_shift = fir->shift;
849 int32_t mask = MSB_MASK(s->quant_step_size[channel]);
851 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
852 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
854 m->dsp.mlp_filter_channel(firbuf, fircoeff,
855 fir->order, iir->order,
856 filter_shift, mask, s->blocksize,
857 &m->sample_buffer[s->blockpos][channel]);
859 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
860 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
863 /** Read a block of PCM residual data (or actual if no filtering active). */
865 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
868 SubStream *s = &m->substream[substr];
869 unsigned int i, ch, expected_stream_pos = 0;
872 if (s->data_check_present) {
873 expected_stream_pos = get_bits_count(gbp);
874 expected_stream_pos += get_bits(gbp, 16);
875 avpriv_request_sample(m->avctx,
876 "Substreams with VLC block size check info");
879 if (s->blockpos + s->blocksize > m->access_unit_size) {
880 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
881 return AVERROR_INVALIDDATA;
884 memset(&m->bypassed_lsbs[s->blockpos][0], 0,
885 s->blocksize * sizeof(m->bypassed_lsbs[0]));
887 for (i = 0; i < s->blocksize; i++)
888 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
891 for (ch = s->min_channel; ch <= s->max_channel; ch++)
892 filter_channel(m, substr, ch);
894 s->blockpos += s->blocksize;
896 if (s->data_check_present) {
897 if (get_bits_count(gbp) != expected_stream_pos)
898 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
905 /** Data table used for TrueHD noise generation function. */
907 static const int8_t noise_table[256] = {
908 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
909 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
910 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
911 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
912 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
913 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
914 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
915 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
916 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
917 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
918 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
919 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
920 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
921 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
922 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
923 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
926 /** Noise generation functions.
927 * I'm not sure what these are for - they seem to be some kind of pseudorandom
928 * sequence generators, used to generate noise data which is used when the
929 * channels are rematrixed. I'm not sure if they provide a practical benefit
930 * to compression, or just obfuscate the decoder. Are they for some kind of
933 /** Generate two channels of noise, used in the matrix when
934 * restart sync word == 0x31ea. */
936 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
938 SubStream *s = &m->substream[substr];
940 uint32_t seed = s->noisegen_seed;
941 unsigned int maxchan = s->max_matrix_channel;
943 for (i = 0; i < s->blockpos; i++) {
944 uint16_t seed_shr7 = seed >> 7;
945 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
946 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;
948 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
951 s->noisegen_seed = seed;
954 /** Generate a block of noise, used when restart sync word == 0x31eb. */
956 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
958 SubStream *s = &m->substream[substr];
960 uint32_t seed = s->noisegen_seed;
962 for (i = 0; i < m->access_unit_size_pow2; i++) {
963 uint8_t seed_shr15 = seed >> 15;
964 m->noise_buffer[i] = noise_table[seed_shr15];
965 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
968 s->noisegen_seed = seed;
972 /** Apply the channel matrices in turn to reconstruct the original audio
975 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
977 SubStream *s = &m->substream[substr];
978 unsigned int mat, src_ch, i;
979 unsigned int maxchan;
981 maxchan = s->max_matrix_channel;
982 if (!s->noise_type) {
983 generate_2_noise_channels(m, substr);
986 fill_noise_buffer(m, substr);
989 for (mat = 0; mat < s->num_primitive_matrices; mat++) {
990 int matrix_noise_shift = s->matrix_noise_shift[mat];
991 unsigned int dest_ch = s->matrix_out_ch[mat];
992 int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
993 int32_t *coeffs = s->matrix_coeff[mat];
994 int index = s->num_primitive_matrices - mat;
995 int index2 = 2 * index + 1;
997 /* TODO: DSPContext? */
999 for (i = 0; i < s->blockpos; i++) {
1000 int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
1001 int32_t *samples = m->sample_buffer[i];
1004 for (src_ch = 0; src_ch <= maxchan; src_ch++)
1005 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
1007 if (matrix_noise_shift) {
1008 index &= m->access_unit_size_pow2 - 1;
1009 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
1013 samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
1018 /** Write the audio data into the output buffer. */
1020 static int output_data(MLPDecodeContext *m, unsigned int substr,
1021 AVFrame *frame, int *got_frame_ptr)
1023 AVCodecContext *avctx = m->avctx;
1024 SubStream *s = &m->substream[substr];
1025 unsigned int i, out_ch = 0;
1029 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1031 if (m->avctx->channels != s->max_matrix_channel + 1) {
1032 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1033 return AVERROR_INVALIDDATA;
1037 av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1038 return AVERROR_INVALIDDATA;
1041 /* get output buffer */
1042 frame->nb_samples = s->blockpos;
1043 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1045 data_32 = (int32_t *)frame->data[0];
1046 data_16 = (int16_t *)frame->data[0];
1048 for (i = 0; i < s->blockpos; i++) {
1049 for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
1050 int mat_ch = s->ch_assign[out_ch];
1051 int32_t sample = m->sample_buffer[i][mat_ch]
1052 << s->output_shift[mat_ch];
1053 s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
1054 if (is32) *data_32++ = sample << 8;
1055 else *data_16++ = sample >> 8;
1064 /** Read an access unit from the stream.
1065 * @return negative on error, 0 if not enough data is present in the input stream,
1066 * otherwise the number of bytes consumed. */
1068 static int read_access_unit(AVCodecContext *avctx, void* data,
1069 int *got_frame_ptr, AVPacket *avpkt)
1071 const uint8_t *buf = avpkt->data;
1072 int buf_size = avpkt->size;
1073 MLPDecodeContext *m = avctx->priv_data;
1075 unsigned int length, substr;
1076 unsigned int substream_start;
1077 unsigned int header_size = 4;
1078 unsigned int substr_header_size = 0;
1079 uint8_t substream_parity_present[MAX_SUBSTREAMS];
1080 uint16_t substream_data_len[MAX_SUBSTREAMS];
1081 uint8_t parity_bits;
1085 return AVERROR_INVALIDDATA;
1087 length = (AV_RB16(buf) & 0xfff) * 2;
1089 if (length < 4 || length > buf_size)
1090 return AVERROR_INVALIDDATA;
1092 init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1094 m->is_major_sync_unit = 0;
1095 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1096 if (read_major_sync(m, &gb) < 0)
1098 m->is_major_sync_unit = 1;
1102 if (!m->params_valid) {
1103 av_log(m->avctx, AV_LOG_WARNING,
1104 "Stream parameters not seen; skipping frame.\n");
1109 substream_start = 0;
1111 for (substr = 0; substr < m->num_substreams; substr++) {
1112 int extraword_present, checkdata_present, end, nonrestart_substr;
1114 extraword_present = get_bits1(&gb);
1115 nonrestart_substr = get_bits1(&gb);
1116 checkdata_present = get_bits1(&gb);
1119 end = get_bits(&gb, 12) * 2;
1121 substr_header_size += 2;
1123 if (extraword_present) {
1124 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1125 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1129 substr_header_size += 2;
1132 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1133 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1137 if (end + header_size + substr_header_size > length) {
1138 av_log(m->avctx, AV_LOG_ERROR,
1139 "Indicated length of substream %d data goes off end of "
1140 "packet.\n", substr);
1141 end = length - header_size - substr_header_size;
1144 if (end < substream_start) {
1145 av_log(avctx, AV_LOG_ERROR,
1146 "Indicated end offset of substream %d data "
1147 "is smaller than calculated start offset.\n",
1152 if (substr > m->max_decoded_substream)
1155 substream_parity_present[substr] = checkdata_present;
1156 substream_data_len[substr] = end - substream_start;
1157 substream_start = end;
1160 parity_bits = ff_mlp_calculate_parity(buf, 4);
1161 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1163 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1164 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1168 buf += header_size + substr_header_size;
1170 for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1171 SubStream *s = &m->substream[substr];
1172 init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1174 m->matrix_changed = 0;
1175 memset(m->filter_changed, 0, sizeof(m->filter_changed));
1179 if (get_bits1(&gb)) {
1180 if (get_bits1(&gb)) {
1181 /* A restart header should be present. */
1182 if (read_restart_header(m, &gb, buf, substr) < 0)
1184 s->restart_seen = 1;
1187 if (!s->restart_seen)
1189 if (read_decoding_params(m, &gb, substr) < 0)
1193 if (!s->restart_seen)
1196 if ((ret = read_block_data(m, &gb, substr)) < 0)
1199 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1200 goto substream_length_mismatch;
1202 } while (!get_bits1(&gb));
1204 skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1206 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1209 if (get_bits(&gb, 16) != 0xD234)
1210 return AVERROR_INVALIDDATA;
1212 shorten_by = get_bits(&gb, 16);
1213 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)
1214 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1215 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)
1216 return AVERROR_INVALIDDATA;
1218 if (substr == m->max_decoded_substream)
1219 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1222 if (substream_parity_present[substr]) {
1223 uint8_t parity, checksum;
1225 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1226 goto substream_length_mismatch;
1228 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1229 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);
1231 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )
1232 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1233 if ( get_bits(&gb, 8) != checksum)
1234 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);
1237 if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1238 goto substream_length_mismatch;
1241 if (!s->restart_seen)
1242 av_log(m->avctx, AV_LOG_ERROR,
1243 "No restart header present in substream %d.\n", substr);
1245 buf += substream_data_len[substr];
1248 rematrix_channels(m, m->max_decoded_substream);
1250 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1255 substream_length_mismatch:
1256 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1257 return AVERROR_INVALIDDATA;
1260 m->params_valid = 0;
1261 return AVERROR_INVALIDDATA;
1264 #if CONFIG_MLP_DECODER
1265 AVCodec ff_mlp_decoder = {
1267 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1268 .type = AVMEDIA_TYPE_AUDIO,
1269 .id = AV_CODEC_ID_MLP,
1270 .priv_data_size = sizeof(MLPDecodeContext),
1271 .init = mlp_decode_init,
1272 .decode = read_access_unit,
1273 .capabilities = CODEC_CAP_DR1,
1276 #if CONFIG_TRUEHD_DECODER
1277 AVCodec ff_truehd_decoder = {
1279 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1280 .type = AVMEDIA_TYPE_AUDIO,
1281 .id = AV_CODEC_ID_TRUEHD,
1282 .priv_data_size = sizeof(MLPDecodeContext),
1283 .init = mlp_decode_init,
1284 .decode = read_access_unit,
1285 .capabilities = CODEC_CAP_DR1,
1287 #endif /* CONFIG_TRUEHD_DECODER */