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