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