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