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