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