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