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