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