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