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 FF_API_REQUEST_CHANNELS
 513 FF_DISABLE_DEPRECATION_WARNINGS
 514     if (m->avctx->request_channels > 0 &&
 515         m->avctx->request_channels <= s->max_channel + 1 &&
 516         m->max_decoded_substream > substr) {
 517         av_log(m->avctx, AV_LOG_DEBUG,
 518                "Extracting %d-channel downmix from substream %d. "
 519                "Further substreams will be skipped.\n",
 520                s->max_channel + 1, substr);
 521         m->max_decoded_substream = substr;
 522     } else
 523 FF_ENABLE_DEPRECATION_WARNINGS
 524 #endif
 525     if (m->avctx->request_channel_layout && (s->ch_layout & m->avctx->request_channel_layout) ==
 526         m->avctx->request_channel_layout && m->max_decoded_substream > substr) {
 527         av_log(m->avctx, AV_LOG_DEBUG,
 528                "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
 529                "Further substreams will be skipped.\n",
 530                s->max_channel + 1, s->ch_layout, substr);
 531         m->max_decoded_substream = substr;
 532     }
 533
 534     s->noise_shift   = get_bits(gbp,  4);
 535     s->noisegen_seed = get_bits(gbp, 23);
 536
 537     skip_bits(gbp, 19);
 538
 539     s->data_check_present = get_bits1(gbp);
 540     lossless_check = get_bits(gbp, 8);
 541     if (substr == m->max_decoded_substream
 542         && s->lossless_check_data != 0xffffffff) {
 543         tmp = xor_32_to_8(s->lossless_check_data);
 544         if (tmp != lossless_check)
 545             av_log(m->avctx, AV_LOG_WARNING,
 546                    "Lossless check failed - expected %02x, calculated %02x.\n",
 547                    lossless_check, tmp);
 548     }
 549
 550     skip_bits(gbp, 16);
 551
 552     memset(s->ch_assign, 0, sizeof(s->ch_assign));
 553
 554     for (ch = 0; ch <= s->max_matrix_channel; ch++) {
 555         int ch_assign = get_bits(gbp, 6);
 556         if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
 557             uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
 558                                                                   ch_assign);
 559             ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
 560                                                             channel);
 561         }
 562         if (ch_assign < 0 || ch_assign > s->max_matrix_channel) {
 563             avpriv_request_sample(m->avctx,
 564                                   "Assignment of matrix channel %d to invalid output channel %d",
 565                                   ch, ch_assign);
 566             return AVERROR_PATCHWELCOME;
 567         }
 568         s->ch_assign[ch_assign] = ch;
 569     }
 570
 571     checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
 572
 573     if (checksum != get_bits(gbp, 8))
 574         av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
 575
 576     /* Set default decoding parameters. */
 577     s->param_presence_flags   = 0xff;
 578     s->num_primitive_matrices = 0;
 579     s->blocksize              = 8;
 580     s->lossless_check_data    = 0;
 581
 582     memset(s->output_shift   , 0, sizeof(s->output_shift   ));
 583     memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
 584
 585     for (ch = s->min_channel; ch <= s->max_channel; ch++) {
 586         ChannelParams *cp = &s->channel_params[ch];
 587         cp->filter_params[FIR].order = 0;
 588         cp->filter_params[IIR].order = 0;
 589         cp->filter_params[FIR].shift = 0;
 590         cp->filter_params[IIR].shift = 0;
 591
 592         /* Default audio coding is 24-bit raw PCM. */
 593         cp->huff_offset      = 0;
 594         cp->sign_huff_offset = (-1) << 23;
 595         cp->codebook         = 0;
 596         cp->huff_lsbs        = 24;
 597     }
 598
 599     if (substr == m->max_decoded_substream) {
 600         m->avctx->channels       = s->max_matrix_channel + 1;
 601         m->avctx->channel_layout = s->ch_layout;
 602         m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
 603                                                                s->output_shift,
 604                                                                s->max_matrix_channel,
 605                                                                m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
 606     }
 607
 608     return 0;
 609 }
 610
 611 /** Read parameters for one of the prediction filters. */
 612
 613 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
 614                               unsigned int substr, unsigned int channel,
 615                               unsigned int filter)
 616 {
 617     SubStream *s = &m->substream[substr];
 618     FilterParams *fp = &s->channel_params[channel].filter_params[filter];
 619     const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
 620     const char fchar = filter ? 'I' : 'F';
 621     int i, order;
 622
 623     // Filter is 0 for FIR, 1 for IIR.
 624     assert(filter < 2);
 625
 626     if (m->filter_changed[channel][filter]++ > 1) {
 627         av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
 628         return AVERROR_INVALIDDATA;
 629     }
 630
 631     order = get_bits(gbp, 4);
 632     if (order > max_order) {
 633         av_log(m->avctx, AV_LOG_ERROR,
 634                "%cIR filter order %d is greater than maximum %d.\n",
 635                fchar, order, max_order);
 636         return AVERROR_INVALIDDATA;
 637     }
 638     fp->order = order;
 639
 640     if (order > 0) {
 641         int32_t *fcoeff = s->channel_params[channel].coeff[filter];
 642         int coeff_bits, coeff_shift;
 643
 644         fp->shift = get_bits(gbp, 4);
 645
 646         coeff_bits  = get_bits(gbp, 5);
 647         coeff_shift = get_bits(gbp, 3);
 648         if (coeff_bits < 1 || coeff_bits > 16) {
 649             av_log(m->avctx, AV_LOG_ERROR,
 650                    "%cIR filter coeff_bits must be between 1 and 16.\n",
 651                    fchar);
 652             return AVERROR_INVALIDDATA;
 653         }
 654         if (coeff_bits + coeff_shift > 16) {
 655             av_log(m->avctx, AV_LOG_ERROR,
 656                    "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
 657                    fchar);
 658             return AVERROR_INVALIDDATA;
 659         }
 660
 661         for (i = 0; i < order; i++)
 662             fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
 663
 664         if (get_bits1(gbp)) {
 665             int state_bits, state_shift;
 666
 667             if (filter == FIR) {
 668                 av_log(m->avctx, AV_LOG_ERROR,
 669                        "FIR filter has state data specified.\n");
 670                 return AVERROR_INVALIDDATA;
 671             }
 672
 673             state_bits  = get_bits(gbp, 4);
 674             state_shift = get_bits(gbp, 4);
 675
 676             /* TODO: Check validity of state data. */
 677
 678             for (i = 0; i < order; i++)
 679                 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
 680         }
 681     }
 682
 683     return 0;
 684 }
 685
 686 /** Read parameters for primitive matrices. */
 687
 688 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
 689 {
 690     SubStream *s = &m->substream[substr];
 691     unsigned int mat, ch;
 692     const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
 693                                      ? MAX_MATRICES_MLP
 694                                      : MAX_MATRICES_TRUEHD;
 695
 696     if (m->matrix_changed++ > 1) {
 697         av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
 698         return AVERROR_INVALIDDATA;
 699     }
 700
 701     s->num_primitive_matrices = get_bits(gbp, 4);
 702
 703     if (s->num_primitive_matrices > max_primitive_matrices) {
 704         av_log(m->avctx, AV_LOG_ERROR,
 705                "Number of primitive matrices cannot be greater than %d.\n",
 706                max_primitive_matrices);
 707         return AVERROR_INVALIDDATA;
 708     }
 709
 710     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
 711         int frac_bits, max_chan;
 712         s->matrix_out_ch[mat] = get_bits(gbp, 4);
 713         frac_bits             = get_bits(gbp, 4);
 714         s->lsb_bypass   [mat] = get_bits1(gbp);
 715
 716         if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
 717             av_log(m->avctx, AV_LOG_ERROR,
 718                     "Invalid channel %d specified as output from matrix.\n",
 719                     s->matrix_out_ch[mat]);
 720             return AVERROR_INVALIDDATA;
 721         }
 722         if (frac_bits > 14) {
 723             av_log(m->avctx, AV_LOG_ERROR,
 724                     "Too many fractional bits specified.\n");
 725             return AVERROR_INVALIDDATA;
 726         }
 727
 728         max_chan = s->max_matrix_channel;
 729         if (!s->noise_type)
 730             max_chan+=2;
 731
 732         for (ch = 0; ch <= max_chan; ch++) {
 733             int coeff_val = 0;
 734             if (get_bits1(gbp))
 735                 coeff_val = get_sbits(gbp, frac_bits + 2);
 736
 737             s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
 738         }
 739
 740         if (s->noise_type)
 741             s->matrix_noise_shift[mat] = get_bits(gbp, 4);
 742         else
 743             s->matrix_noise_shift[mat] = 0;
 744     }
 745
 746     return 0;
 747 }
 748
 749 /** Read channel parameters. */
 750
 751 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
 752                                GetBitContext *gbp, unsigned int ch)
 753 {
 754     SubStream *s = &m->substream[substr];
 755     ChannelParams *cp = &s->channel_params[ch];
 756     FilterParams *fir = &cp->filter_params[FIR];
 757     FilterParams *iir = &cp->filter_params[IIR];
 758     int ret;
 759
 760     if (s->param_presence_flags & PARAM_FIR)
 761         if (get_bits1(gbp))
 762             if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
 763                 return ret;
 764
 765     if (s->param_presence_flags & PARAM_IIR)
 766         if (get_bits1(gbp))
 767             if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
 768                 return ret;
 769
 770     if (fir->order + iir->order > 8) {
 771         av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
 772         return AVERROR_INVALIDDATA;
 773     }
 774
 775     if (fir->order && iir->order &&
 776         fir->shift != iir->shift) {
 777         av_log(m->avctx, AV_LOG_ERROR,
 778                 "FIR and IIR filters must use the same precision.\n");
 779         return AVERROR_INVALIDDATA;
 780     }
 781     /* The FIR and IIR filters must have the same precision.
 782      * To simplify the filtering code, only the precision of the
 783      * FIR filter is considered. If only the IIR filter is employed,
 784      * the FIR filter precision is set to that of the IIR filter, so
 785      * that the filtering code can use it. */
 786     if (!fir->order && iir->order)
 787         fir->shift = iir->shift;
 788
 789     if (s->param_presence_flags & PARAM_HUFFOFFSET)
 790         if (get_bits1(gbp))
 791             cp->huff_offset = get_sbits(gbp, 15);
 792
 793     cp->codebook  = get_bits(gbp, 2);
 794     cp->huff_lsbs = get_bits(gbp, 5);
 795
 796     if (cp->huff_lsbs > 24) {
 797         av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
 798         return AVERROR_INVALIDDATA;
 799     }
 800
 801     cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
 802
 803     return 0;
 804 }
 805
 806 /** Read decoding parameters that change more often than those in the restart
 807  *  header. */
 808
 809 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
 810                                 unsigned int substr)
 811 {
 812     SubStream *s = &m->substream[substr];
 813     unsigned int ch;
 814     int ret;
 815
 816     if (s->param_presence_flags & PARAM_PRESENCE)
 817         if (get_bits1(gbp))
 818             s->param_presence_flags = get_bits(gbp, 8);
 819
 820     if (s->param_presence_flags & PARAM_BLOCKSIZE)
 821         if (get_bits1(gbp)) {
 822             s->blocksize = get_bits(gbp, 9);
 823             if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
 824                 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
 825                 s->blocksize = 0;
 826                 return AVERROR_INVALIDDATA;
 827             }
 828         }
 829
 830     if (s->param_presence_flags & PARAM_MATRIX)
 831         if (get_bits1(gbp))
 832             if ((ret = read_matrix_params(m, substr, gbp)) < 0)
 833                 return ret;
 834
 835     if (s->param_presence_flags & PARAM_OUTSHIFT)
 836         if (get_bits1(gbp)) {
 837             for (ch = 0; ch <= s->max_matrix_channel; ch++)
 838                 s->output_shift[ch] = get_sbits(gbp, 4);
 839             if (substr == m->max_decoded_substream)
 840                 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
 841                                                                        s->output_shift,
 842                                                                        s->max_matrix_channel,
 843                                                                        m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
 844         }
 845
 846     if (s->param_presence_flags & PARAM_QUANTSTEP)
 847         if (get_bits1(gbp))
 848             for (ch = 0; ch <= s->max_channel; ch++) {
 849                 ChannelParams *cp = &s->channel_params[ch];
 850
 851                 s->quant_step_size[ch] = get_bits(gbp, 4);
 852
 853                 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
 854             }
 855
 856     for (ch = s->min_channel; ch <= s->max_channel; ch++)
 857         if (get_bits1(gbp))
 858             if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
 859                 return ret;
 860
 861     return 0;
 862 }
 863
 864 #define MSB_MASK(bits)  (-1u << bits)
 865
 866 /** Generate PCM samples using the prediction filters and residual values
 867  *  read from the data stream, and update the filter state. */
 868
 869 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
 870                            unsigned int channel)
 871 {
 872     SubStream *s = &m->substream[substr];
 873     const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
 874     int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
 875     int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
 876     int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
 877     FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
 878     FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
 879     unsigned int filter_shift = fir->shift;
 880     int32_t mask = MSB_MASK(s->quant_step_size[channel]);
 881
 882     memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
 883     memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
 884
 885     m->dsp.mlp_filter_channel(firbuf, fircoeff,
 886                               fir->order, iir->order,
 887                               filter_shift, mask, s->blocksize,
 888                               &m->sample_buffer[s->blockpos][channel]);
 889
 890     memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
 891     memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
 892 }
 893
 894 /** Read a block of PCM residual data (or actual if no filtering active). */
 895
 896 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
 897                            unsigned int substr)
 898 {
 899     SubStream *s = &m->substream[substr];
 900     unsigned int i, ch, expected_stream_pos = 0;
 901     int ret;
 902
 903     if (s->data_check_present) {
 904         expected_stream_pos  = get_bits_count(gbp);
 905         expected_stream_pos += get_bits(gbp, 16);
 906         avpriv_request_sample(m->avctx,
 907                               "Substreams with VLC block size check info");
 908     }
 909
 910     if (s->blockpos + s->blocksize > m->access_unit_size) {
 911         av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
 912         return AVERROR_INVALIDDATA;
 913     }
 914
 915     memset(&m->bypassed_lsbs[s->blockpos][0], 0,
 916            s->blocksize * sizeof(m->bypassed_lsbs[0]));
 917
 918     for (i = 0; i < s->blocksize; i++)
 919         if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
 920             return ret;
 921
 922     for (ch = s->min_channel; ch <= s->max_channel; ch++)
 923         filter_channel(m, substr, ch);
 924
 925     s->blockpos += s->blocksize;
 926
 927     if (s->data_check_present) {
 928         if (get_bits_count(gbp) != expected_stream_pos)
 929             av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
 930         skip_bits(gbp, 8);
 931     }
 932
 933     return 0;
 934 }
 935
 936 /** Data table used for TrueHD noise generation function. */
 937
 938 static const int8_t noise_table[256] = {
 939      30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
 940      52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
 941      10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
 942      51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
 943      38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
 944      61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
 945      67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
 946      48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
 947       0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
 948      16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
 949      13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
 950      89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
 951      36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
 952      39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
 953      45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
 954     -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
 955 };
 956
 957 /** Noise generation functions.
 958  *  I'm not sure what these are for - they seem to be some kind of pseudorandom
 959  *  sequence generators, used to generate noise data which is used when the
 960  *  channels are rematrixed. I'm not sure if they provide a practical benefit
 961  *  to compression, or just obfuscate the decoder. Are they for some kind of
 962  *  dithering? */
 963
 964 /** Generate two channels of noise, used in the matrix when
 965  *  restart sync word == 0x31ea. */
 966
 967 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
 968 {
 969     SubStream *s = &m->substream[substr];
 970     unsigned int i;
 971     uint32_t seed = s->noisegen_seed;
 972     unsigned int maxchan = s->max_matrix_channel;
 973
 974     for (i = 0; i < s->blockpos; i++) {
 975         uint16_t seed_shr7 = seed >> 7;
 976         m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
 977         m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
 978
 979         seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
 980     }
 981
 982     s->noisegen_seed = seed;
 983 }
 984
 985 /** Generate a block of noise, used when restart sync word == 0x31eb. */
 986
 987 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
 988 {
 989     SubStream *s = &m->substream[substr];
 990     unsigned int i;
 991     uint32_t seed = s->noisegen_seed;
 992
 993     for (i = 0; i < m->access_unit_size_pow2; i++) {
 994         uint8_t seed_shr15 = seed >> 15;
 995         m->noise_buffer[i] = noise_table[seed_shr15];
 996         seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
 997     }
 998
 999     s->noisegen_seed = seed;
1000 }
1001
1002
1003 /** Apply the channel matrices in turn to reconstruct the original audio
1004  *  samples. */
1005
1006 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
1007 {
1008     SubStream *s = &m->substream[substr];
1009     unsigned int mat;
1010     unsigned int maxchan;
1011
1012     maxchan = s->max_matrix_channel;
1013     if (!s->noise_type) {
1014         generate_2_noise_channels(m, substr);
1015         maxchan += 2;
1016     } else {
1017         fill_noise_buffer(m, substr);
1018     }
1019
1020     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1021         unsigned int dest_ch = s->matrix_out_ch[mat];
1022         m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1023                                     s->matrix_coeff[mat],
1024                                     &m->bypassed_lsbs[0][mat],
1025                                     m->noise_buffer,
1026                                     s->num_primitive_matrices - mat,
1027                                     dest_ch,
1028                                     s->blockpos,
1029                                     maxchan,
1030                                     s->matrix_noise_shift[mat],
1031                                     m->access_unit_size_pow2,
1032                                     MSB_MASK(s->quant_step_size[dest_ch]));
1033     }
1034 }
1035
1036 /** Write the audio data into the output buffer. */
1037
1038 static int output_data(MLPDecodeContext *m, unsigned int substr,
1039                        AVFrame *frame, int *got_frame_ptr)
1040 {
1041     AVCodecContext *avctx = m->avctx;
1042     SubStream *s = &m->substream[substr];
1043     int ret;
1044     int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1045
1046     if (m->avctx->channels != s->max_matrix_channel + 1) {
1047         av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1048         return AVERROR_INVALIDDATA;
1049     }
1050
1051     if (!s->blockpos) {
1052         av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1053         return AVERROR_INVALIDDATA;
1054     }
1055
1056     /* get output buffer */
1057     frame->nb_samples = s->blockpos;
1058     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1059         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1060         return ret;
1061     }
1062     s->lossless_check_data = m->dsp.mlp_pack_output(s->lossless_check_data,
1063                                                     s->blockpos,
1064                                                     m->sample_buffer,
1065                                                     frame->data[0],
1066                                                     s->ch_assign,
1067                                                     s->output_shift,
1068                                                     s->max_matrix_channel,
1069                                                     is32);
1070
1071     /* Update matrix encoding side data */
1072     if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1073         return ret;
1074
1075     *got_frame_ptr = 1;
1076
1077     return 0;
1078 }
1079
1080 /** Read an access unit from the stream.
1081  *  @return negative on error, 0 if not enough data is present in the input stream,
1082  *  otherwise the number of bytes consumed. */
1083
1084 static int read_access_unit(AVCodecContext *avctx, void* data,
1085                             int *got_frame_ptr, AVPacket *avpkt)
1086 {
1087     const uint8_t *buf = avpkt->data;
1088     int buf_size = avpkt->size;
1089     MLPDecodeContext *m = avctx->priv_data;
1090     GetBitContext gb;
1091     unsigned int length, substr;
1092     unsigned int substream_start;
1093     unsigned int header_size = 4;
1094     unsigned int substr_header_size = 0;
1095     uint8_t substream_parity_present[MAX_SUBSTREAMS];
1096     uint16_t substream_data_len[MAX_SUBSTREAMS];
1097     uint8_t parity_bits;
1098     int ret;
1099
1100     if (buf_size < 4)
1101         return 0;
1102
1103     length = (AV_RB16(buf) & 0xfff) * 2;
1104
1105     if (length < 4 || length > buf_size)
1106         return AVERROR_INVALIDDATA;
1107
1108     init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1109
1110     m->is_major_sync_unit = 0;
1111     if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1112         if (read_major_sync(m, &gb) < 0)
1113             goto error;
1114         m->is_major_sync_unit = 1;
1115         header_size += m->major_sync_header_size;
1116     }
1117
1118     if (!m->params_valid) {
1119         av_log(m->avctx, AV_LOG_WARNING,
1120                "Stream parameters not seen; skipping frame.\n");
1121         *got_frame_ptr = 0;
1122         return length;
1123     }
1124
1125     substream_start = 0;
1126
1127     for (substr = 0; substr < m->num_substreams; substr++) {
1128         int extraword_present, checkdata_present, end, nonrestart_substr;
1129
1130         extraword_present = get_bits1(&gb);
1131         nonrestart_substr = get_bits1(&gb);
1132         checkdata_present = get_bits1(&gb);
1133         skip_bits1(&gb);
1134
1135         end = get_bits(&gb, 12) * 2;
1136
1137         substr_header_size += 2;
1138
1139         if (extraword_present) {
1140             if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1141                 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1142                 goto error;
1143             }
1144             skip_bits(&gb, 16);
1145             substr_header_size += 2;
1146         }
1147
1148         if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1149             av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1150             goto error;
1151         }
1152
1153         if (end + header_size + substr_header_size > length) {
1154             av_log(m->avctx, AV_LOG_ERROR,
1155                    "Indicated length of substream %d data goes off end of "
1156                    "packet.\n", substr);
1157             end = length - header_size - substr_header_size;
1158         }
1159
1160         if (end < substream_start) {
1161             av_log(avctx, AV_LOG_ERROR,
1162                    "Indicated end offset of substream %d data "
1163                    "is smaller than calculated start offset.\n",
1164                    substr);
1165             goto error;
1166         }
1167
1168         if (substr > m->max_decoded_substream)
1169             continue;
1170
1171         substream_parity_present[substr] = checkdata_present;
1172         substream_data_len[substr] = end - substream_start;
1173         substream_start = end;
1174     }
1175
1176     parity_bits  = ff_mlp_calculate_parity(buf, 4);
1177     parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1178
1179     if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1180         av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1181         goto error;
1182     }
1183
1184     buf += header_size + substr_header_size;
1185
1186     for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1187         SubStream *s = &m->substream[substr];
1188         init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1189
1190         m->matrix_changed = 0;
1191         memset(m->filter_changed, 0, sizeof(m->filter_changed));
1192
1193         s->blockpos = 0;
1194         do {
1195             if (get_bits1(&gb)) {
1196                 if (get_bits1(&gb)) {
1197                     /* A restart header should be present. */
1198                     if (read_restart_header(m, &gb, buf, substr) < 0)
1199                         goto next_substr;
1200                     s->restart_seen = 1;
1201                 }
1202
1203                 if (!s->restart_seen)
1204                     goto next_substr;
1205                 if (read_decoding_params(m, &gb, substr) < 0)
1206                     goto next_substr;
1207             }
1208
1209             if (!s->restart_seen)
1210                 goto next_substr;
1211
1212             if ((ret = read_block_data(m, &gb, substr)) < 0)
1213                 return ret;
1214
1215             if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1216                 goto substream_length_mismatch;
1217
1218         } while (!get_bits1(&gb));
1219
1220         skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1221
1222         if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1223             int shorten_by;
1224
1225             if (get_bits(&gb, 16) != 0xD234)
1226                 return AVERROR_INVALIDDATA;
1227
1228             shorten_by = get_bits(&gb, 16);
1229             if      (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by  & 0x2000)
1230                 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1231             else if (m->avctx->codec_id == AV_CODEC_ID_MLP    && shorten_by != 0xD234)
1232                 return AVERROR_INVALIDDATA;
1233
1234             if (substr == m->max_decoded_substream)
1235                 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1236         }
1237
1238         if (substream_parity_present[substr]) {
1239             uint8_t parity, checksum;
1240
1241             if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1242                 goto substream_length_mismatch;
1243
1244             parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1245             checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
1246
1247             if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
1248                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1249             if ( get_bits(&gb, 8)           != checksum)
1250                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
1251         }
1252
1253         if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1254             goto substream_length_mismatch;
1255
1256 next_substr:
1257         if (!s->restart_seen)
1258             av_log(m->avctx, AV_LOG_ERROR,
1259                    "No restart header present in substream %d.\n", substr);
1260
1261         buf += substream_data_len[substr];
1262     }
1263
1264     rematrix_channels(m, m->max_decoded_substream);
1265
1266     if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1267         return ret;
1268
1269     return length;
1270
1271 substream_length_mismatch:
1272     av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1273     return AVERROR_INVALIDDATA;
1274
1275 error:
1276     m->params_valid = 0;
1277     return AVERROR_INVALIDDATA;
1278 }
1279
1280 AVCodec ff_mlp_decoder = {
1281     .name           = "mlp",
1282     .long_name      = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1283     .type           = AVMEDIA_TYPE_AUDIO,
1284     .id             = AV_CODEC_ID_MLP,
1285     .priv_data_size = sizeof(MLPDecodeContext),
1286     .init           = mlp_decode_init,
1287     .decode         = read_access_unit,
1288     .capabilities   = CODEC_CAP_DR1,
1289 };
1290
1291 #if CONFIG_TRUEHD_DECODER
1292 AVCodec ff_truehd_decoder = {
1293     .name           = "truehd",
1294     .long_name      = NULL_IF_CONFIG_SMALL("TrueHD"),
1295     .type           = AVMEDIA_TYPE_AUDIO,
1296     .id             = AV_CODEC_ID_TRUEHD,
1297     .priv_data_size = sizeof(MLPDecodeContext),
1298     .init           = mlp_decode_init,
1299     .decode         = read_access_unit,
1300     .capabilities   = CODEC_CAP_DR1,
1301 };
1302 #endif /* CONFIG_TRUEHD_DECODER */