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