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