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