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