git.sesse.net Git - ffmpeg/blob - libavcodec/mlpdec.c

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