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