git.sesse.net Git - ffmpeg/blob - libavcodec/mlpdec.c

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