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     AVFrame     frame;
 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     avcodec_get_frame_defaults(&m->frame);
 272     avctx->coded_frame = &m->frame;
 273
 274     return 0;
 275 }
 276
 277 /** Read a major sync info header - contains high level information about
 278  *  the stream - sample rate, channel arrangement etc. Most of this
 279  *  information is not actually necessary for decoding, only for playback.
 280  */
 281
 282 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
 283 {
 284     MLPHeaderInfo mh;
 285     int substr, ret;
 286
 287     if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
 288         return ret;
 289
 290     if (mh.group1_bits == 0) {
 291         av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
 292         return AVERROR_INVALIDDATA;
 293     }
 294     if (mh.group2_bits > mh.group1_bits) {
 295         av_log(m->avctx, AV_LOG_ERROR,
 296                "Channel group 2 cannot have more bits per sample than group 1.\n");
 297         return AVERROR_INVALIDDATA;
 298     }
 299
 300     if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
 301         av_log(m->avctx, AV_LOG_ERROR,
 302                "Channel groups with differing sample rates are not currently supported.\n");
 303         return AVERROR_INVALIDDATA;
 304     }
 305
 306     if (mh.group1_samplerate == 0) {
 307         av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
 308         return AVERROR_INVALIDDATA;
 309     }
 310     if (mh.group1_samplerate > MAX_SAMPLERATE) {
 311         av_log(m->avctx, AV_LOG_ERROR,
 312                "Sampling rate %d is greater than the supported maximum (%d).\n",
 313                mh.group1_samplerate, MAX_SAMPLERATE);
 314         return AVERROR_INVALIDDATA;
 315     }
 316     if (mh.access_unit_size > MAX_BLOCKSIZE) {
 317         av_log(m->avctx, AV_LOG_ERROR,
 318                "Block size %d is greater than the supported maximum (%d).\n",
 319                mh.access_unit_size, MAX_BLOCKSIZE);
 320         return AVERROR_INVALIDDATA;
 321     }
 322     if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
 323         av_log(m->avctx, AV_LOG_ERROR,
 324                "Block size pow2 %d is greater than the supported maximum (%d).\n",
 325                mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
 326         return AVERROR_INVALIDDATA;
 327     }
 328
 329     if (mh.num_substreams == 0)
 330         return AVERROR_INVALIDDATA;
 331     if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
 332         av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
 333         return AVERROR_INVALIDDATA;
 334     }
 335     if (mh.num_substreams > MAX_SUBSTREAMS) {
 336         av_log_ask_for_sample(m->avctx,
 337                "Number of substreams %d is larger than the maximum supported "
 338                "by the decoder.\n", mh.num_substreams);
 339         return AVERROR_PATCHWELCOME;
 340     }
 341
 342     m->access_unit_size      = mh.access_unit_size;
 343     m->access_unit_size_pow2 = mh.access_unit_size_pow2;
 344
 345     m->num_substreams        = mh.num_substreams;
 346     m->max_decoded_substream = m->num_substreams - 1;
 347
 348     m->avctx->sample_rate    = mh.group1_samplerate;
 349     m->avctx->frame_size     = mh.access_unit_size;
 350
 351     m->avctx->bits_per_raw_sample = mh.group1_bits;
 352     if (mh.group1_bits > 16)
 353         m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
 354     else
 355         m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 356
 357     m->params_valid = 1;
 358     for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
 359         m->substream[substr].restart_seen = 0;
 360
 361     /* Set the layout for each substream. When there's more than one, the first
 362      * substream is Stereo. Subsequent substreams' layouts are indicated in the
 363      * major sync. */
 364     if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
 365         if ((substr = (mh.num_substreams > 1)))
 366             m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
 367         m->substream[substr].ch_layout = mh.channel_layout_mlp;
 368     } else {
 369         if ((substr = (mh.num_substreams > 1)))
 370             m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
 371         if (mh.num_substreams > 2)
 372             if (mh.channel_layout_thd_stream2)
 373                 m->substream[2].ch_layout = mh.channel_layout_thd_stream2;
 374             else
 375                 m->substream[2].ch_layout = mh.channel_layout_thd_stream1;
 376         m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;
 377     }
 378
 379     return 0;
 380 }
 381
 382 /** Read a restart header from a block in a substream. This contains parameters
 383  *  required to decode the audio that do not change very often. Generally
 384  *  (always) present only in blocks following a major sync. */
 385
 386 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
 387                                const uint8_t *buf, unsigned int substr)
 388 {
 389     SubStream *s = &m->substream[substr];
 390     unsigned int ch;
 391     int sync_word, tmp;
 392     uint8_t checksum;
 393     uint8_t lossless_check;
 394     int start_count = get_bits_count(gbp);
 395     const int max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
 396                                  ? MAX_MATRIX_CHANNEL_MLP
 397                                  : MAX_MATRIX_CHANNEL_TRUEHD;
 398
 399     sync_word = get_bits(gbp, 13);
 400
 401     if (sync_word != 0x31ea >> 1) {
 402         av_log(m->avctx, AV_LOG_ERROR,
 403                "restart header sync incorrect (got 0x%04x)\n", sync_word);
 404         return AVERROR_INVALIDDATA;
 405     }
 406
 407     s->noise_type = get_bits1(gbp);
 408
 409     if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
 410         av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
 411         return AVERROR_INVALIDDATA;
 412     }
 413
 414     skip_bits(gbp, 16); /* Output timestamp */
 415
 416     s->min_channel        = get_bits(gbp, 4);
 417     s->max_channel        = get_bits(gbp, 4);
 418     s->max_matrix_channel = get_bits(gbp, 4);
 419
 420     if (s->max_matrix_channel > max_matrix_channel) {
 421         av_log(m->avctx, AV_LOG_ERROR,
 422                "Max matrix channel cannot be greater than %d.\n",
 423                max_matrix_channel);
 424         return AVERROR_INVALIDDATA;
 425     }
 426
 427     if (s->max_channel != s->max_matrix_channel) {
 428         av_log(m->avctx, AV_LOG_ERROR,
 429                "Max channel must be equal max matrix channel.\n");
 430         return AVERROR_INVALIDDATA;
 431     }
 432
 433     /* This should happen for TrueHD streams with >6 channels and MLP's noise
 434      * type. It is not yet known if this is allowed. */
 435     if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
 436         av_log_ask_for_sample(m->avctx,
 437                "Number of channels %d is larger than the maximum supported "
 438                "by the decoder.\n", s->max_channel + 2);
 439         return AVERROR_PATCHWELCOME;
 440     }
 441
 442     if (s->min_channel > s->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 #if FF_API_REQUEST_CHANNELS
 449     if (m->avctx->request_channels > 0 &&
 450         m->avctx->request_channels <= s->max_channel + 1 &&
 451         m->max_decoded_substream > substr) {
 452         av_log(m->avctx, AV_LOG_DEBUG,
 453                "Extracting %d-channel downmix from substream %d. "
 454                "Further substreams will be skipped.\n",
 455                s->max_channel + 1, substr);
 456         m->max_decoded_substream = substr;
 457     } else
 458 #endif
 459     if (m->avctx->request_channel_layout == s->ch_layout &&
 460         m->max_decoded_substream > substr) {
 461         av_log(m->avctx, AV_LOG_DEBUG,
 462                "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
 463                "Further substreams will be skipped.\n",
 464                s->max_channel + 1, s->ch_layout, substr);
 465         m->max_decoded_substream = substr;
 466     }
 467
 468     s->noise_shift   = get_bits(gbp,  4);
 469     s->noisegen_seed = get_bits(gbp, 23);
 470
 471     skip_bits(gbp, 19);
 472
 473     s->data_check_present = get_bits1(gbp);
 474     lossless_check = get_bits(gbp, 8);
 475     if (substr == m->max_decoded_substream
 476         && s->lossless_check_data != 0xffffffff) {
 477         tmp = xor_32_to_8(s->lossless_check_data);
 478         if (tmp != lossless_check)
 479             av_log(m->avctx, AV_LOG_WARNING,
 480                    "Lossless check failed - expected %02x, calculated %02x.\n",
 481                    lossless_check, tmp);
 482     }
 483
 484     skip_bits(gbp, 16);
 485
 486     memset(s->ch_assign, 0, sizeof(s->ch_assign));
 487
 488     for (ch = 0; ch <= s->max_matrix_channel; ch++) {
 489         int ch_assign = get_bits(gbp, 6);
 490         if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
 491             uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
 492                                                                   ch_assign);
 493             ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
 494                                                             channel);
 495         }
 496         if (ch_assign > s->max_matrix_channel) {
 497             av_log_ask_for_sample(m->avctx,
 498                    "Assignment of matrix channel %d to invalid output channel %d.\n",
 499                    ch, ch_assign);
 500             return AVERROR_PATCHWELCOME;
 501         }
 502         s->ch_assign[ch_assign] = ch;
 503     }
 504
 505     checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
 506
 507     if (checksum != get_bits(gbp, 8))
 508         av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
 509
 510     /* Set default decoding parameters. */
 511     s->param_presence_flags   = 0xff;
 512     s->num_primitive_matrices = 0;
 513     s->blocksize              = 8;
 514     s->lossless_check_data    = 0;
 515
 516     memset(s->output_shift   , 0, sizeof(s->output_shift   ));
 517     memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
 518
 519     for (ch = s->min_channel; ch <= s->max_channel; ch++) {
 520         ChannelParams *cp = &s->channel_params[ch];
 521         cp->filter_params[FIR].order = 0;
 522         cp->filter_params[IIR].order = 0;
 523         cp->filter_params[FIR].shift = 0;
 524         cp->filter_params[IIR].shift = 0;
 525
 526         /* Default audio coding is 24-bit raw PCM. */
 527         cp->huff_offset      = 0;
 528         cp->sign_huff_offset = (-1) << 23;
 529         cp->codebook         = 0;
 530         cp->huff_lsbs        = 24;
 531     }
 532
 533     if (substr == m->max_decoded_substream) {
 534         m->avctx->channels       = s->max_matrix_channel + 1;
 535         m->avctx->channel_layout = s->ch_layout;
 536     }
 537
 538     return 0;
 539 }
 540
 541 /** Read parameters for one of the prediction filters. */
 542
 543 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
 544                               unsigned int substr, unsigned int channel,
 545                               unsigned int filter)
 546 {
 547     SubStream *s = &m->substream[substr];
 548     FilterParams *fp = &s->channel_params[channel].filter_params[filter];
 549     const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
 550     const char fchar = filter ? 'I' : 'F';
 551     int i, order;
 552
 553     // Filter is 0 for FIR, 1 for IIR.
 554     assert(filter < 2);
 555
 556     if (m->filter_changed[channel][filter]++ > 1) {
 557         av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
 558         return AVERROR_INVALIDDATA;
 559     }
 560
 561     order = get_bits(gbp, 4);
 562     if (order > max_order) {
 563         av_log(m->avctx, AV_LOG_ERROR,
 564                "%cIR filter order %d is greater than maximum %d.\n",
 565                fchar, order, max_order);
 566         return AVERROR_INVALIDDATA;
 567     }
 568     fp->order = order;
 569
 570     if (order > 0) {
 571         int32_t *fcoeff = s->channel_params[channel].coeff[filter];
 572         int coeff_bits, coeff_shift;
 573
 574         fp->shift = get_bits(gbp, 4);
 575
 576         coeff_bits  = get_bits(gbp, 5);
 577         coeff_shift = get_bits(gbp, 3);
 578         if (coeff_bits < 1 || coeff_bits > 16) {
 579             av_log(m->avctx, AV_LOG_ERROR,
 580                    "%cIR filter coeff_bits must be between 1 and 16.\n",
 581                    fchar);
 582             return AVERROR_INVALIDDATA;
 583         }
 584         if (coeff_bits + coeff_shift > 16) {
 585             av_log(m->avctx, AV_LOG_ERROR,
 586                    "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
 587                    fchar);
 588             return AVERROR_INVALIDDATA;
 589         }
 590
 591         for (i = 0; i < order; i++)
 592             fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
 593
 594         if (get_bits1(gbp)) {
 595             int state_bits, state_shift;
 596
 597             if (filter == FIR) {
 598                 av_log(m->avctx, AV_LOG_ERROR,
 599                        "FIR filter has state data specified.\n");
 600                 return AVERROR_INVALIDDATA;
 601             }
 602
 603             state_bits  = get_bits(gbp, 4);
 604             state_shift = get_bits(gbp, 4);
 605
 606             /* TODO: Check validity of state data. */
 607
 608             for (i = 0; i < order; i++)
 609                 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
 610         }
 611     }
 612
 613     return 0;
 614 }
 615
 616 /** Read parameters for primitive matrices. */
 617
 618 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
 619 {
 620     SubStream *s = &m->substream[substr];
 621     unsigned int mat, ch;
 622     const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
 623                                      ? MAX_MATRICES_MLP
 624                                      : MAX_MATRICES_TRUEHD;
 625
 626     if (m->matrix_changed++ > 1) {
 627         av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
 628         return AVERROR_INVALIDDATA;
 629     }
 630
 631     s->num_primitive_matrices = get_bits(gbp, 4);
 632
 633     if (s->num_primitive_matrices > max_primitive_matrices) {
 634         av_log(m->avctx, AV_LOG_ERROR,
 635                "Number of primitive matrices cannot be greater than %d.\n",
 636                max_primitive_matrices);
 637         return AVERROR_INVALIDDATA;
 638     }
 639
 640     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
 641         int frac_bits, max_chan;
 642         s->matrix_out_ch[mat] = get_bits(gbp, 4);
 643         frac_bits             = get_bits(gbp, 4);
 644         s->lsb_bypass   [mat] = get_bits1(gbp);
 645
 646         if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
 647             av_log(m->avctx, AV_LOG_ERROR,
 648                     "Invalid channel %d specified as output from matrix.\n",
 649                     s->matrix_out_ch[mat]);
 650             return AVERROR_INVALIDDATA;
 651         }
 652         if (frac_bits > 14) {
 653             av_log(m->avctx, AV_LOG_ERROR,
 654                     "Too many fractional bits specified.\n");
 655             return AVERROR_INVALIDDATA;
 656         }
 657
 658         max_chan = s->max_matrix_channel;
 659         if (!s->noise_type)
 660             max_chan+=2;
 661
 662         for (ch = 0; ch <= max_chan; ch++) {
 663             int coeff_val = 0;
 664             if (get_bits1(gbp))
 665                 coeff_val = get_sbits(gbp, frac_bits + 2);
 666
 667             s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
 668         }
 669
 670         if (s->noise_type)
 671             s->matrix_noise_shift[mat] = get_bits(gbp, 4);
 672         else
 673             s->matrix_noise_shift[mat] = 0;
 674     }
 675
 676     return 0;
 677 }
 678
 679 /** Read channel parameters. */
 680
 681 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
 682                                GetBitContext *gbp, unsigned int ch)
 683 {
 684     SubStream *s = &m->substream[substr];
 685     ChannelParams *cp = &s->channel_params[ch];
 686     FilterParams *fir = &cp->filter_params[FIR];
 687     FilterParams *iir = &cp->filter_params[IIR];
 688     int ret;
 689
 690     if (s->param_presence_flags & PARAM_FIR)
 691         if (get_bits1(gbp))
 692             if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
 693                 return ret;
 694
 695     if (s->param_presence_flags & PARAM_IIR)
 696         if (get_bits1(gbp))
 697             if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
 698                 return ret;
 699
 700     if (fir->order + iir->order > 8) {
 701         av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
 702         return AVERROR_INVALIDDATA;
 703     }
 704
 705     if (fir->order && iir->order &&
 706         fir->shift != iir->shift) {
 707         av_log(m->avctx, AV_LOG_ERROR,
 708                 "FIR and IIR filters must use the same precision.\n");
 709         return AVERROR_INVALIDDATA;
 710     }
 711     /* The FIR and IIR filters must have the same precision.
 712      * To simplify the filtering code, only the precision of the
 713      * FIR filter is considered. If only the IIR filter is employed,
 714      * the FIR filter precision is set to that of the IIR filter, so
 715      * that the filtering code can use it. */
 716     if (!fir->order && iir->order)
 717         fir->shift = iir->shift;
 718
 719     if (s->param_presence_flags & PARAM_HUFFOFFSET)
 720         if (get_bits1(gbp))
 721             cp->huff_offset = get_sbits(gbp, 15);
 722
 723     cp->codebook  = get_bits(gbp, 2);
 724     cp->huff_lsbs = get_bits(gbp, 5);
 725
 726     if (cp->huff_lsbs > 24) {
 727         av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
 728         return AVERROR_INVALIDDATA;
 729     }
 730
 731     cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
 732
 733     return 0;
 734 }
 735
 736 /** Read decoding parameters that change more often than those in the restart
 737  *  header. */
 738
 739 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
 740                                 unsigned int substr)
 741 {
 742     SubStream *s = &m->substream[substr];
 743     unsigned int ch;
 744     int ret;
 745
 746     if (s->param_presence_flags & PARAM_PRESENCE)
 747         if (get_bits1(gbp))
 748             s->param_presence_flags = get_bits(gbp, 8);
 749
 750     if (s->param_presence_flags & PARAM_BLOCKSIZE)
 751         if (get_bits1(gbp)) {
 752             s->blocksize = get_bits(gbp, 9);
 753             if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
 754                 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
 755                 s->blocksize = 0;
 756                 return AVERROR_INVALIDDATA;
 757             }
 758         }
 759
 760     if (s->param_presence_flags & PARAM_MATRIX)
 761         if (get_bits1(gbp))
 762             if ((ret = read_matrix_params(m, substr, gbp)) < 0)
 763                 return ret;
 764
 765     if (s->param_presence_flags & PARAM_OUTSHIFT)
 766         if (get_bits1(gbp))
 767             for (ch = 0; ch <= s->max_matrix_channel; ch++)
 768                 s->output_shift[ch] = get_sbits(gbp, 4);
 769
 770     if (s->param_presence_flags & PARAM_QUANTSTEP)
 771         if (get_bits1(gbp))
 772             for (ch = 0; ch <= s->max_channel; ch++) {
 773                 ChannelParams *cp = &s->channel_params[ch];
 774
 775                 s->quant_step_size[ch] = get_bits(gbp, 4);
 776
 777                 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
 778             }
 779
 780     for (ch = s->min_channel; ch <= s->max_channel; ch++)
 781         if (get_bits1(gbp))
 782             if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
 783                 return ret;
 784
 785     return 0;
 786 }
 787
 788 #define MSB_MASK(bits)  (-1u << bits)
 789
 790 /** Generate PCM samples using the prediction filters and residual values
 791  *  read from the data stream, and update the filter state. */
 792
 793 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
 794                            unsigned int channel)
 795 {
 796     SubStream *s = &m->substream[substr];
 797     const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
 798     int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
 799     int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
 800     int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
 801     FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
 802     FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
 803     unsigned int filter_shift = fir->shift;
 804     int32_t mask = MSB_MASK(s->quant_step_size[channel]);
 805
 806     memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
 807     memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
 808
 809     m->dsp.mlp_filter_channel(firbuf, fircoeff,
 810                               fir->order, iir->order,
 811                               filter_shift, mask, s->blocksize,
 812                               &m->sample_buffer[s->blockpos][channel]);
 813
 814     memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
 815     memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
 816 }
 817
 818 /** Read a block of PCM residual data (or actual if no filtering active). */
 819
 820 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
 821                            unsigned int substr)
 822 {
 823     SubStream *s = &m->substream[substr];
 824     unsigned int i, ch, expected_stream_pos = 0;
 825     int ret;
 826
 827     if (s->data_check_present) {
 828         expected_stream_pos  = get_bits_count(gbp);
 829         expected_stream_pos += get_bits(gbp, 16);
 830         av_log_ask_for_sample(m->avctx, "This file contains some features "
 831                               "we have not tested yet.\n");
 832     }
 833
 834     if (s->blockpos + s->blocksize > m->access_unit_size) {
 835         av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
 836         return AVERROR_INVALIDDATA;
 837     }
 838
 839     memset(&m->bypassed_lsbs[s->blockpos][0], 0,
 840            s->blocksize * sizeof(m->bypassed_lsbs[0]));
 841
 842     for (i = 0; i < s->blocksize; i++)
 843         if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
 844             return ret;
 845
 846     for (ch = s->min_channel; ch <= s->max_channel; ch++)
 847         filter_channel(m, substr, ch);
 848
 849     s->blockpos += s->blocksize;
 850
 851     if (s->data_check_present) {
 852         if (get_bits_count(gbp) != expected_stream_pos)
 853             av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
 854         skip_bits(gbp, 8);
 855     }
 856
 857     return 0;
 858 }
 859
 860 /** Data table used for TrueHD noise generation function. */
 861
 862 static const int8_t noise_table[256] = {
 863      30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
 864      52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
 865      10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
 866      51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
 867      38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
 868      61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
 869      67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
 870      48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
 871       0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
 872      16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
 873      13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
 874      89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
 875      36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
 876      39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
 877      45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
 878     -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
 879 };
 880
 881 /** Noise generation functions.
 882  *  I'm not sure what these are for - they seem to be some kind of pseudorandom
 883  *  sequence generators, used to generate noise data which is used when the
 884  *  channels are rematrixed. I'm not sure if they provide a practical benefit
 885  *  to compression, or just obfuscate the decoder. Are they for some kind of
 886  *  dithering? */
 887
 888 /** Generate two channels of noise, used in the matrix when
 889  *  restart sync word == 0x31ea. */
 890
 891 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
 892 {
 893     SubStream *s = &m->substream[substr];
 894     unsigned int i;
 895     uint32_t seed = s->noisegen_seed;
 896     unsigned int maxchan = s->max_matrix_channel;
 897
 898     for (i = 0; i < s->blockpos; i++) {
 899         uint16_t seed_shr7 = seed >> 7;
 900         m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
 901         m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
 902
 903         seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
 904     }
 905
 906     s->noisegen_seed = seed;
 907 }
 908
 909 /** Generate a block of noise, used when restart sync word == 0x31eb. */
 910
 911 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
 912 {
 913     SubStream *s = &m->substream[substr];
 914     unsigned int i;
 915     uint32_t seed = s->noisegen_seed;
 916
 917     for (i = 0; i < m->access_unit_size_pow2; i++) {
 918         uint8_t seed_shr15 = seed >> 15;
 919         m->noise_buffer[i] = noise_table[seed_shr15];
 920         seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
 921     }
 922
 923     s->noisegen_seed = seed;
 924 }
 925
 926
 927 /** Apply the channel matrices in turn to reconstruct the original audio
 928  *  samples. */
 929
 930 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
 931 {
 932     SubStream *s = &m->substream[substr];
 933     unsigned int mat, src_ch, i;
 934     unsigned int maxchan;
 935
 936     maxchan = s->max_matrix_channel;
 937     if (!s->noise_type) {
 938         generate_2_noise_channels(m, substr);
 939         maxchan += 2;
 940     } else {
 941         fill_noise_buffer(m, substr);
 942     }
 943
 944     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
 945         int matrix_noise_shift = s->matrix_noise_shift[mat];
 946         unsigned int dest_ch = s->matrix_out_ch[mat];
 947         int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
 948         int32_t *coeffs = s->matrix_coeff[mat];
 949         int index  = s->num_primitive_matrices - mat;
 950         int index2 = 2 * index + 1;
 951
 952         /* TODO: DSPContext? */
 953
 954         for (i = 0; i < s->blockpos; i++) {
 955             int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
 956             int32_t *samples = m->sample_buffer[i];
 957             int64_t accum = 0;
 958
 959             for (src_ch = 0; src_ch <= maxchan; src_ch++)
 960                 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
 961
 962             if (matrix_noise_shift) {
 963                 index &= m->access_unit_size_pow2 - 1;
 964                 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
 965                 index += index2;
 966             }
 967
 968             samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
 969         }
 970     }
 971 }
 972
 973 /** Write the audio data into the output buffer. */
 974
 975 static int output_data(MLPDecodeContext *m, unsigned int substr,
 976                        void *data, int *got_frame_ptr)
 977 {
 978     AVCodecContext *avctx = m->avctx;
 979     SubStream *s = &m->substream[substr];
 980     unsigned int i, out_ch = 0;
 981     int32_t *data_32;
 982     int16_t *data_16;
 983     int ret;
 984     int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
 985
 986     if (m->avctx->channels != s->max_matrix_channel + 1) {
 987         av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
 988         return AVERROR_INVALIDDATA;
 989     }
 990
 991     /* get output buffer */
 992     m->frame.nb_samples = s->blockpos;
 993     if ((ret = ff_get_buffer(avctx, &m->frame)) < 0) {
 994         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 995         return ret;
 996     }
 997     data_32 = (int32_t *)m->frame.data[0];
 998     data_16 = (int16_t *)m->frame.data[0];
 999
1000     for (i = 0; i < s->blockpos; i++) {
1001         for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
1002             int mat_ch = s->ch_assign[out_ch];
1003             int32_t sample = m->sample_buffer[i][mat_ch]
1004                           << s->output_shift[mat_ch];
1005             s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
1006             if (is32) *data_32++ = sample << 8;
1007             else      *data_16++ = sample >> 8;
1008         }
1009     }
1010
1011     *got_frame_ptr   = 1;
1012     *(AVFrame *)data = m->frame;
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 */