1/* 2 * MLP decoder 3 * Copyright (c) 2007-2008 Ian Caulfield 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * FFmpeg is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22/** 23 * @file 24 * MLP decoder 25 */ 26 27#include "config_components.h" 28 29#include <stdint.h> 30 31#include "avcodec.h" 32#include "libavutil/internal.h" 33#include "libavutil/intreadwrite.h" 34#include "libavutil/channel_layout.h" 35#include "libavutil/mem_internal.h" 36#include "libavutil/thread.h" 37#include "libavutil/opt.h" 38#include "codec_internal.h" 39#include "get_bits.h" 40#include "internal.h" 41#include "libavutil/crc.h" 42#include "parser.h" 43#include "mlp_parse.h" 44#include "mlpdsp.h" 45#include "mlp.h" 46#include "config.h" 47 48/** number of bits used for VLC lookup - longest Huffman code is 9 */ 49#if ARCH_ARM 50#define VLC_BITS 5 51#define VLC_STATIC_SIZE 64 52#else 53#define VLC_BITS 9 54#define VLC_STATIC_SIZE 512 55#endif 56 57typedef struct SubStream { 58 /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded. 59 uint8_t restart_seen; 60 /// Set if end of stream is encountered 61 uint8_t end_of_stream; 62 63 //@{ 64 /** restart header data */ 65 /// The type of noise to be used in the rematrix stage. 66 uint16_t noise_type; 67 68 /// The index of the first channel coded in this substream. 69 uint8_t min_channel; 70 /// The index of the last channel coded in this substream. 71 uint8_t max_channel; 72 /// The number of channels input into the rematrix stage. 73 uint8_t max_matrix_channel; 74 /// For each channel output by the matrix, the output channel to map it to 75 uint8_t ch_assign[MAX_CHANNELS]; 76 /// The channel layout for this substream 77 uint64_t mask; 78 /// The matrix encoding mode for this substream 79 enum AVMatrixEncoding matrix_encoding; 80 enum AVMatrixEncoding prev_matrix_encoding; 81 82 /// Channel coding parameters for channels in the substream 83 ChannelParams channel_params[MAX_CHANNELS]; 84 85 /// The left shift applied to random noise in 0x31ea substreams. 86 uint8_t noise_shift; 87 /// The current seed value for the pseudorandom noise generator(s). 88 uint32_t noisegen_seed; 89 90 /// Set if the substream contains extra info to check the size of VLC blocks. 91 uint8_t data_check_present; 92 93 /// Bitmask of which parameter sets are conveyed in a decoding parameter block. 94 uint8_t param_presence_flags; 95#define PARAM_BLOCKSIZE (1 << 7) 96#define PARAM_MATRIX (1 << 6) 97#define PARAM_OUTSHIFT (1 << 5) 98#define PARAM_QUANTSTEP (1 << 4) 99#define PARAM_FIR (1 << 3) 100#define PARAM_IIR (1 << 2) 101#define PARAM_HUFFOFFSET (1 << 1) 102#define PARAM_PRESENCE (1 << 0) 103 //@} 104 105 //@{ 106 /** matrix data */ 107 108 /// Number of matrices to be applied. 109 uint8_t num_primitive_matrices; 110 111 /// matrix output channel 112 uint8_t matrix_out_ch[MAX_MATRICES]; 113 114 /// Whether the LSBs of the matrix output are encoded in the bitstream. 115 uint8_t lsb_bypass[MAX_MATRICES]; 116 /// Matrix coefficients, stored as 2.14 fixed point. 117 DECLARE_ALIGNED(32, int32_t, matrix_coeff)[MAX_MATRICES][MAX_CHANNELS]; 118 /// Left shift to apply to noise values in 0x31eb substreams. 119 uint8_t matrix_noise_shift[MAX_MATRICES]; 120 //@} 121 122 /// Left shift to apply to Huffman-decoded residuals. 123 uint8_t quant_step_size[MAX_CHANNELS]; 124 125 /// number of PCM samples in current audio block 126 uint16_t blocksize; 127 /// Number of PCM samples decoded so far in this frame. 128 uint16_t blockpos; 129 130 /// Left shift to apply to decoded PCM values to get final 24-bit output. 131 int8_t output_shift[MAX_CHANNELS]; 132 133 /// Running XOR of all output samples. 134 int32_t lossless_check_data; 135 136} SubStream; 137 138typedef struct MLPDecodeContext { 139 const AVClass *class; 140 AVCodecContext *avctx; 141 142 AVChannelLayout downmix_layout; 143 144 /// Current access unit being read has a major sync. 145 int is_major_sync_unit; 146 147 /// Size of the major sync unit, in bytes 148 int major_sync_header_size; 149 150 /// Set if a valid major sync block has been read. Otherwise no decoding is possible. 151 uint8_t params_valid; 152 153 /// Number of substreams contained within this stream. 154 uint8_t num_substreams; 155 156 /// Index of the last substream to decode - further substreams are skipped. 157 uint8_t max_decoded_substream; 158 159 /// Stream needs channel reordering to comply with FFmpeg's channel order 160 uint8_t needs_reordering; 161 162 /// number of PCM samples contained in each frame 163 int access_unit_size; 164 /// next power of two above the number of samples in each frame 165 int access_unit_size_pow2; 166 167 SubStream substream[MAX_SUBSTREAMS]; 168 169 int matrix_changed; 170 int filter_changed[MAX_CHANNELS][NUM_FILTERS]; 171 172 int8_t noise_buffer[MAX_BLOCKSIZE_POW2]; 173 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS]; 174 DECLARE_ALIGNED(32, int32_t, sample_buffer)[MAX_BLOCKSIZE][MAX_CHANNELS]; 175 176 MLPDSPContext dsp; 177} MLPDecodeContext; 178 179static const enum AVChannel thd_channel_order[] = { 180 AV_CHAN_FRONT_LEFT, AV_CHAN_FRONT_RIGHT, // LR 181 AV_CHAN_FRONT_CENTER, // C 182 AV_CHAN_LOW_FREQUENCY, // LFE 183 AV_CHAN_SIDE_LEFT, AV_CHAN_SIDE_RIGHT, // LRs 184 AV_CHAN_TOP_FRONT_LEFT, AV_CHAN_TOP_FRONT_RIGHT, // LRvh 185 AV_CHAN_FRONT_LEFT_OF_CENTER, AV_CHAN_FRONT_RIGHT_OF_CENTER, // LRc 186 AV_CHAN_BACK_LEFT, AV_CHAN_BACK_RIGHT, // LRrs 187 AV_CHAN_BACK_CENTER, // Cs 188 AV_CHAN_TOP_CENTER, // Ts 189 AV_CHAN_SURROUND_DIRECT_LEFT, AV_CHAN_SURROUND_DIRECT_RIGHT, // LRsd 190 AV_CHAN_WIDE_LEFT, AV_CHAN_WIDE_RIGHT, // LRw 191 AV_CHAN_TOP_FRONT_CENTER, // Cvh 192 AV_CHAN_LOW_FREQUENCY_2, // LFE2 193}; 194 195static int mlp_channel_layout_subset(AVChannelLayout *layout, uint64_t mask) 196{ 197 return av_channel_layout_check(layout) && 198 av_channel_layout_subset(layout, mask) == 199 av_channel_layout_subset(layout, UINT64_MAX); 200} 201 202static enum AVChannel thd_channel_layout_extract_channel(uint64_t channel_layout, 203 int index) 204{ 205 int i; 206 207 if (av_popcount64(channel_layout) <= index) 208 return AV_CHAN_NONE; 209 210 for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++) 211 if (channel_layout & (1ULL << thd_channel_order[i]) && !index--) 212 return thd_channel_order[i]; 213 return AV_CHAN_NONE; 214} 215 216static VLC huff_vlc[3]; 217 218/** Initialize static data, constant between all invocations of the codec. */ 219 220static av_cold void init_static(void) 221{ 222 for (int i = 0; i < 3; i++) { 223 static VLCElem vlc_buf[3 * VLC_STATIC_SIZE]; 224 huff_vlc[i].table = &vlc_buf[i * VLC_STATIC_SIZE]; 225 huff_vlc[i].table_allocated = VLC_STATIC_SIZE; 226 init_vlc(&huff_vlc[i], VLC_BITS, 18, 227 &ff_mlp_huffman_tables[i][0][1], 2, 1, 228 &ff_mlp_huffman_tables[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC); 229 } 230 231 ff_mlp_init_crc(); 232} 233 234static inline int32_t calculate_sign_huff(MLPDecodeContext *m, 235 unsigned int substr, unsigned int ch) 236{ 237 SubStream *s = &m->substream[substr]; 238 ChannelParams *cp = &s->channel_params[ch]; 239 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch]; 240 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1); 241 int32_t sign_huff_offset = cp->huff_offset; 242 243 if (cp->codebook > 0) 244 sign_huff_offset -= 7 << lsb_bits; 245 246 if (sign_shift >= 0) 247 sign_huff_offset -= 1 << sign_shift; 248 249 return sign_huff_offset; 250} 251 252/** Read a sample, consisting of either, both or neither of entropy-coded MSBs 253 * and plain LSBs. */ 254 255static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp, 256 unsigned int substr, unsigned int pos) 257{ 258 SubStream *s = &m->substream[substr]; 259 unsigned int mat, channel; 260 261 for (mat = 0; mat < s->num_primitive_matrices; mat++) 262 if (s->lsb_bypass[mat]) 263 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp); 264 265 for (channel = s->min_channel; channel <= s->max_channel; channel++) { 266 ChannelParams *cp = &s->channel_params[channel]; 267 int codebook = cp->codebook; 268 int quant_step_size = s->quant_step_size[channel]; 269 int lsb_bits = cp->huff_lsbs - quant_step_size; 270 int result = 0; 271 272 if (codebook > 0) 273 result = get_vlc2(gbp, huff_vlc[codebook-1].table, 274 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS); 275 276 if (result < 0) 277 return AVERROR_INVALIDDATA; 278 279 if (lsb_bits > 0) 280 result = (result << lsb_bits) + get_bits_long(gbp, lsb_bits); 281 282 result += cp->sign_huff_offset; 283 result *= 1 << quant_step_size; 284 285 m->sample_buffer[pos + s->blockpos][channel] = result; 286 } 287 288 return 0; 289} 290 291static av_cold int mlp_decode_init(AVCodecContext *avctx) 292{ 293 static AVOnce init_static_once = AV_ONCE_INIT; 294 MLPDecodeContext *m = avctx->priv_data; 295 int substr; 296 297 m->avctx = avctx; 298 for (substr = 0; substr < MAX_SUBSTREAMS; substr++) 299 m->substream[substr].lossless_check_data = 0xffffffff; 300 ff_mlpdsp_init(&m->dsp); 301 302#if FF_API_OLD_CHANNEL_LAYOUT 303FF_DISABLE_DEPRECATION_WARNINGS 304 if (avctx->request_channel_layout) { 305 av_channel_layout_uninit(&m->downmix_layout); 306 av_channel_layout_from_mask(&m->downmix_layout, avctx->request_channel_layout); 307 } 308FF_ENABLE_DEPRECATION_WARNINGS 309#endif 310 ff_thread_once(&init_static_once, init_static); 311 312 return 0; 313} 314 315/** Read a major sync info header - contains high level information about 316 * the stream - sample rate, channel arrangement etc. Most of this 317 * information is not actually necessary for decoding, only for playback. 318 */ 319 320static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb) 321{ 322 MLPHeaderInfo mh; 323 int substr, ret; 324 325 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0) 326 return ret; 327 328 if (mh.group1_bits == 0) { 329 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n"); 330 return AVERROR_INVALIDDATA; 331 } 332 if (mh.group2_bits > mh.group1_bits) { 333 av_log(m->avctx, AV_LOG_ERROR, 334 "Channel group 2 cannot have more bits per sample than group 1.\n"); 335 return AVERROR_INVALIDDATA; 336 } 337 338 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) { 339 av_log(m->avctx, AV_LOG_ERROR, 340 "Channel groups with differing sample rates are not currently supported.\n"); 341 return AVERROR_INVALIDDATA; 342 } 343 344 if (mh.group1_samplerate == 0) { 345 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n"); 346 return AVERROR_INVALIDDATA; 347 } 348 if (mh.group1_samplerate > MAX_SAMPLERATE) { 349 av_log(m->avctx, AV_LOG_ERROR, 350 "Sampling rate %d is greater than the supported maximum (%d).\n", 351 mh.group1_samplerate, MAX_SAMPLERATE); 352 return AVERROR_INVALIDDATA; 353 } 354 if (mh.access_unit_size > MAX_BLOCKSIZE) { 355 av_log(m->avctx, AV_LOG_ERROR, 356 "Block size %d is greater than the supported maximum (%d).\n", 357 mh.access_unit_size, MAX_BLOCKSIZE); 358 return AVERROR_INVALIDDATA; 359 } 360 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) { 361 av_log(m->avctx, AV_LOG_ERROR, 362 "Block size pow2 %d is greater than the supported maximum (%d).\n", 363 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2); 364 return AVERROR_INVALIDDATA; 365 } 366 367 if (mh.num_substreams == 0) 368 return AVERROR_INVALIDDATA; 369 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) { 370 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n"); 371 return AVERROR_INVALIDDATA; 372 } 373 if (mh.num_substreams > MAX_SUBSTREAMS) { 374 avpriv_request_sample(m->avctx, 375 "%d substreams (more than the " 376 "maximum supported by the decoder)", 377 mh.num_substreams); 378 return AVERROR_PATCHWELCOME; 379 } 380 381 m->major_sync_header_size = mh.header_size; 382 383 m->access_unit_size = mh.access_unit_size; 384 m->access_unit_size_pow2 = mh.access_unit_size_pow2; 385 386 m->num_substreams = mh.num_substreams; 387 388 /* limit to decoding 3 substreams, as the 4th is used by Dolby Atmos for non-audio data */ 389 m->max_decoded_substream = FFMIN(m->num_substreams - 1, 2); 390 391 m->avctx->sample_rate = mh.group1_samplerate; 392 m->avctx->frame_size = mh.access_unit_size; 393 394 m->avctx->bits_per_raw_sample = mh.group1_bits; 395 if (mh.group1_bits > 16) 396 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32; 397 else 398 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16; 399 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(m->substream[m->max_decoded_substream].ch_assign, 400 m->substream[m->max_decoded_substream].output_shift, 401 m->substream[m->max_decoded_substream].max_matrix_channel, 402 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32); 403 404 m->params_valid = 1; 405 for (substr = 0; substr < MAX_SUBSTREAMS; substr++) 406 m->substream[substr].restart_seen = 0; 407 408 /* Set the layout for each substream. When there's more than one, the first 409 * substream is Stereo. Subsequent substreams' layouts are indicated in the 410 * major sync. */ 411 if (m->avctx->codec_id == AV_CODEC_ID_MLP) { 412 if (mh.stream_type != SYNC_MLP) { 413 avpriv_request_sample(m->avctx, 414 "unexpected stream_type %X in MLP", 415 mh.stream_type); 416 return AVERROR_PATCHWELCOME; 417 } 418 if ((substr = (mh.num_substreams > 1))) 419 m->substream[0].mask = AV_CH_LAYOUT_STEREO; 420 m->substream[substr].mask = mh.channel_layout_mlp; 421 } else { 422 if (mh.stream_type != SYNC_TRUEHD) { 423 avpriv_request_sample(m->avctx, 424 "unexpected stream_type %X in !MLP", 425 mh.stream_type); 426 return AVERROR_PATCHWELCOME; 427 } 428 if (mh.channels_thd_stream1 == 2 && 429 mh.channels_thd_stream2 == 2 && 430 m->avctx->ch_layout.nb_channels == 2) 431 m->substream[0].mask = AV_CH_LAYOUT_STEREO; 432 if ((substr = (mh.num_substreams > 1))) 433 m->substream[0].mask = AV_CH_LAYOUT_STEREO; 434 if (mh.num_substreams > 2) 435 if (mh.channel_layout_thd_stream2) 436 m->substream[2].mask = mh.channel_layout_thd_stream2; 437 else 438 m->substream[2].mask = mh.channel_layout_thd_stream1; 439 if (m->avctx->ch_layout.nb_channels > 2) 440 m->substream[mh.num_substreams > 1].mask = mh.channel_layout_thd_stream1; 441 442 if (m->avctx->ch_layout.nb_channels <= 2 && 443 m->substream[substr].mask == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) { 444 av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n"); 445 m->max_decoded_substream = 0; 446 if (m->avctx->ch_layout.nb_channels == 2) { 447 av_channel_layout_uninit(&m->avctx->ch_layout); 448 m->avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO; 449 } 450 } 451 } 452 453 m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20; 454 455 /* Parse the TrueHD decoder channel modifiers and set each substream's 456 * AVMatrixEncoding accordingly. 457 * 458 * The meaning of the modifiers depends on the channel layout: 459 * 460 * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel 461 * 462 * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono) 463 * 464 * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to 465 * layouts with an Ls/Rs channel pair 466 */ 467 for (substr = 0; substr < MAX_SUBSTREAMS; substr++) 468 m->substream[substr].matrix_encoding = AV_MATRIX_ENCODING_NONE; 469 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) { 470 if (mh.num_substreams > 2 && 471 mh.channel_layout_thd_stream2 & AV_CH_SIDE_LEFT && 472 mh.channel_layout_thd_stream2 & AV_CH_SIDE_RIGHT && 473 mh.channel_modifier_thd_stream2 == THD_CH_MODIFIER_SURROUNDEX) 474 m->substream[2].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX; 475 476 if (mh.num_substreams > 1 && 477 mh.channel_layout_thd_stream1 & AV_CH_SIDE_LEFT && 478 mh.channel_layout_thd_stream1 & AV_CH_SIDE_RIGHT && 479 mh.channel_modifier_thd_stream1 == THD_CH_MODIFIER_SURROUNDEX) 480 m->substream[1].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX; 481 482 if (mh.num_substreams > 0) 483 switch (mh.channel_modifier_thd_stream0) { 484 case THD_CH_MODIFIER_LTRT: 485 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBY; 486 break; 487 case THD_CH_MODIFIER_LBINRBIN: 488 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE; 489 break; 490 default: 491 break; 492 } 493 } 494 495 return 0; 496} 497 498/** Read a restart header from a block in a substream. This contains parameters 499 * required to decode the audio that do not change very often. Generally 500 * (always) present only in blocks following a major sync. */ 501 502static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp, 503 const uint8_t *buf, unsigned int substr) 504{ 505 SubStream *s = &m->substream[substr]; 506 unsigned int ch; 507 int sync_word, tmp; 508 uint8_t checksum; 509 uint8_t lossless_check; 510 int start_count = get_bits_count(gbp); 511 int min_channel, max_channel, max_matrix_channel, noise_type; 512 const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP 513 ? MAX_MATRIX_CHANNEL_MLP 514 : MAX_MATRIX_CHANNEL_TRUEHD; 515 516 sync_word = get_bits(gbp, 13); 517 518 if (sync_word != 0x31ea >> 1) { 519 av_log(m->avctx, AV_LOG_ERROR, 520 "restart header sync incorrect (got 0x%04x)\n", sync_word); 521 return AVERROR_INVALIDDATA; 522 } 523 524 noise_type = get_bits1(gbp); 525 526 if (m->avctx->codec_id == AV_CODEC_ID_MLP && noise_type) { 527 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n"); 528 return AVERROR_INVALIDDATA; 529 } 530 531 skip_bits(gbp, 16); /* Output timestamp */ 532 533 min_channel = get_bits(gbp, 4); 534 max_channel = get_bits(gbp, 4); 535 max_matrix_channel = get_bits(gbp, 4); 536 537 if (max_matrix_channel > std_max_matrix_channel) { 538 av_log(m->avctx, AV_LOG_ERROR, 539 "Max matrix channel cannot be greater than %d.\n", 540 std_max_matrix_channel); 541 return AVERROR_INVALIDDATA; 542 } 543 544 if (max_channel != max_matrix_channel) { 545 av_log(m->avctx, AV_LOG_ERROR, 546 "Max channel must be equal max matrix channel.\n"); 547 return AVERROR_INVALIDDATA; 548 } 549 550 /* This should happen for TrueHD streams with >6 channels and MLP's noise 551 * type. It is not yet known if this is allowed. */ 552 if (max_matrix_channel > MAX_MATRIX_CHANNEL_MLP && !noise_type) { 553 avpriv_request_sample(m->avctx, 554 "%d channels (more than the " 555 "maximum supported by the decoder)", 556 max_channel + 2); 557 return AVERROR_PATCHWELCOME; 558 } 559 560 if (min_channel > max_channel) { 561 av_log(m->avctx, AV_LOG_ERROR, 562 "Substream min channel cannot be greater than max channel.\n"); 563 return AVERROR_INVALIDDATA; 564 } 565 566 s->min_channel = min_channel; 567 s->max_channel = max_channel; 568 s->max_matrix_channel = max_matrix_channel; 569 s->noise_type = noise_type; 570 571 if (mlp_channel_layout_subset(&m->downmix_layout, s->mask) && 572 m->max_decoded_substream > substr) { 573 av_log(m->avctx, AV_LOG_DEBUG, 574 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. " 575 "Further substreams will be skipped.\n", 576 s->max_channel + 1, s->mask, substr); 577 m->max_decoded_substream = substr; 578 } 579 580 s->noise_shift = get_bits(gbp, 4); 581 s->noisegen_seed = get_bits(gbp, 23); 582 583 skip_bits(gbp, 19); 584 585 s->data_check_present = get_bits1(gbp); 586 lossless_check = get_bits(gbp, 8); 587 if (substr == m->max_decoded_substream 588 && s->lossless_check_data != 0xffffffff) { 589 tmp = xor_32_to_8(s->lossless_check_data); 590 if (tmp != lossless_check) 591 av_log(m->avctx, AV_LOG_WARNING, 592 "Lossless check failed - expected %02x, calculated %02x.\n", 593 lossless_check, tmp); 594 } 595 596 skip_bits(gbp, 16); 597 598 memset(s->ch_assign, 0, sizeof(s->ch_assign)); 599 600 for (ch = 0; ch <= s->max_matrix_channel; ch++) { 601 int ch_assign = get_bits(gbp, 6); 602 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) { 603 AVChannelLayout l; 604 enum AVChannel channel = thd_channel_layout_extract_channel(s->mask, ch_assign); 605 606 av_channel_layout_from_mask(&l, s->mask); 607 ch_assign = av_channel_layout_index_from_channel(&l, channel); 608 } 609 if (ch_assign < 0 || ch_assign > s->max_matrix_channel) { 610 avpriv_request_sample(m->avctx, 611 "Assignment of matrix channel %d to invalid output channel %d", 612 ch, ch_assign); 613 return AVERROR_PATCHWELCOME; 614 } 615 s->ch_assign[ch_assign] = ch; 616 } 617 618 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count); 619 620 if (checksum != get_bits(gbp, 8)) 621 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n"); 622 623 /* Set default decoding parameters. */ 624 s->param_presence_flags = 0xff; 625 s->num_primitive_matrices = 0; 626 s->blocksize = 8; 627 s->lossless_check_data = 0; 628 629 memset(s->output_shift , 0, sizeof(s->output_shift )); 630 memset(s->quant_step_size, 0, sizeof(s->quant_step_size)); 631 632 for (ch = s->min_channel; ch <= s->max_channel; ch++) { 633 ChannelParams *cp = &s->channel_params[ch]; 634 cp->filter_params[FIR].order = 0; 635 cp->filter_params[IIR].order = 0; 636 cp->filter_params[FIR].shift = 0; 637 cp->filter_params[IIR].shift = 0; 638 639 /* Default audio coding is 24-bit raw PCM. */ 640 cp->huff_offset = 0; 641 cp->sign_huff_offset = -(1 << 23); 642 cp->codebook = 0; 643 cp->huff_lsbs = 24; 644 } 645 646 if (substr == m->max_decoded_substream) { 647 av_channel_layout_uninit(&m->avctx->ch_layout); 648 av_channel_layout_from_mask(&m->avctx->ch_layout, s->mask); 649 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign, 650 s->output_shift, 651 s->max_matrix_channel, 652 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32); 653 654 if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) { 655 if (s->mask == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) || 656 s->mask == AV_CH_LAYOUT_5POINT0_BACK) { 657 int i = s->ch_assign[4]; 658 s->ch_assign[4] = s->ch_assign[3]; 659 s->ch_assign[3] = s->ch_assign[2]; 660 s->ch_assign[2] = i; 661 } else if (s->mask == AV_CH_LAYOUT_5POINT1_BACK) { 662 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]); 663 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]); 664 } 665 } 666 667 } 668 669 return 0; 670} 671 672/** Read parameters for one of the prediction filters. */ 673 674static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp, 675 unsigned int substr, unsigned int channel, 676 unsigned int filter) 677{ 678 SubStream *s = &m->substream[substr]; 679 FilterParams *fp = &s->channel_params[channel].filter_params[filter]; 680 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER; 681 const char fchar = filter ? 'I' : 'F'; 682 int i, order; 683 684 // Filter is 0 for FIR, 1 for IIR. 685 av_assert0(filter < 2); 686 687 if (m->filter_changed[channel][filter]++ > 1) { 688 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n"); 689 return AVERROR_INVALIDDATA; 690 } 691 692 order = get_bits(gbp, 4); 693 if (order > max_order) { 694 av_log(m->avctx, AV_LOG_ERROR, 695 "%cIR filter order %d is greater than maximum %d.\n", 696 fchar, order, max_order); 697 return AVERROR_INVALIDDATA; 698 } 699 fp->order = order; 700 701 if (order > 0) { 702 int32_t *fcoeff = s->channel_params[channel].coeff[filter]; 703 int coeff_bits, coeff_shift; 704 705 fp->shift = get_bits(gbp, 4); 706 707 coeff_bits = get_bits(gbp, 5); 708 coeff_shift = get_bits(gbp, 3); 709 if (coeff_bits < 1 || coeff_bits > 16) { 710 av_log(m->avctx, AV_LOG_ERROR, 711 "%cIR filter coeff_bits must be between 1 and 16.\n", 712 fchar); 713 return AVERROR_INVALIDDATA; 714 } 715 if (coeff_bits + coeff_shift > 16) { 716 av_log(m->avctx, AV_LOG_ERROR, 717 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n", 718 fchar); 719 return AVERROR_INVALIDDATA; 720 } 721 722 for (i = 0; i < order; i++) 723 fcoeff[i] = get_sbits(gbp, coeff_bits) * (1 << coeff_shift); 724 725 if (get_bits1(gbp)) { 726 int state_bits, state_shift; 727 728 if (filter == FIR) { 729 av_log(m->avctx, AV_LOG_ERROR, 730 "FIR filter has state data specified.\n"); 731 return AVERROR_INVALIDDATA; 732 } 733 734 state_bits = get_bits(gbp, 4); 735 state_shift = get_bits(gbp, 4); 736 737 /* TODO: Check validity of state data. */ 738 739 for (i = 0; i < order; i++) 740 fp->state[i] = state_bits ? get_sbits(gbp, state_bits) * (1 << state_shift) : 0; 741 } 742 } 743 744 return 0; 745} 746 747/** Read parameters for primitive matrices. */ 748 749static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp) 750{ 751 SubStream *s = &m->substream[substr]; 752 unsigned int mat, ch; 753 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP 754 ? MAX_MATRICES_MLP 755 : MAX_MATRICES_TRUEHD; 756 757 if (m->matrix_changed++ > 1) { 758 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n"); 759 return AVERROR_INVALIDDATA; 760 } 761 762 s->num_primitive_matrices = get_bits(gbp, 4); 763 764 if (s->num_primitive_matrices > max_primitive_matrices) { 765 av_log(m->avctx, AV_LOG_ERROR, 766 "Number of primitive matrices cannot be greater than %d.\n", 767 max_primitive_matrices); 768 goto error; 769 } 770 771 for (mat = 0; mat < s->num_primitive_matrices; mat++) { 772 int frac_bits, max_chan; 773 s->matrix_out_ch[mat] = get_bits(gbp, 4); 774 frac_bits = get_bits(gbp, 4); 775 s->lsb_bypass [mat] = get_bits1(gbp); 776 777 if (s->matrix_out_ch[mat] > s->max_matrix_channel) { 778 av_log(m->avctx, AV_LOG_ERROR, 779 "Invalid channel %d specified as output from matrix.\n", 780 s->matrix_out_ch[mat]); 781 goto error; 782 } 783 if (frac_bits > 14) { 784 av_log(m->avctx, AV_LOG_ERROR, 785 "Too many fractional bits specified.\n"); 786 goto error; 787 } 788 789 max_chan = s->max_matrix_channel; 790 if (!s->noise_type) 791 max_chan+=2; 792 793 for (ch = 0; ch <= max_chan; ch++) { 794 int coeff_val = 0; 795 if (get_bits1(gbp)) 796 coeff_val = get_sbits(gbp, frac_bits + 2); 797 798 s->matrix_coeff[mat][ch] = coeff_val * (1 << (14 - frac_bits)); 799 } 800 801 if (s->noise_type) 802 s->matrix_noise_shift[mat] = get_bits(gbp, 4); 803 else 804 s->matrix_noise_shift[mat] = 0; 805 } 806 807 return 0; 808error: 809 s->num_primitive_matrices = 0; 810 memset(s->matrix_out_ch, 0, sizeof(s->matrix_out_ch)); 811 812 return AVERROR_INVALIDDATA; 813} 814 815/** Read channel parameters. */ 816 817static int read_channel_params(MLPDecodeContext *m, unsigned int substr, 818 GetBitContext *gbp, unsigned int ch) 819{ 820 SubStream *s = &m->substream[substr]; 821 ChannelParams *cp = &s->channel_params[ch]; 822 FilterParams *fir = &cp->filter_params[FIR]; 823 FilterParams *iir = &cp->filter_params[IIR]; 824 int ret; 825 826 if (s->param_presence_flags & PARAM_FIR) 827 if (get_bits1(gbp)) 828 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0) 829 return ret; 830 831 if (s->param_presence_flags & PARAM_IIR) 832 if (get_bits1(gbp)) 833 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0) 834 return ret; 835 836 if (fir->order + iir->order > 8) { 837 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n"); 838 return AVERROR_INVALIDDATA; 839 } 840 841 if (fir->order && iir->order && 842 fir->shift != iir->shift) { 843 av_log(m->avctx, AV_LOG_ERROR, 844 "FIR and IIR filters must use the same precision.\n"); 845 return AVERROR_INVALIDDATA; 846 } 847 /* The FIR and IIR filters must have the same precision. 848 * To simplify the filtering code, only the precision of the 849 * FIR filter is considered. If only the IIR filter is employed, 850 * the FIR filter precision is set to that of the IIR filter, so 851 * that the filtering code can use it. */ 852 if (!fir->order && iir->order) 853 fir->shift = iir->shift; 854 855 if (s->param_presence_flags & PARAM_HUFFOFFSET) 856 if (get_bits1(gbp)) 857 cp->huff_offset = get_sbits(gbp, 15); 858 859 cp->codebook = get_bits(gbp, 2); 860 cp->huff_lsbs = get_bits(gbp, 5); 861 862 if (cp->codebook > 0 && cp->huff_lsbs > 24) { 863 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n"); 864 cp->huff_lsbs = 0; 865 return AVERROR_INVALIDDATA; 866 } 867 868 return 0; 869} 870 871/** Read decoding parameters that change more often than those in the restart 872 * header. */ 873 874static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp, 875 unsigned int substr) 876{ 877 SubStream *s = &m->substream[substr]; 878 unsigned int ch; 879 int ret = 0; 880 unsigned recompute_sho = 0; 881 882 if (s->param_presence_flags & PARAM_PRESENCE) 883 if (get_bits1(gbp)) 884 s->param_presence_flags = get_bits(gbp, 8); 885 886 if (s->param_presence_flags & PARAM_BLOCKSIZE) 887 if (get_bits1(gbp)) { 888 s->blocksize = get_bits(gbp, 9); 889 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) { 890 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n"); 891 s->blocksize = 0; 892 return AVERROR_INVALIDDATA; 893 } 894 } 895 896 if (s->param_presence_flags & PARAM_MATRIX) 897 if (get_bits1(gbp)) 898 if ((ret = read_matrix_params(m, substr, gbp)) < 0) 899 return ret; 900 901 if (s->param_presence_flags & PARAM_OUTSHIFT) 902 if (get_bits1(gbp)) { 903 for (ch = 0; ch <= s->max_matrix_channel; ch++) { 904 s->output_shift[ch] = get_sbits(gbp, 4); 905 if (s->output_shift[ch] < 0) { 906 avpriv_request_sample(m->avctx, "Negative output_shift"); 907 s->output_shift[ch] = 0; 908 } 909 } 910 if (substr == m->max_decoded_substream) 911 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign, 912 s->output_shift, 913 s->max_matrix_channel, 914 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32); 915 } 916 917 if (s->param_presence_flags & PARAM_QUANTSTEP) 918 if (get_bits1(gbp)) 919 for (ch = 0; ch <= s->max_channel; ch++) { 920 s->quant_step_size[ch] = get_bits(gbp, 4); 921 922 recompute_sho |= 1<<ch; 923 } 924 925 for (ch = s->min_channel; ch <= s->max_channel; ch++) 926 if (get_bits1(gbp)) { 927 recompute_sho |= 1<<ch; 928 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0) 929 goto fail; 930 } 931 932 933fail: 934 for (ch = 0; ch <= s->max_channel; ch++) { 935 if (recompute_sho & (1<<ch)) { 936 ChannelParams *cp = &s->channel_params[ch]; 937 938 if (cp->codebook > 0 && cp->huff_lsbs < s->quant_step_size[ch]) { 939 if (ret >= 0) { 940 av_log(m->avctx, AV_LOG_ERROR, "quant_step_size larger than huff_lsbs\n"); 941 ret = AVERROR_INVALIDDATA; 942 } 943 s->quant_step_size[ch] = 0; 944 } 945 946 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch); 947 } 948 } 949 return ret; 950} 951 952#define MSB_MASK(bits) (-(1 << (bits))) 953 954/** Generate PCM samples using the prediction filters and residual values 955 * read from the data stream, and update the filter state. */ 956 957static void filter_channel(MLPDecodeContext *m, unsigned int substr, 958 unsigned int channel) 959{ 960 SubStream *s = &m->substream[substr]; 961 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR]; 962 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER]; 963 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE; 964 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE; 965 FilterParams *fir = &s->channel_params[channel].filter_params[FIR]; 966 FilterParams *iir = &s->channel_params[channel].filter_params[IIR]; 967 unsigned int filter_shift = fir->shift; 968 int32_t mask = MSB_MASK(s->quant_step_size[channel]); 969 970 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t)); 971 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t)); 972 973 m->dsp.mlp_filter_channel(firbuf, fircoeff, 974 fir->order, iir->order, 975 filter_shift, mask, s->blocksize, 976 &m->sample_buffer[s->blockpos][channel]); 977 978 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t)); 979 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t)); 980} 981 982/** Read a block of PCM residual data (or actual if no filtering active). */ 983 984static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp, 985 unsigned int substr) 986{ 987 SubStream *s = &m->substream[substr]; 988 unsigned int i, ch, expected_stream_pos = 0; 989 int ret; 990 991 if (s->data_check_present) { 992 expected_stream_pos = get_bits_count(gbp); 993 expected_stream_pos += get_bits(gbp, 16); 994 avpriv_request_sample(m->avctx, 995 "Substreams with VLC block size check info"); 996 } 997 998 if (s->blockpos + s->blocksize > m->access_unit_size) { 999 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n"); 1000 return AVERROR_INVALIDDATA; 1001 } 1002 1003 memset(&m->bypassed_lsbs[s->blockpos][0], 0, 1004 s->blocksize * sizeof(m->bypassed_lsbs[0])); 1005 1006 for (i = 0; i < s->blocksize; i++) 1007 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0) 1008 return ret; 1009 1010 for (ch = s->min_channel; ch <= s->max_channel; ch++) 1011 filter_channel(m, substr, ch); 1012 1013 s->blockpos += s->blocksize; 1014 1015 if (s->data_check_present) { 1016 if (get_bits_count(gbp) != expected_stream_pos) 1017 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n"); 1018 skip_bits(gbp, 8); 1019 } 1020 1021 return 0; 1022} 1023 1024/** Data table used for TrueHD noise generation function. */ 1025 1026static const int8_t noise_table[256] = { 1027 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2, 1028 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62, 1029 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5, 1030 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40, 1031 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34, 1032 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30, 1033 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36, 1034 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69, 1035 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24, 1036 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20, 1037 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23, 1038 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8, 1039 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40, 1040 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37, 1041 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52, 1042 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70, 1043}; 1044 1045/** Noise generation functions. 1046 * I'm not sure what these are for - they seem to be some kind of pseudorandom 1047 * sequence generators, used to generate noise data which is used when the 1048 * channels are rematrixed. I'm not sure if they provide a practical benefit 1049 * to compression, or just obfuscate the decoder. Are they for some kind of 1050 * dithering? */ 1051 1052/** Generate two channels of noise, used in the matrix when 1053 * restart sync word == 0x31ea. */ 1054 1055static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr) 1056{ 1057 SubStream *s = &m->substream[substr]; 1058 unsigned int i; 1059 uint32_t seed = s->noisegen_seed; 1060 unsigned int maxchan = s->max_matrix_channel; 1061 1062 for (i = 0; i < s->blockpos; i++) { 1063 uint16_t seed_shr7 = seed >> 7; 1064 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) * (1 << s->noise_shift); 1065 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) * (1 << s->noise_shift); 1066 1067 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5); 1068 } 1069 1070 s->noisegen_seed = seed; 1071} 1072 1073/** Generate a block of noise, used when restart sync word == 0x31eb. */ 1074 1075static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr) 1076{ 1077 SubStream *s = &m->substream[substr]; 1078 unsigned int i; 1079 uint32_t seed = s->noisegen_seed; 1080 1081 for (i = 0; i < m->access_unit_size_pow2; i++) { 1082 uint8_t seed_shr15 = seed >> 15; 1083 m->noise_buffer[i] = noise_table[seed_shr15]; 1084 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5); 1085 } 1086 1087 s->noisegen_seed = seed; 1088} 1089 1090/** Write the audio data into the output buffer. */ 1091 1092static int output_data(MLPDecodeContext *m, unsigned int substr, 1093 AVFrame *frame, int *got_frame_ptr) 1094{ 1095 AVCodecContext *avctx = m->avctx; 1096 SubStream *s = &m->substream[substr]; 1097 unsigned int mat; 1098 unsigned int maxchan; 1099 int ret; 1100 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32); 1101 1102 if (m->avctx->ch_layout.nb_channels != s->max_matrix_channel + 1) { 1103 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n"); 1104 return AVERROR_INVALIDDATA; 1105 } 1106 1107 if (!s->blockpos) { 1108 av_log(avctx, AV_LOG_ERROR, "No samples to output.\n"); 1109 return AVERROR_INVALIDDATA; 1110 } 1111 1112 maxchan = s->max_matrix_channel; 1113 if (!s->noise_type) { 1114 generate_2_noise_channels(m, substr); 1115 maxchan += 2; 1116 } else { 1117 fill_noise_buffer(m, substr); 1118 } 1119 1120 /* Apply the channel matrices in turn to reconstruct the original audio 1121 * samples. */ 1122 for (mat = 0; mat < s->num_primitive_matrices; mat++) { 1123 unsigned int dest_ch = s->matrix_out_ch[mat]; 1124 m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0], 1125 s->matrix_coeff[mat], 1126 &m->bypassed_lsbs[0][mat], 1127 m->noise_buffer, 1128 s->num_primitive_matrices - mat, 1129 dest_ch, 1130 s->blockpos, 1131 maxchan, 1132 s->matrix_noise_shift[mat], 1133 m->access_unit_size_pow2, 1134 MSB_MASK(s->quant_step_size[dest_ch])); 1135 } 1136 1137 /* get output buffer */ 1138 frame->nb_samples = s->blockpos; 1139 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) 1140 return ret; 1141 s->lossless_check_data = m->dsp.mlp_pack_output(s->lossless_check_data, 1142 s->blockpos, 1143 m->sample_buffer, 1144 frame->data[0], 1145 s->ch_assign, 1146 s->output_shift, 1147 s->max_matrix_channel, 1148 is32); 1149 1150 /* Update matrix encoding side data */ 1151 if (s->matrix_encoding != s->prev_matrix_encoding) { 1152 if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0) 1153 return ret; 1154 1155 s->prev_matrix_encoding = s->matrix_encoding; 1156 } 1157 1158 *got_frame_ptr = 1; 1159 1160 return 0; 1161} 1162 1163/** Read an access unit from the stream. 1164 * @return negative on error, 0 if not enough data is present in the input stream, 1165 * otherwise the number of bytes consumed. */ 1166 1167static int read_access_unit(AVCodecContext *avctx, AVFrame *frame, 1168 int *got_frame_ptr, AVPacket *avpkt) 1169{ 1170 const uint8_t *buf = avpkt->data; 1171 int buf_size = avpkt->size; 1172 MLPDecodeContext *m = avctx->priv_data; 1173 GetBitContext gb; 1174 unsigned int length, substr; 1175 unsigned int substream_start; 1176 unsigned int header_size = 4; 1177 unsigned int substr_header_size = 0; 1178 uint8_t substream_parity_present[MAX_SUBSTREAMS]; 1179 uint16_t substream_data_len[MAX_SUBSTREAMS]; 1180 uint8_t parity_bits; 1181 int ret; 1182 1183 if (buf_size < 4) 1184 return AVERROR_INVALIDDATA; 1185 1186 length = (AV_RB16(buf) & 0xfff) * 2; 1187 1188 if (length < 4 || length > buf_size) 1189 return AVERROR_INVALIDDATA; 1190 1191 init_get_bits(&gb, (buf + 4), (length - 4) * 8); 1192 1193 m->is_major_sync_unit = 0; 1194 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) { 1195 if (read_major_sync(m, &gb) < 0) 1196 goto error; 1197 m->is_major_sync_unit = 1; 1198 header_size += m->major_sync_header_size; 1199 } 1200 1201 if (!m->params_valid) { 1202 av_log(m->avctx, AV_LOG_WARNING, 1203 "Stream parameters not seen; skipping frame.\n"); 1204 *got_frame_ptr = 0; 1205 return length; 1206 } 1207 1208 substream_start = 0; 1209 1210 for (substr = 0; substr < m->num_substreams; substr++) { 1211 int extraword_present, checkdata_present, end, nonrestart_substr; 1212 1213 extraword_present = get_bits1(&gb); 1214 nonrestart_substr = get_bits1(&gb); 1215 checkdata_present = get_bits1(&gb); 1216 skip_bits1(&gb); 1217 1218 end = get_bits(&gb, 12) * 2; 1219 1220 substr_header_size += 2; 1221 1222 if (extraword_present) { 1223 if (m->avctx->codec_id == AV_CODEC_ID_MLP) { 1224 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n"); 1225 goto error; 1226 } 1227 skip_bits(&gb, 16); 1228 substr_header_size += 2; 1229 } 1230 1231 if (length < header_size + substr_header_size) { 1232 av_log(m->avctx, AV_LOG_ERROR, "Insufficient data for headers\n"); 1233 goto error; 1234 } 1235 1236 if (!(nonrestart_substr ^ m->is_major_sync_unit)) { 1237 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n"); 1238 goto error; 1239 } 1240 1241 if (end + header_size + substr_header_size > length) { 1242 av_log(m->avctx, AV_LOG_ERROR, 1243 "Indicated length of substream %d data goes off end of " 1244 "packet.\n", substr); 1245 end = length - header_size - substr_header_size; 1246 } 1247 1248 if (end < substream_start) { 1249 av_log(avctx, AV_LOG_ERROR, 1250 "Indicated end offset of substream %d data " 1251 "is smaller than calculated start offset.\n", 1252 substr); 1253 goto error; 1254 } 1255 1256 if (substr > m->max_decoded_substream) 1257 continue; 1258 1259 substream_parity_present[substr] = checkdata_present; 1260 substream_data_len[substr] = end - substream_start; 1261 substream_start = end; 1262 } 1263 1264 parity_bits = ff_mlp_calculate_parity(buf, 4); 1265 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size); 1266 1267 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) { 1268 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n"); 1269 goto error; 1270 } 1271 1272 buf += header_size + substr_header_size; 1273 1274 for (substr = 0; substr <= m->max_decoded_substream; substr++) { 1275 SubStream *s = &m->substream[substr]; 1276 1277 if (substr != m->max_decoded_substream && 1278 m->substream[m->max_decoded_substream].min_channel == 0 && 1279 m->substream[m->max_decoded_substream].max_channel == avctx->ch_layout.nb_channels - 1) 1280 goto skip_substr; 1281 1282 init_get_bits(&gb, buf, substream_data_len[substr] * 8); 1283 1284 m->matrix_changed = 0; 1285 memset(m->filter_changed, 0, sizeof(m->filter_changed)); 1286 1287 s->blockpos = 0; 1288 do { 1289 if (get_bits1(&gb)) { 1290 if (get_bits1(&gb)) { 1291 /* A restart header should be present. */ 1292 if (read_restart_header(m, &gb, buf, substr) < 0) 1293 goto next_substr; 1294 s->restart_seen = 1; 1295 } 1296 1297 if (!s->restart_seen) 1298 goto next_substr; 1299 if (read_decoding_params(m, &gb, substr) < 0) 1300 goto next_substr; 1301 } 1302 1303 if (!s->restart_seen) 1304 goto next_substr; 1305 1306 if ((ret = read_block_data(m, &gb, substr)) < 0) 1307 return ret; 1308 1309 if (get_bits_count(&gb) >= substream_data_len[substr] * 8) 1310 goto substream_length_mismatch; 1311 1312 } while (!get_bits1(&gb)); 1313 1314 skip_bits(&gb, (-get_bits_count(&gb)) & 15); 1315 1316 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) { 1317 int shorten_by; 1318 1319 if (get_bits(&gb, 16) != 0xD234) 1320 return AVERROR_INVALIDDATA; 1321 1322 shorten_by = get_bits(&gb, 16); 1323 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000) 1324 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos); 1325 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234) 1326 return AVERROR_INVALIDDATA; 1327 1328 av_log(m->avctx, AV_LOG_DEBUG, "End of stream indicated.\n"); 1329 s->end_of_stream = 1; 1330 } 1331 1332 if (substream_parity_present[substr]) { 1333 uint8_t parity, checksum; 1334 1335 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16) 1336 goto substream_length_mismatch; 1337 1338 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2); 1339 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2); 1340 1341 if ((get_bits(&gb, 8) ^ parity) != 0xa9 ) 1342 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr); 1343 if ( get_bits(&gb, 8) != checksum) 1344 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr); 1345 } 1346 1347 if (substream_data_len[substr] * 8 != get_bits_count(&gb)) 1348 goto substream_length_mismatch; 1349 1350next_substr: 1351 if (!s->restart_seen) 1352 av_log(m->avctx, AV_LOG_ERROR, 1353 "No restart header present in substream %d.\n", substr); 1354 1355skip_substr: 1356 buf += substream_data_len[substr]; 1357 } 1358 1359 if ((ret = output_data(m, m->max_decoded_substream, frame, got_frame_ptr)) < 0) 1360 return ret; 1361 1362 for (substr = 0; substr <= m->max_decoded_substream; substr++){ 1363 SubStream *s = &m->substream[substr]; 1364 1365 if (s->end_of_stream) { 1366 s->lossless_check_data = 0xffffffff; 1367 s->end_of_stream = 0; 1368 m->params_valid = 0; 1369 } 1370 } 1371 1372 return length; 1373 1374substream_length_mismatch: 1375 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr); 1376 return AVERROR_INVALIDDATA; 1377 1378error: 1379 m->params_valid = 0; 1380 return AVERROR_INVALIDDATA; 1381} 1382 1383static void mlp_decode_flush(AVCodecContext *avctx) 1384{ 1385 MLPDecodeContext *m = avctx->priv_data; 1386 1387 m->params_valid = 0; 1388 for (int substr = 0; substr <= m->max_decoded_substream; substr++){ 1389 SubStream *s = &m->substream[substr]; 1390 1391 s->lossless_check_data = 0xffffffff; 1392 s->prev_matrix_encoding = 0; 1393 } 1394} 1395 1396#define OFFSET(x) offsetof(MLPDecodeContext, x) 1397#define FLAGS (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM) 1398static const AVOption options[] = { 1399 { "downmix", "Request a specific channel layout from the decoder", OFFSET(downmix_layout), 1400 AV_OPT_TYPE_CHLAYOUT, {.str = NULL}, .flags = FLAGS }, 1401 { NULL }, 1402}; 1403 1404static const AVClass mlp_decoder_class = { 1405 .class_name = "MLP decoder", 1406 .item_name = av_default_item_name, 1407 .option = options, 1408 .version = LIBAVUTIL_VERSION_INT, 1409}; 1410 1411static const AVClass truehd_decoder_class = { 1412 .class_name = "TrueHD decoder", 1413 .item_name = av_default_item_name, 1414 .option = options, 1415 .version = LIBAVUTIL_VERSION_INT, 1416}; 1417 1418#if CONFIG_MLP_DECODER 1419const FFCodec ff_mlp_decoder = { 1420 .p.name = "mlp", 1421 .p.long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"), 1422 .p.type = AVMEDIA_TYPE_AUDIO, 1423 .p.id = AV_CODEC_ID_MLP, 1424 .priv_data_size = sizeof(MLPDecodeContext), 1425 .p.priv_class = &mlp_decoder_class, 1426 .init = mlp_decode_init, 1427 FF_CODEC_DECODE_CB(read_access_unit), 1428 .flush = mlp_decode_flush, 1429 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF, 1430 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 1431}; 1432#endif 1433#if CONFIG_TRUEHD_DECODER 1434const FFCodec ff_truehd_decoder = { 1435 .p.name = "truehd", 1436 .p.long_name = NULL_IF_CONFIG_SMALL("TrueHD"), 1437 .p.type = AVMEDIA_TYPE_AUDIO, 1438 .p.id = AV_CODEC_ID_TRUEHD, 1439 .priv_data_size = sizeof(MLPDecodeContext), 1440 .p.priv_class = &truehd_decoder_class, 1441 .init = mlp_decode_init, 1442 FF_CODEC_DECODE_CB(read_access_unit), 1443 .flush = mlp_decode_flush, 1444 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF, 1445 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 1446}; 1447#endif /* CONFIG_TRUEHD_DECODER */ 1448