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