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