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