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