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