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

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