git.sesse.net Git - ffmpeg/blob - libavcodec/mlpdec.c

   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 <stdint.h>
  28
  29 #include "avcodec.h"
  30 #include "dsputil.h"
  31 #include "libavutil/intreadwrite.h"
  32 #include "get_bits.h"
  33 #include "libavutil/crc.h"
  34 #include "parser.h"
  35 #include "mlp_parser.h"
  36 #include "mlp.h"
  37
  38 /** number of bits used for VLC lookup - longest Huffman code is 9 */
  39 #define VLC_BITS            9
  40
  41
  42 static const char* sample_message =
  43     "Please file a bug report following the instructions at "
  44     "http://ffmpeg.org/bugreports.html and include "
  45     "a sample of this file.";
  46
  47 typedef struct SubStream {
  48     /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
  49     uint8_t     restart_seen;
  50
  51     //@{
  52     /** restart header data */
  53     /// The type of noise to be used in the rematrix stage.
  54     uint16_t    noise_type;
  55
  56     /// The index of the first channel coded in this substream.
  57     uint8_t     min_channel;
  58     /// The index of the last channel coded in this substream.
  59     uint8_t     max_channel;
  60     /// The number of channels input into the rematrix stage.
  61     uint8_t     max_matrix_channel;
  62     /// For each channel output by the matrix, the output channel to map it to
  63     uint8_t     ch_assign[MAX_CHANNELS];
  64
  65     /// Channel coding parameters for channels in the substream
  66     ChannelParams channel_params[MAX_CHANNELS];
  67
  68     /// The left shift applied to random noise in 0x31ea substreams.
  69     uint8_t     noise_shift;
  70     /// The current seed value for the pseudorandom noise generator(s).
  71     uint32_t    noisegen_seed;
  72
  73     /// Set if the substream contains extra info to check the size of VLC blocks.
  74     uint8_t     data_check_present;
  75
  76     /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
  77     uint8_t     param_presence_flags;
  78 #define PARAM_BLOCKSIZE     (1 << 7)
  79 #define PARAM_MATRIX        (1 << 6)
  80 #define PARAM_OUTSHIFT      (1 << 5)
  81 #define PARAM_QUANTSTEP     (1 << 4)
  82 #define PARAM_FIR           (1 << 3)
  83 #define PARAM_IIR           (1 << 2)
  84 #define PARAM_HUFFOFFSET    (1 << 1)
  85 #define PARAM_PRESENCE      (1 << 0)
  86     //@}
  87
  88     //@{
  89     /** matrix data */
  90
  91     /// Number of matrices to be applied.
  92     uint8_t     num_primitive_matrices;
  93
  94     /// matrix output channel
  95     uint8_t     matrix_out_ch[MAX_MATRICES];
  96
  97     /// Whether the LSBs of the matrix output are encoded in the bitstream.
  98     uint8_t     lsb_bypass[MAX_MATRICES];
  99     /// Matrix coefficients, stored as 2.14 fixed point.
 100     int32_t     matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
 101     /// Left shift to apply to noise values in 0x31eb substreams.
 102     uint8_t     matrix_noise_shift[MAX_MATRICES];
 103     //@}
 104
 105     /// Left shift to apply to Huffman-decoded residuals.
 106     uint8_t     quant_step_size[MAX_CHANNELS];
 107
 108     /// number of PCM samples in current audio block
 109     uint16_t    blocksize;
 110     /// Number of PCM samples decoded so far in this frame.
 111     uint16_t    blockpos;
 112
 113     /// Left shift to apply to decoded PCM values to get final 24-bit output.
 114     int8_t      output_shift[MAX_CHANNELS];
 115
 116     /// Running XOR of all output samples.
 117     int32_t     lossless_check_data;
 118
 119 } SubStream;
 120
 121 typedef struct MLPDecodeContext {
 122     AVCodecContext *avctx;
 123     AVFrame     frame;
 124
 125     /// Current access unit being read has a major sync.
 126     int         is_major_sync_unit;
 127
 128     /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
 129     uint8_t     params_valid;
 130
 131     /// Number of substreams contained within this stream.
 132     uint8_t     num_substreams;
 133
 134     /// Index of the last substream to decode - further substreams are skipped.
 135     uint8_t     max_decoded_substream;
 136
 137     /// Stream needs channel reordering to comply with FFmpeg's channel order
 138     uint8_t     needs_reordering;
 139
 140     /// number of PCM samples contained in each frame
 141     int         access_unit_size;
 142     /// next power of two above the number of samples in each frame
 143     int         access_unit_size_pow2;
 144
 145     SubStream   substream[MAX_SUBSTREAMS];
 146
 147     int         matrix_changed;
 148     int         filter_changed[MAX_CHANNELS][NUM_FILTERS];
 149
 150     int8_t      noise_buffer[MAX_BLOCKSIZE_POW2];
 151     int8_t      bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
 152     int32_t     sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
 153
 154     DSPContext  dsp;
 155 } MLPDecodeContext;
 156
 157 static VLC huff_vlc[3];
 158
 159 /** Initialize static data, constant between all invocations of the codec. */
 160
 161 static av_cold void init_static(void)
 162 {
 163     if (!huff_vlc[0].bits) {
 164         INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
 165                     &ff_mlp_huffman_tables[0][0][1], 2, 1,
 166                     &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
 167         INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
 168                     &ff_mlp_huffman_tables[1][0][1], 2, 1,
 169                     &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
 170         INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
 171                     &ff_mlp_huffman_tables[2][0][1], 2, 1,
 172                     &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
 173     }
 174
 175     ff_mlp_init_crc();
 176 }
 177
 178 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
 179                                           unsigned int substr, unsigned int ch)
 180 {
 181     SubStream *s = &m->substream[substr];
 182     ChannelParams *cp = &s->channel_params[ch];
 183     int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
 184     int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
 185     int32_t sign_huff_offset = cp->huff_offset;
 186
 187     if (cp->codebook > 0)
 188         sign_huff_offset -= 7 << lsb_bits;
 189
 190     if (sign_shift >= 0)
 191         sign_huff_offset -= 1 << sign_shift;
 192
 193     return sign_huff_offset;
 194 }
 195
 196 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
 197  *  and plain LSBs. */
 198
 199 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
 200                                      unsigned int substr, unsigned int pos)
 201 {
 202     SubStream *s = &m->substream[substr];
 203     unsigned int mat, channel;
 204
 205     for (mat = 0; mat < s->num_primitive_matrices; mat++)
 206         if (s->lsb_bypass[mat])
 207             m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
 208
 209     for (channel = s->min_channel; channel <= s->max_channel; channel++) {
 210         ChannelParams *cp = &s->channel_params[channel];
 211         int codebook = cp->codebook;
 212         int quant_step_size = s->quant_step_size[channel];
 213         int lsb_bits = cp->huff_lsbs - quant_step_size;
 214         int result = 0;
 215
 216         if (codebook > 0)
 217             result = get_vlc2(gbp, huff_vlc[codebook-1].table,
 218                             VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
 219
 220         if (result < 0)
 221             return AVERROR_INVALIDDATA;
 222
 223         if (lsb_bits > 0)
 224             result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
 225
 226         result  += cp->sign_huff_offset;
 227         result <<= quant_step_size;
 228
 229         m->sample_buffer[pos + s->blockpos][channel] = result;
 230     }
 231
 232     return 0;
 233 }
 234
 235 static av_cold int mlp_decode_init(AVCodecContext *avctx)
 236 {
 237     MLPDecodeContext *m = avctx->priv_data;
 238     int substr;
 239
 240     init_static();
 241     m->avctx = avctx;
 242     for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
 243         m->substream[substr].lossless_check_data = 0xffffffff;
 244     dsputil_init(&m->dsp, avctx);
 245
 246     avcodec_get_frame_defaults(&m->frame);
 247     avctx->coded_frame = &m->frame;
 248
 249     return 0;
 250 }
 251
 252 /** Read a major sync info header - contains high level information about
 253  *  the stream - sample rate, channel arrangement etc. Most of this
 254  *  information is not actually necessary for decoding, only for playback.
 255  */
 256
 257 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
 258 {
 259     MLPHeaderInfo mh;
 260     int substr, ret;
 261
 262     if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
 263         return ret;
 264
 265     if (mh.group1_bits == 0) {
 266         av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
 267         return AVERROR_INVALIDDATA;
 268     }
 269     if (mh.group2_bits > mh.group1_bits) {
 270         av_log(m->avctx, AV_LOG_ERROR,
 271                "Channel group 2 cannot have more bits per sample than group 1.\n");
 272         return AVERROR_INVALIDDATA;
 273     }
 274
 275     if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
 276         av_log(m->avctx, AV_LOG_ERROR,
 277                "Channel groups with differing sample rates are not currently supported.\n");
 278         return AVERROR_INVALIDDATA;
 279     }
 280
 281     if (mh.group1_samplerate == 0) {
 282         av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
 283         return AVERROR_INVALIDDATA;
 284     }
 285     if (mh.group1_samplerate > MAX_SAMPLERATE) {
 286         av_log(m->avctx, AV_LOG_ERROR,
 287                "Sampling rate %d is greater than the supported maximum (%d).\n",
 288                mh.group1_samplerate, MAX_SAMPLERATE);
 289         return AVERROR_INVALIDDATA;
 290     }
 291     if (mh.access_unit_size > MAX_BLOCKSIZE) {
 292         av_log(m->avctx, AV_LOG_ERROR,
 293                "Block size %d is greater than the supported maximum (%d).\n",
 294                mh.access_unit_size, MAX_BLOCKSIZE);
 295         return AVERROR_INVALIDDATA;
 296     }
 297     if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
 298         av_log(m->avctx, AV_LOG_ERROR,
 299                "Block size pow2 %d is greater than the supported maximum (%d).\n",
 300                mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
 301         return AVERROR_INVALIDDATA;
 302     }
 303
 304     if (mh.num_substreams == 0)
 305         return AVERROR_INVALIDDATA;
 306     if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
 307         av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
 308         return AVERROR_INVALIDDATA;
 309     }
 310     if (mh.num_substreams > MAX_SUBSTREAMS) {
 311         av_log(m->avctx, AV_LOG_ERROR,
 312                "Number of substreams %d is larger than the maximum supported "
 313                "by the decoder. %s\n", mh.num_substreams, sample_message);
 314         return AVERROR_INVALIDDATA;
 315     }
 316
 317     m->access_unit_size      = mh.access_unit_size;
 318     m->access_unit_size_pow2 = mh.access_unit_size_pow2;
 319
 320     m->num_substreams        = mh.num_substreams;
 321     m->max_decoded_substream = m->num_substreams - 1;
 322
 323     m->avctx->sample_rate    = mh.group1_samplerate;
 324     m->avctx->frame_size     = mh.access_unit_size;
 325
 326     m->avctx->bits_per_raw_sample = mh.group1_bits;
 327     if (mh.group1_bits > 16)
 328         m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 329     else
 330         m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 331
 332     m->params_valid = 1;
 333     for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
 334         m->substream[substr].restart_seen = 0;
 335
 336     if (mh.stream_type == 0xbb) {
 337         /* MLP stream */
 338         m->avctx->channel_layout = ff_mlp_layout[mh.channels_mlp];
 339     } else { /* mh.stream_type == 0xba */
 340         /* TrueHD stream */
 341         if (mh.channels_thd_stream2) {
 342             m->avctx->channel_layout = ff_truehd_layout(mh.channels_thd_stream2);
 343         } else {
 344             m->avctx->channel_layout = ff_truehd_layout(mh.channels_thd_stream1);
 345         }
 346         if (m->avctx->channels &&
 347             !m->avctx->request_channels && !m->avctx->request_channel_layout &&
 348             av_get_channel_layout_nb_channels(m->avctx->channel_layout) != m->avctx->channels) {
 349             m->avctx->channel_layout = 0;
 350             av_log_ask_for_sample(m->avctx, "Unknown channel layout.");
 351         }
 352     }
 353
 354     m->needs_reordering = mh.channels_mlp >= 18 && mh.channels_mlp <= 20;
 355
 356     return 0;
 357 }
 358
 359 /** Read a restart header from a block in a substream. This contains parameters
 360  *  required to decode the audio that do not change very often. Generally
 361  *  (always) present only in blocks following a major sync. */
 362
 363 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
 364                                const uint8_t *buf, unsigned int substr)
 365 {
 366     SubStream *s = &m->substream[substr];
 367     unsigned int ch;
 368     int sync_word, tmp;
 369     uint8_t checksum;
 370     uint8_t lossless_check;
 371     int start_count = get_bits_count(gbp);
 372     const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP
 373                                  ? MAX_MATRIX_CHANNEL_MLP
 374                                  : MAX_MATRIX_CHANNEL_TRUEHD;
 375
 376     sync_word = get_bits(gbp, 13);
 377
 378     if (sync_word != 0x31ea >> 1) {
 379         av_log(m->avctx, AV_LOG_ERROR,
 380                "restart header sync incorrect (got 0x%04x)\n", sync_word);
 381         return AVERROR_INVALIDDATA;
 382     }
 383
 384     s->noise_type = get_bits1(gbp);
 385
 386     if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) {
 387         av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
 388         return AVERROR_INVALIDDATA;
 389     }
 390
 391     skip_bits(gbp, 16); /* Output timestamp */
 392
 393     s->min_channel        = get_bits(gbp, 4);
 394     s->max_channel        = get_bits(gbp, 4);
 395     s->max_matrix_channel = get_bits(gbp, 4);
 396
 397     if (s->max_matrix_channel > max_matrix_channel) {
 398         av_log(m->avctx, AV_LOG_ERROR,
 399                "Max matrix channel cannot be greater than %d.\n",
 400                max_matrix_channel);
 401         return AVERROR_INVALIDDATA;
 402     }
 403
 404     if (s->max_channel != s->max_matrix_channel) {
 405         av_log(m->avctx, AV_LOG_ERROR,
 406                "Max channel must be equal max matrix channel.\n");
 407         return AVERROR_INVALIDDATA;
 408     }
 409
 410     /* This should happen for TrueHD streams with >6 channels and MLP's noise
 411      * type. It is not yet known if this is allowed. */
 412     if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
 413         av_log(m->avctx, AV_LOG_ERROR,
 414                "Number of channels %d is larger than the maximum supported "
 415                "by the decoder. %s\n", s->max_channel+2, sample_message);
 416         return AVERROR_INVALIDDATA;
 417     }
 418
 419     if (s->min_channel > s->max_channel) {
 420         av_log(m->avctx, AV_LOG_ERROR,
 421                "Substream min channel cannot be greater than max channel.\n");
 422         return AVERROR_INVALIDDATA;
 423     }
 424
 425     if (m->avctx->request_channels > 0
 426         && s->max_channel + 1 >= m->avctx->request_channels
 427         && substr < m->max_decoded_substream) {
 428         av_log(m->avctx, AV_LOG_DEBUG,
 429                "Extracting %d channel downmix from substream %d. "
 430                "Further substreams will be skipped.\n",
 431                s->max_channel + 1, substr);
 432         m->max_decoded_substream = substr;
 433     }
 434
 435     s->noise_shift   = get_bits(gbp,  4);
 436     s->noisegen_seed = get_bits(gbp, 23);
 437
 438     skip_bits(gbp, 19);
 439
 440     s->data_check_present = get_bits1(gbp);
 441     lossless_check = get_bits(gbp, 8);
 442     if (substr == m->max_decoded_substream
 443         && s->lossless_check_data != 0xffffffff) {
 444         tmp = xor_32_to_8(s->lossless_check_data);
 445         if (tmp != lossless_check)
 446             av_log(m->avctx, AV_LOG_WARNING,
 447                    "Lossless check failed - expected %02x, calculated %02x.\n",
 448                    lossless_check, tmp);
 449     }
 450
 451     skip_bits(gbp, 16);
 452
 453     memset(s->ch_assign, 0, sizeof(s->ch_assign));
 454
 455     for (ch = 0; ch <= s->max_matrix_channel; ch++) {
 456         int ch_assign = get_bits(gbp, 6);
 457         if (ch_assign > s->max_matrix_channel) {
 458             av_log(m->avctx, AV_LOG_ERROR,
 459                    "Assignment of matrix channel %d to invalid output channel %d. %s\n",
 460                    ch, ch_assign, sample_message);
 461             return AVERROR_INVALIDDATA;
 462         }
 463         s->ch_assign[ch_assign] = ch;
 464     }
 465
 466     if (m->avctx->codec_id == CODEC_ID_MLP && m->needs_reordering) {
 467         if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
 468             m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
 469             int i = s->ch_assign[4];
 470             s->ch_assign[4] = s->ch_assign[3];
 471             s->ch_assign[3] = s->ch_assign[2];
 472             s->ch_assign[2] = i;
 473         } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
 474             FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
 475             FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
 476         }
 477     }
 478     if (m->avctx->codec_id == CODEC_ID_TRUEHD &&
 479         m->avctx->channel_layout == AV_CH_LAYOUT_7POINT1) {
 480         FFSWAP(int, s->ch_assign[4], s->ch_assign[6]);
 481         FFSWAP(int, s->ch_assign[5], s->ch_assign[7]);
 482     }
 483
 484     checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
 485
 486     if (checksum != get_bits(gbp, 8))
 487         av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
 488
 489     /* Set default decoding parameters. */
 490     s->param_presence_flags   = 0xff;
 491     s->num_primitive_matrices = 0;
 492     s->blocksize              = 8;
 493     s->lossless_check_data    = 0;
 494
 495     memset(s->output_shift   , 0, sizeof(s->output_shift   ));
 496     memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
 497
 498     for (ch = s->min_channel; ch <= s->max_channel; ch++) {
 499         ChannelParams *cp = &s->channel_params[ch];
 500         cp->filter_params[FIR].order = 0;
 501         cp->filter_params[IIR].order = 0;
 502         cp->filter_params[FIR].shift = 0;
 503         cp->filter_params[IIR].shift = 0;
 504
 505         /* Default audio coding is 24-bit raw PCM. */
 506         cp->huff_offset      = 0;
 507         cp->sign_huff_offset = (-1) << 23;
 508         cp->codebook         = 0;
 509         cp->huff_lsbs        = 24;
 510     }
 511
 512     if (substr == m->max_decoded_substream)
 513         m->avctx->channels = s->max_matrix_channel + 1;
 514
 515     return 0;
 516 }
 517
 518 /** Read parameters for one of the prediction filters. */
 519
 520 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
 521                               unsigned int substr, unsigned int channel,
 522                               unsigned int filter)
 523 {
 524     SubStream *s = &m->substream[substr];
 525     FilterParams *fp = &s->channel_params[channel].filter_params[filter];
 526     const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
 527     const char fchar = filter ? 'I' : 'F';
 528     int i, order;
 529
 530     // Filter is 0 for FIR, 1 for IIR.
 531     assert(filter < 2);
 532
 533     if (m->filter_changed[channel][filter]++ > 1) {
 534         av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
 535         return AVERROR_INVALIDDATA;
 536     }
 537
 538     order = get_bits(gbp, 4);
 539     if (order > max_order) {
 540         av_log(m->avctx, AV_LOG_ERROR,
 541                "%cIR filter order %d is greater than maximum %d.\n",
 542                fchar, order, max_order);
 543         return AVERROR_INVALIDDATA;
 544     }
 545     fp->order = order;
 546
 547     if (order > 0) {
 548         int32_t *fcoeff = s->channel_params[channel].coeff[filter];
 549         int coeff_bits, coeff_shift;
 550
 551         fp->shift = get_bits(gbp, 4);
 552
 553         coeff_bits  = get_bits(gbp, 5);
 554         coeff_shift = get_bits(gbp, 3);
 555         if (coeff_bits < 1 || coeff_bits > 16) {
 556             av_log(m->avctx, AV_LOG_ERROR,
 557                    "%cIR filter coeff_bits must be between 1 and 16.\n",
 558                    fchar);
 559             return AVERROR_INVALIDDATA;
 560         }
 561         if (coeff_bits + coeff_shift > 16) {
 562             av_log(m->avctx, AV_LOG_ERROR,
 563                    "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
 564                    fchar);
 565             return AVERROR_INVALIDDATA;
 566         }
 567
 568         for (i = 0; i < order; i++)
 569             fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
 570
 571         if (get_bits1(gbp)) {
 572             int state_bits, state_shift;
 573
 574             if (filter == FIR) {
 575                 av_log(m->avctx, AV_LOG_ERROR,
 576                        "FIR filter has state data specified.\n");
 577                 return AVERROR_INVALIDDATA;
 578             }
 579
 580             state_bits  = get_bits(gbp, 4);
 581             state_shift = get_bits(gbp, 4);
 582
 583             /* TODO: Check validity of state data. */
 584
 585             for (i = 0; i < order; i++)
 586                 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
 587         }
 588     }
 589
 590     return 0;
 591 }
 592
 593 /** Read parameters for primitive matrices. */
 594
 595 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
 596 {
 597     SubStream *s = &m->substream[substr];
 598     unsigned int mat, ch;
 599     const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
 600                                      ? MAX_MATRICES_MLP
 601                                      : MAX_MATRICES_TRUEHD;
 602
 603     if (m->matrix_changed++ > 1) {
 604         av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
 605         return AVERROR_INVALIDDATA;
 606     }
 607
 608     s->num_primitive_matrices = get_bits(gbp, 4);
 609
 610     if (s->num_primitive_matrices > max_primitive_matrices) {
 611         av_log(m->avctx, AV_LOG_ERROR,
 612                "Number of primitive matrices cannot be greater than %d.\n",
 613                max_primitive_matrices);
 614         return AVERROR_INVALIDDATA;
 615     }
 616
 617     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
 618         int frac_bits, max_chan;
 619         s->matrix_out_ch[mat] = get_bits(gbp, 4);
 620         frac_bits             = get_bits(gbp, 4);
 621         s->lsb_bypass   [mat] = get_bits1(gbp);
 622
 623         if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
 624             av_log(m->avctx, AV_LOG_ERROR,
 625                     "Invalid channel %d specified as output from matrix.\n",
 626                     s->matrix_out_ch[mat]);
 627             return AVERROR_INVALIDDATA;
 628         }
 629         if (frac_bits > 14) {
 630             av_log(m->avctx, AV_LOG_ERROR,
 631                     "Too many fractional bits specified.\n");
 632             return AVERROR_INVALIDDATA;
 633         }
 634
 635         max_chan = s->max_matrix_channel;
 636         if (!s->noise_type)
 637             max_chan+=2;
 638
 639         for (ch = 0; ch <= max_chan; ch++) {
 640             int coeff_val = 0;
 641             if (get_bits1(gbp))
 642                 coeff_val = get_sbits(gbp, frac_bits + 2);
 643
 644             s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
 645         }
 646
 647         if (s->noise_type)
 648             s->matrix_noise_shift[mat] = get_bits(gbp, 4);
 649         else
 650             s->matrix_noise_shift[mat] = 0;
 651     }
 652
 653     return 0;
 654 }
 655
 656 /** Read channel parameters. */
 657
 658 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
 659                                GetBitContext *gbp, unsigned int ch)
 660 {
 661     SubStream *s = &m->substream[substr];
 662     ChannelParams *cp = &s->channel_params[ch];
 663     FilterParams *fir = &cp->filter_params[FIR];
 664     FilterParams *iir = &cp->filter_params[IIR];
 665     int ret;
 666
 667     if (s->param_presence_flags & PARAM_FIR)
 668         if (get_bits1(gbp))
 669             if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
 670                 return ret;
 671
 672     if (s->param_presence_flags & PARAM_IIR)
 673         if (get_bits1(gbp))
 674             if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
 675                 return ret;
 676
 677     if (fir->order + iir->order > 8) {
 678         av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
 679         return AVERROR_INVALIDDATA;
 680     }
 681
 682     if (fir->order && iir->order &&
 683         fir->shift != iir->shift) {
 684         av_log(m->avctx, AV_LOG_ERROR,
 685                 "FIR and IIR filters must use the same precision.\n");
 686         return AVERROR_INVALIDDATA;
 687     }
 688     /* The FIR and IIR filters must have the same precision.
 689      * To simplify the filtering code, only the precision of the
 690      * FIR filter is considered. If only the IIR filter is employed,
 691      * the FIR filter precision is set to that of the IIR filter, so
 692      * that the filtering code can use it. */
 693     if (!fir->order && iir->order)
 694         fir->shift = iir->shift;
 695
 696     if (s->param_presence_flags & PARAM_HUFFOFFSET)
 697         if (get_bits1(gbp))
 698             cp->huff_offset = get_sbits(gbp, 15);
 699
 700     cp->codebook  = get_bits(gbp, 2);
 701     cp->huff_lsbs = get_bits(gbp, 5);
 702
 703     if (cp->huff_lsbs > 24) {
 704         av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
 705         return AVERROR_INVALIDDATA;
 706     }
 707
 708     cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
 709
 710     return 0;
 711 }
 712
 713 /** Read decoding parameters that change more often than those in the restart
 714  *  header. */
 715
 716 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
 717                                 unsigned int substr)
 718 {
 719     SubStream *s = &m->substream[substr];
 720     unsigned int ch;
 721     int ret;
 722
 723     if (s->param_presence_flags & PARAM_PRESENCE)
 724         if (get_bits1(gbp))
 725             s->param_presence_flags = get_bits(gbp, 8);
 726
 727     if (s->param_presence_flags & PARAM_BLOCKSIZE)
 728         if (get_bits1(gbp)) {
 729             s->blocksize = get_bits(gbp, 9);
 730             if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
 731                 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
 732                 s->blocksize = 0;
 733                 return AVERROR_INVALIDDATA;
 734             }
 735         }
 736
 737     if (s->param_presence_flags & PARAM_MATRIX)
 738         if (get_bits1(gbp))
 739             if ((ret = read_matrix_params(m, substr, gbp)) < 0)
 740                 return ret;
 741
 742     if (s->param_presence_flags & PARAM_OUTSHIFT)
 743         if (get_bits1(gbp))
 744             for (ch = 0; ch <= s->max_matrix_channel; ch++)
 745                 s->output_shift[ch] = get_sbits(gbp, 4);
 746
 747     if (s->param_presence_flags & PARAM_QUANTSTEP)
 748         if (get_bits1(gbp))
 749             for (ch = 0; ch <= s->max_channel; ch++) {
 750                 ChannelParams *cp = &s->channel_params[ch];
 751
 752                 s->quant_step_size[ch] = get_bits(gbp, 4);
 753
 754                 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
 755             }
 756
 757     for (ch = s->min_channel; ch <= s->max_channel; ch++)
 758         if (get_bits1(gbp))
 759             if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
 760                 return ret;
 761
 762     return 0;
 763 }
 764
 765 #define MSB_MASK(bits)  (-1u << bits)
 766
 767 /** Generate PCM samples using the prediction filters and residual values
 768  *  read from the data stream, and update the filter state. */
 769
 770 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
 771                            unsigned int channel)
 772 {
 773     SubStream *s = &m->substream[substr];
 774     const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
 775     int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
 776     int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
 777     int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
 778     FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
 779     FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
 780     unsigned int filter_shift = fir->shift;
 781     int32_t mask = MSB_MASK(s->quant_step_size[channel]);
 782
 783     memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
 784     memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
 785
 786     m->dsp.mlp_filter_channel(firbuf, fircoeff,
 787                               fir->order, iir->order,
 788                               filter_shift, mask, s->blocksize,
 789                               &m->sample_buffer[s->blockpos][channel]);
 790
 791     memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
 792     memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
 793 }
 794
 795 /** Read a block of PCM residual data (or actual if no filtering active). */
 796
 797 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
 798                            unsigned int substr)
 799 {
 800     SubStream *s = &m->substream[substr];
 801     unsigned int i, ch, expected_stream_pos = 0;
 802     int ret;
 803
 804     if (s->data_check_present) {
 805         expected_stream_pos  = get_bits_count(gbp);
 806         expected_stream_pos += get_bits(gbp, 16);
 807         av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
 808                "we have not tested yet. %s\n", sample_message);
 809     }
 810
 811     if (s->blockpos + s->blocksize > m->access_unit_size) {
 812         av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
 813         return AVERROR_INVALIDDATA;
 814     }
 815
 816     memset(&m->bypassed_lsbs[s->blockpos][0], 0,
 817            s->blocksize * sizeof(m->bypassed_lsbs[0]));
 818
 819     for (i = 0; i < s->blocksize; i++)
 820         if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
 821             return ret;
 822
 823     for (ch = s->min_channel; ch <= s->max_channel; ch++)
 824         filter_channel(m, substr, ch);
 825
 826     s->blockpos += s->blocksize;
 827
 828     if (s->data_check_present) {
 829         if (get_bits_count(gbp) != expected_stream_pos)
 830             av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
 831         skip_bits(gbp, 8);
 832     }
 833
 834     return 0;
 835 }
 836
 837 /** Data table used for TrueHD noise generation function. */
 838
 839 static const int8_t noise_table[256] = {
 840      30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
 841      52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
 842      10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
 843      51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
 844      38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
 845      61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
 846      67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
 847      48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
 848       0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
 849      16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
 850      13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
 851      89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
 852      36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
 853      39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
 854      45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
 855     -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
 856 };
 857
 858 /** Noise generation functions.
 859  *  I'm not sure what these are for - they seem to be some kind of pseudorandom
 860  *  sequence generators, used to generate noise data which is used when the
 861  *  channels are rematrixed. I'm not sure if they provide a practical benefit
 862  *  to compression, or just obfuscate the decoder. Are they for some kind of
 863  *  dithering? */
 864
 865 /** Generate two channels of noise, used in the matrix when
 866  *  restart sync word == 0x31ea. */
 867
 868 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
 869 {
 870     SubStream *s = &m->substream[substr];
 871     unsigned int i;
 872     uint32_t seed = s->noisegen_seed;
 873     unsigned int maxchan = s->max_matrix_channel;
 874
 875     for (i = 0; i < s->blockpos; i++) {
 876         uint16_t seed_shr7 = seed >> 7;
 877         m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
 878         m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
 879
 880         seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
 881     }
 882
 883     s->noisegen_seed = seed;
 884 }
 885
 886 /** Generate a block of noise, used when restart sync word == 0x31eb. */
 887
 888 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
 889 {
 890     SubStream *s = &m->substream[substr];
 891     unsigned int i;
 892     uint32_t seed = s->noisegen_seed;
 893
 894     for (i = 0; i < m->access_unit_size_pow2; i++) {
 895         uint8_t seed_shr15 = seed >> 15;
 896         m->noise_buffer[i] = noise_table[seed_shr15];
 897         seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
 898     }
 899
 900     s->noisegen_seed = seed;
 901 }
 902
 903
 904 /** Apply the channel matrices in turn to reconstruct the original audio
 905  *  samples. */
 906
 907 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
 908 {
 909     SubStream *s = &m->substream[substr];
 910     unsigned int mat, src_ch, i;
 911     unsigned int maxchan;
 912
 913     maxchan = s->max_matrix_channel;
 914     if (!s->noise_type) {
 915         generate_2_noise_channels(m, substr);
 916         maxchan += 2;
 917     } else {
 918         fill_noise_buffer(m, substr);
 919     }
 920
 921     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
 922         int matrix_noise_shift = s->matrix_noise_shift[mat];
 923         unsigned int dest_ch = s->matrix_out_ch[mat];
 924         int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
 925         int32_t *coeffs = s->matrix_coeff[mat];
 926         int index  = s->num_primitive_matrices - mat;
 927         int index2 = 2 * index + 1;
 928
 929         /* TODO: DSPContext? */
 930
 931         for (i = 0; i < s->blockpos; i++) {
 932             int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
 933             int32_t *samples = m->sample_buffer[i];
 934             int64_t accum = 0;
 935
 936             for (src_ch = 0; src_ch <= maxchan; src_ch++)
 937                 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
 938
 939             if (matrix_noise_shift) {
 940                 index &= m->access_unit_size_pow2 - 1;
 941                 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
 942                 index += index2;
 943             }
 944
 945             samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
 946         }
 947     }
 948 }
 949
 950 /** Write the audio data into the output buffer. */
 951
 952 static int output_data(MLPDecodeContext *m, unsigned int substr,
 953                        void *data, int *got_frame_ptr)
 954 {
 955     AVCodecContext *avctx = m->avctx;
 956     SubStream *s = &m->substream[substr];
 957     unsigned int i, out_ch = 0;
 958     int32_t *data_32;
 959     int16_t *data_16;
 960     int ret;
 961     int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
 962
 963     if (m->avctx->channels != s->max_matrix_channel + 1) {
 964         av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
 965         return AVERROR_INVALIDDATA;
 966     }
 967
 968     /* get output buffer */
 969     m->frame.nb_samples = s->blockpos;
 970     if ((ret = avctx->get_buffer(avctx, &m->frame)) < 0) {
 971         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 972         return ret;
 973     }
 974     data_32 = (int32_t *)m->frame.data[0];
 975     data_16 = (int16_t *)m->frame.data[0];
 976
 977     for (i = 0; i < s->blockpos; i++) {
 978         for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
 979             int mat_ch = s->ch_assign[out_ch];
 980             int32_t sample = m->sample_buffer[i][mat_ch]
 981                           << s->output_shift[mat_ch];
 982             s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
 983             if (is32) *data_32++ = sample << 8;
 984             else      *data_16++ = sample >> 8;
 985         }
 986     }
 987
 988     *got_frame_ptr   = 1;
 989     *(AVFrame *)data = m->frame;
 990
 991     return 0;
 992 }
 993
 994 /** Read an access unit from the stream.
 995  *  @return negative on error, 0 if not enough data is present in the input stream,
 996  *  otherwise the number of bytes consumed. */
 997
 998 static int read_access_unit(AVCodecContext *avctx, void* data,
 999                             int *got_frame_ptr, AVPacket *avpkt)
1000 {
1001     const uint8_t *buf = avpkt->data;
1002     int buf_size = avpkt->size;
1003     MLPDecodeContext *m = avctx->priv_data;
1004     GetBitContext gb;
1005     unsigned int length, substr;
1006     unsigned int substream_start;
1007     unsigned int header_size = 4;
1008     unsigned int substr_header_size = 0;
1009     uint8_t substream_parity_present[MAX_SUBSTREAMS];
1010     uint16_t substream_data_len[MAX_SUBSTREAMS];
1011     uint8_t parity_bits;
1012     int ret;
1013
1014     if (buf_size < 4)
1015         return 0;
1016
1017     length = (AV_RB16(buf) & 0xfff) * 2;
1018
1019     if (length < 4 || length > buf_size)
1020         return AVERROR_INVALIDDATA;
1021
1022     init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1023
1024     m->is_major_sync_unit = 0;
1025     if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1026         if (read_major_sync(m, &gb) < 0)
1027             goto error;
1028         m->is_major_sync_unit = 1;
1029         header_size += 28;
1030     }
1031
1032     if (!m->params_valid) {
1033         av_log(m->avctx, AV_LOG_WARNING,
1034                "Stream parameters not seen; skipping frame.\n");
1035         *got_frame_ptr = 0;
1036         return length;
1037     }
1038
1039     substream_start = 0;
1040
1041     for (substr = 0; substr < m->num_substreams; substr++) {
1042         int extraword_present, checkdata_present, end, nonrestart_substr;
1043
1044         extraword_present = get_bits1(&gb);
1045         nonrestart_substr = get_bits1(&gb);
1046         checkdata_present = get_bits1(&gb);
1047         skip_bits1(&gb);
1048
1049         end = get_bits(&gb, 12) * 2;
1050
1051         substr_header_size += 2;
1052
1053         if (extraword_present) {
1054             if (m->avctx->codec_id == CODEC_ID_MLP) {
1055                 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1056                 goto error;
1057             }
1058             skip_bits(&gb, 16);
1059             substr_header_size += 2;
1060         }
1061
1062         if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1063             av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1064             goto error;
1065         }
1066
1067         if (end + header_size + substr_header_size > length) {
1068             av_log(m->avctx, AV_LOG_ERROR,
1069                    "Indicated length of substream %d data goes off end of "
1070                    "packet.\n", substr);
1071             end = length - header_size - substr_header_size;
1072         }
1073
1074         if (end < substream_start) {
1075             av_log(avctx, AV_LOG_ERROR,
1076                    "Indicated end offset of substream %d data "
1077                    "is smaller than calculated start offset.\n",
1078                    substr);
1079             goto error;
1080         }
1081
1082         if (substr > m->max_decoded_substream)
1083             continue;
1084
1085         substream_parity_present[substr] = checkdata_present;
1086         substream_data_len[substr] = end - substream_start;
1087         substream_start = end;
1088     }
1089
1090     parity_bits  = ff_mlp_calculate_parity(buf, 4);
1091     parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1092
1093     if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1094         av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1095         goto error;
1096     }
1097
1098     buf += header_size + substr_header_size;
1099
1100     for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1101         SubStream *s = &m->substream[substr];
1102         init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1103
1104         m->matrix_changed = 0;
1105         memset(m->filter_changed, 0, sizeof(m->filter_changed));
1106
1107         s->blockpos = 0;
1108         do {
1109             if (get_bits1(&gb)) {
1110                 if (get_bits1(&gb)) {
1111                     /* A restart header should be present. */
1112                     if (read_restart_header(m, &gb, buf, substr) < 0)
1113                         goto next_substr;
1114                     s->restart_seen = 1;
1115                 }
1116
1117                 if (!s->restart_seen)
1118                     goto next_substr;
1119                 if (read_decoding_params(m, &gb, substr) < 0)
1120                     goto next_substr;
1121             }
1122
1123             if (!s->restart_seen)
1124                 goto next_substr;
1125
1126             if ((ret = read_block_data(m, &gb, substr)) < 0)
1127                 return ret;
1128
1129             if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1130                 goto substream_length_mismatch;
1131
1132         } while (!get_bits1(&gb));
1133
1134         skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1135
1136         if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1137             int shorten_by;
1138
1139             if (get_bits(&gb, 16) != 0xD234)
1140                 return AVERROR_INVALIDDATA;
1141
1142             shorten_by = get_bits(&gb, 16);
1143             if      (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by  & 0x2000)
1144                 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1145             else if (m->avctx->codec_id == CODEC_ID_MLP    && shorten_by != 0xD234)
1146                 return AVERROR_INVALIDDATA;
1147
1148             if (substr == m->max_decoded_substream)
1149                 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1150         }
1151
1152         if (substream_parity_present[substr]) {
1153             uint8_t parity, checksum;
1154
1155             if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1156                 goto substream_length_mismatch;
1157
1158             parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1159             checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
1160
1161             if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
1162                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1163             if ( get_bits(&gb, 8)           != checksum)
1164                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
1165         }
1166
1167         if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1168             goto substream_length_mismatch;
1169
1170 next_substr:
1171         if (!s->restart_seen)
1172             av_log(m->avctx, AV_LOG_ERROR,
1173                    "No restart header present in substream %d.\n", substr);
1174
1175         buf += substream_data_len[substr];
1176     }
1177
1178     rematrix_channels(m, m->max_decoded_substream);
1179
1180     if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1181         return ret;
1182
1183     return length;
1184
1185 substream_length_mismatch:
1186     av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1187     return AVERROR_INVALIDDATA;
1188
1189 error:
1190     m->params_valid = 0;
1191     return AVERROR_INVALIDDATA;
1192 }
1193
1194 AVCodec ff_mlp_decoder = {
1195     .name           = "mlp",
1196     .type           = AVMEDIA_TYPE_AUDIO,
1197     .id             = CODEC_ID_MLP,
1198     .priv_data_size = sizeof(MLPDecodeContext),
1199     .init           = mlp_decode_init,
1200     .decode         = read_access_unit,
1201     .capabilities   = CODEC_CAP_DR1,
1202     .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1203 };
1204
1205 #if CONFIG_TRUEHD_DECODER
1206 AVCodec ff_truehd_decoder = {
1207     .name           = "truehd",
1208     .type           = AVMEDIA_TYPE_AUDIO,
1209     .id             = CODEC_ID_TRUEHD,
1210     .priv_data_size = sizeof(MLPDecodeContext),
1211     .init           = mlp_decode_init,
1212     .decode         = read_access_unit,
1213     .capabilities   = CODEC_CAP_DR1,
1214     .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1215 };
1216 #endif /* CONFIG_TRUEHD_DECODER */