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