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     return 0;
 340 }
 341
 342 /** Read a major sync info header - contains high level information about
 343  *  the stream - sample rate, channel arrangement etc. Most of this
 344  *  information is not actually necessary for decoding, only for playback.
 345  */
 346
 347 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
 348 {
 349     MLPHeaderInfo mh;
 350     int substr;
 351
 352     if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
 353         return -1;
 354
 355     if (mh.group1_bits == 0) {
 356         av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
 357         return -1;
 358     }
 359     if (mh.group2_bits > mh.group1_bits) {
 360         av_log(m->avctx, AV_LOG_ERROR,
 361                "Channel group 2 cannot have more bits per sample than group 1.\n");
 362         return -1;
 363     }
 364
 365     if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
 366         av_log(m->avctx, AV_LOG_ERROR,
 367                "Channel groups with differing sample rates are not currently supported.\n");
 368         return -1;
 369     }
 370
 371     if (mh.group1_samplerate == 0) {
 372         av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
 373         return -1;
 374     }
 375     if (mh.group1_samplerate > MAX_SAMPLERATE) {
 376         av_log(m->avctx, AV_LOG_ERROR,
 377                "Sampling rate %d is greater than the supported maximum (%d).\n",
 378                mh.group1_samplerate, MAX_SAMPLERATE);
 379         return -1;
 380     }
 381     if (mh.access_unit_size > MAX_BLOCKSIZE) {
 382         av_log(m->avctx, AV_LOG_ERROR,
 383                "Block size %d is greater than the supported maximum (%d).\n",
 384                mh.access_unit_size, MAX_BLOCKSIZE);
 385         return -1;
 386     }
 387     if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
 388         av_log(m->avctx, AV_LOG_ERROR,
 389                "Block size pow2 %d is greater than the supported maximum (%d).\n",
 390                mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
 391         return -1;
 392     }
 393
 394     if (mh.num_substreams == 0)
 395         return -1;
 396     if (mh.num_substreams > MAX_SUBSTREAMS) {
 397         av_log(m->avctx, AV_LOG_ERROR,
 398                "Number of substreams %d is larger than the maximum supported "
 399                "by the decoder. %s\n", mh.num_substreams, sample_message);
 400         return -1;
 401     }
 402
 403     m->access_unit_size      = mh.access_unit_size;
 404     m->access_unit_size_pow2 = mh.access_unit_size_pow2;
 405
 406     m->num_substreams        = mh.num_substreams;
 407     m->max_decoded_substream = m->num_substreams - 1;
 408
 409     m->avctx->sample_rate    = mh.group1_samplerate;
 410     m->avctx->frame_size     = mh.access_unit_size;
 411
 412 #ifdef CONFIG_AUDIO_NONSHORT
 413     m->avctx->bits_per_sample = mh.group1_bits;
 414     if (mh.group1_bits > 16) {
 415         m->avctx->sample_fmt = SAMPLE_FMT_S32;
 416     }
 417 #endif
 418
 419     m->params_valid = 1;
 420     for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
 421         m->substream[substr].restart_seen = 0;
 422
 423     return 0;
 424 }
 425
 426 /** Read a restart header from a block in a substream. This contains parameters
 427  *  required to decode the audio that do not change very often. Generally
 428  *  (always) present only in blocks following a major sync. */
 429
 430 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
 431                                const uint8_t *buf, unsigned int substr)
 432 {
 433     SubStream *s = &m->substream[substr];
 434     unsigned int ch;
 435     int sync_word, tmp;
 436     uint8_t checksum;
 437     uint8_t lossless_check;
 438     int start_count = get_bits_count(gbp);
 439
 440     sync_word = get_bits(gbp, 13);
 441
 442     if (sync_word != 0x31ea >> 1) {
 443         av_log(m->avctx, AV_LOG_ERROR,
 444                "restart header sync incorrect (got 0x%04x)\n", sync_word);
 445         return -1;
 446     }
 447     s->noise_type = get_bits1(gbp);
 448
 449     skip_bits(gbp, 16); /* Output timestamp */
 450
 451     s->min_channel        = get_bits(gbp, 4);
 452     s->max_channel        = get_bits(gbp, 4);
 453     s->max_matrix_channel = get_bits(gbp, 4);
 454
 455     if (s->min_channel > s->max_channel) {
 456         av_log(m->avctx, AV_LOG_ERROR,
 457                "Substream min channel cannot be greater than max channel.\n");
 458         return -1;
 459     }
 460
 461     if (m->avctx->request_channels > 0
 462         && s->max_channel + 1 >= m->avctx->request_channels
 463         && substr < m->max_decoded_substream) {
 464         av_log(m->avctx, AV_LOG_INFO,
 465                "Extracting %d channel downmix from substream %d. "
 466                "Further substreams will be skipped.\n",
 467                s->max_channel + 1, substr);
 468         m->max_decoded_substream = substr;
 469     }
 470
 471     s->noise_shift   = get_bits(gbp,  4);
 472     s->noisegen_seed = get_bits(gbp, 23);
 473
 474     skip_bits(gbp, 19);
 475
 476     s->data_check_present = get_bits1(gbp);
 477     lossless_check = get_bits(gbp, 8);
 478     if (substr == m->max_decoded_substream
 479         && s->lossless_check_data != 0xffffffff) {
 480         tmp = s->lossless_check_data;
 481         tmp ^= tmp >> 16;
 482         tmp ^= tmp >> 8;
 483         tmp &= 0xff;
 484         if (tmp != lossless_check)
 485             av_log(m->avctx, AV_LOG_WARNING,
 486                    "Lossless check failed - expected %02x, calculated %02x.\n",
 487                    lossless_check, tmp);
 488         else
 489             dprintf(m->avctx, "Lossless check passed for substream %d (%x).\n",
 490                     substr, tmp);
 491     }
 492
 493     skip_bits(gbp, 16);
 494
 495     for (ch = 0; ch <= s->max_matrix_channel; ch++) {
 496         int ch_assign = get_bits(gbp, 6);
 497         dprintf(m->avctx, "ch_assign[%d][%d] = %d\n", substr, ch,
 498                 ch_assign);
 499         if (ch_assign != ch) {
 500             av_log(m->avctx, AV_LOG_ERROR,
 501                    "Non-1:1 channel assignments are used in this stream. %s\n",
 502                    sample_message);
 503             return -1;
 504         }
 505     }
 506
 507     checksum = mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
 508
 509     if (checksum != get_bits(gbp, 8))
 510         av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
 511
 512     /* Set default decoding parameters. */
 513     s->param_presence_flags   = 0xff;
 514     s->num_primitive_matrices = 0;
 515     s->blocksize              = 8;
 516     s->lossless_check_data    = 0;
 517
 518     memset(s->output_shift   , 0, sizeof(s->output_shift   ));
 519     memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
 520
 521     for (ch = s->min_channel; ch <= s->max_channel; ch++) {
 522         m->filter_order[ch][FIR] = 0;
 523         m->filter_order[ch][IIR] = 0;
 524         m->filter_shift[ch][FIR] = 0;
 525         m->filter_shift[ch][IIR] = 0;
 526
 527         /* Default audio coding is 24-bit raw PCM. */
 528         m->huff_offset     [ch] = 0;
 529         m->sign_huff_offset[ch] = (-1) << 23;
 530         m->codebook        [ch] = 0;
 531         m->huff_lsbs       [ch] = 24;
 532     }
 533
 534     if (substr == m->max_decoded_substream) {
 535         m->avctx->channels = s->max_channel + 1;
 536     }
 537
 538     return 0;
 539 }
 540
 541 /** Read parameters for one of the prediction filters. */
 542
 543 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
 544                               unsigned int channel, unsigned int filter)
 545 {
 546     const char fchar = filter ? 'I' : 'F';
 547     int i, order;
 548
 549     // Filter is 0 for FIR, 1 for IIR.
 550     assert(filter < 2);
 551
 552     order = get_bits(gbp, 4);
 553     if (order > MAX_FILTER_ORDER) {
 554         av_log(m->avctx, AV_LOG_ERROR,
 555                "%cIR filter order %d is greater than maximum %d.\n",
 556                fchar, order, MAX_FILTER_ORDER);
 557         return -1;
 558     }
 559     m->filter_order[channel][filter] = order;
 560
 561     if (order > 0) {
 562         int coeff_bits, coeff_shift;
 563
 564         m->filter_shift[channel][filter] = get_bits(gbp, 4);
 565
 566         coeff_bits  = get_bits(gbp, 5);
 567         coeff_shift = get_bits(gbp, 3);
 568         if (coeff_bits < 1 || coeff_bits > 16) {
 569             av_log(m->avctx, AV_LOG_ERROR,
 570                    "%cIR filter coeff_bits must be between 1 and 16.\n",
 571                    fchar);
 572             return -1;
 573         }
 574         if (coeff_bits + coeff_shift > 16) {
 575             av_log(m->avctx, AV_LOG_ERROR,
 576                    "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
 577                    fchar);
 578             return -1;
 579         }
 580
 581         for (i = 0; i < order; i++)
 582             m->filter_coeff[channel][filter][i] =
 583                     get_sbits(gbp, coeff_bits) << coeff_shift;
 584
 585         if (get_bits1(gbp)) {
 586             int state_bits, state_shift;
 587
 588             if (filter == FIR) {
 589                 av_log(m->avctx, AV_LOG_ERROR,
 590                        "FIR filter has state data specified.\n");
 591                 return -1;
 592             }
 593
 594             state_bits  = get_bits(gbp, 4);
 595             state_shift = get_bits(gbp, 4);
 596
 597             /* TODO: Check validity of state data. */
 598
 599             for (i = 0; i < order; i++)
 600                 m->filter_state[channel][filter][i] =
 601                     get_sbits(gbp, state_bits) << state_shift;
 602         }
 603     }
 604
 605     return 0;
 606 }
 607
 608 /** Read decoding parameters that change more often than those in the restart
 609  *  header. */
 610
 611 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
 612                                 unsigned int substr)
 613 {
 614     SubStream *s = &m->substream[substr];
 615     unsigned int mat, ch;
 616
 617     if (get_bits1(gbp))
 618         s->param_presence_flags = get_bits(gbp, 8);
 619
 620     if (s->param_presence_flags & PARAM_BLOCKSIZE)
 621         if (get_bits1(gbp)) {
 622             s->blocksize = get_bits(gbp, 9);
 623             if (s->blocksize > MAX_BLOCKSIZE) {
 624                 av_log(m->avctx, AV_LOG_ERROR, "block size too large\n");
 625                 s->blocksize = 0;
 626                 return -1;
 627             }
 628         }
 629
 630     if (s->param_presence_flags & PARAM_MATRIX)
 631         if (get_bits1(gbp)) {
 632             s->num_primitive_matrices = get_bits(gbp, 4);
 633
 634             for (mat = 0; mat < s->num_primitive_matrices; mat++) {
 635                 int frac_bits, max_chan;
 636                 s->matrix_out_ch[mat] = get_bits(gbp, 4);
 637                 frac_bits             = get_bits(gbp, 4);
 638                 s->lsb_bypass   [mat] = get_bits1(gbp);
 639
 640                 if (s->matrix_out_ch[mat] > s->max_channel) {
 641                     av_log(m->avctx, AV_LOG_ERROR,
 642                            "Invalid channel %d specified as output from matrix.\n",
 643                            s->matrix_out_ch[mat]);
 644                     return -1;
 645                 }
 646                 if (frac_bits > 14) {
 647                     av_log(m->avctx, AV_LOG_ERROR,
 648                            "Too many fractional bits specified.\n");
 649                     return -1;
 650                 }
 651
 652                 max_chan = s->max_matrix_channel;
 653                 if (!s->noise_type)
 654                     max_chan+=2;
 655
 656                 for (ch = 0; ch <= max_chan; ch++) {
 657                     int coeff_val = 0;
 658                     if (get_bits1(gbp))
 659                         coeff_val = get_sbits(gbp, frac_bits + 2);
 660
 661                     s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
 662                 }
 663
 664                 if (s->noise_type)
 665                     s->matrix_noise_shift[mat] = get_bits(gbp, 4);
 666                 else
 667                     s->matrix_noise_shift[mat] = 0;
 668             }
 669         }
 670
 671     if (s->param_presence_flags & PARAM_OUTSHIFT)
 672         if (get_bits1(gbp))
 673             for (ch = 0; ch <= s->max_matrix_channel; ch++) {
 674                 s->output_shift[ch] = get_bits(gbp, 4);
 675                 dprintf(m->avctx, "output shift[%d] = %d\n",
 676                         ch, s->output_shift[ch]);
 677                 /* TODO: validate */
 678             }
 679
 680     if (s->param_presence_flags & PARAM_QUANTSTEP)
 681         if (get_bits1(gbp))
 682             for (ch = 0; ch <= s->max_channel; ch++) {
 683                 s->quant_step_size[ch] = get_bits(gbp, 4);
 684                 /* TODO: validate */
 685
 686                 m->sign_huff_offset[ch] = calculate_sign_huff(m, substr, ch);
 687             }
 688
 689     for (ch = s->min_channel; ch <= s->max_channel; ch++)
 690         if (get_bits1(gbp)) {
 691             if (s->param_presence_flags & PARAM_FIR)
 692                 if (get_bits1(gbp))
 693                     if (read_filter_params(m, gbp, ch, FIR) < 0)
 694                         return -1;
 695
 696             if (s->param_presence_flags & PARAM_IIR)
 697                 if (get_bits1(gbp))
 698                     if (read_filter_params(m, gbp, ch, IIR) < 0)
 699                         return -1;
 700
 701             if (m->filter_order[ch][FIR] && m->filter_order[ch][IIR] &&
 702                 m->filter_shift[ch][FIR] != m->filter_shift[ch][IIR]) {
 703                 av_log(m->avctx, AV_LOG_ERROR,
 704                        "FIR and IIR filters must use the same precision.\n");
 705                 return -1;
 706             }
 707             /* The FIR and IIR filters must have the same precision.
 708              * To simplify the filtering code, only the precision of the
 709              * FIR filter is considered. If only the IIR filter is employed,
 710              * the FIR filter precision is set to that of the IIR filter, so
 711              * that the filtering code can use it. */
 712             if (!m->filter_order[ch][FIR] && m->filter_order[ch][IIR])
 713                 m->filter_shift[ch][FIR] = m->filter_shift[ch][IIR];
 714
 715             if (s->param_presence_flags & PARAM_HUFFOFFSET)
 716                 if (get_bits1(gbp))
 717                     m->huff_offset[ch] = get_sbits(gbp, 15);
 718
 719             m->codebook [ch] = get_bits(gbp, 2);
 720             m->huff_lsbs[ch] = get_bits(gbp, 5);
 721
 722             m->sign_huff_offset[ch] = calculate_sign_huff(m, substr, ch);
 723
 724             /* TODO: validate */
 725         }
 726
 727     return 0;
 728 }
 729
 730 #define MSB_MASK(bits)  (-1u << bits)
 731
 732 /** Generate PCM samples using the prediction filters and residual values
 733  *  read from the data stream, and update the filter state. */
 734
 735 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
 736                            unsigned int channel)
 737 {
 738     SubStream *s = &m->substream[substr];
 739     int32_t filter_state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FILTER_ORDER];
 740     unsigned int filter_shift = m->filter_shift[channel][FIR];
 741     int32_t mask = MSB_MASK(s->quant_step_size[channel]);
 742     int index = MAX_BLOCKSIZE;
 743     int j, i;
 744
 745     for (j = 0; j < NUM_FILTERS; j++) {
 746         memcpy(&   filter_state_buffer  [j][MAX_BLOCKSIZE],
 747                &m->filter_state[channel][j][0],
 748                MAX_FILTER_ORDER * sizeof(int32_t));
 749     }
 750
 751     for (i = 0; i < s->blocksize; i++) {
 752         int32_t residual = m->sample_buffer[i + s->blockpos][channel];
 753         unsigned int order;
 754         int64_t accum = 0;
 755         int32_t result;
 756
 757         /* TODO: Move this code to DSPContext? */
 758
 759         for (j = 0; j < NUM_FILTERS; j++)
 760             for (order = 0; order < m->filter_order[channel][j]; order++)
 761                 accum += (int64_t)filter_state_buffer[j][index + order] *
 762                         m->filter_coeff[channel][j][order];
 763
 764         accum  = accum >> filter_shift;
 765         result = (accum + residual) & mask;
 766
 767         --index;
 768
 769         filter_state_buffer[FIR][index] = result;
 770         filter_state_buffer[IIR][index] = result - accum;
 771
 772         m->sample_buffer[i + s->blockpos][channel] = result;
 773     }
 774
 775     for (j = 0; j < NUM_FILTERS; j++) {
 776         memcpy(&m->filter_state[channel][j][0],
 777                &   filter_state_buffer  [j][index],
 778                MAX_FILTER_ORDER * sizeof(int32_t));
 779     }
 780 }
 781
 782 /** Read a block of PCM residual data (or actual if no filtering active). */
 783
 784 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
 785                            unsigned int substr)
 786 {
 787     SubStream *s = &m->substream[substr];
 788     unsigned int i, ch, expected_stream_pos = 0;
 789
 790     if (s->data_check_present) {
 791         expected_stream_pos  = get_bits_count(gbp);
 792         expected_stream_pos += get_bits(gbp, 16);
 793         av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
 794                "we have not tested yet. %s\n", sample_message);
 795     }
 796
 797     if (s->blockpos + s->blocksize > m->access_unit_size) {
 798         av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
 799         return -1;
 800     }
 801
 802     memset(&m->bypassed_lsbs[s->blockpos][0], 0,
 803            s->blocksize * sizeof(m->bypassed_lsbs[0]));
 804
 805     for (i = 0; i < s->blocksize; i++) {
 806         if (read_huff_channels(m, gbp, substr, i) < 0)
 807             return -1;
 808     }
 809
 810     for (ch = s->min_channel; ch <= s->max_channel; ch++) {
 811         filter_channel(m, substr, ch);
 812     }
 813
 814     s->blockpos += s->blocksize;
 815
 816     if (s->data_check_present) {
 817         if (get_bits_count(gbp) != expected_stream_pos)
 818             av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
 819         skip_bits(gbp, 8);
 820     }
 821
 822     return 0;
 823 }
 824
 825 /** Data table used for TrueHD noise generation function. */
 826
 827 static const int8_t noise_table[256] = {
 828      30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
 829      52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
 830      10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
 831      51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
 832      38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
 833      61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
 834      67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
 835      48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
 836       0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
 837      16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
 838      13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
 839      89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
 840      36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
 841      39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
 842      45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
 843     -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
 844 };
 845
 846 /** Noise generation functions.
 847  *  I'm not sure what these are for - they seem to be some kind of pseudorandom
 848  *  sequence generators, used to generate noise data which is used when the
 849  *  channels are rematrixed. I'm not sure if they provide a practical benefit
 850  *  to compression, or just obfuscate the decoder. Are they for some kind of
 851  *  dithering? */
 852
 853 /** Generate two channels of noise, used in the matrix when
 854  *  restart sync word == 0x31ea. */
 855
 856 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
 857 {
 858     SubStream *s = &m->substream[substr];
 859     unsigned int i;
 860     uint32_t seed = s->noisegen_seed;
 861     unsigned int maxchan = s->max_matrix_channel;
 862
 863     for (i = 0; i < s->blockpos; i++) {
 864         uint16_t seed_shr7 = seed >> 7;
 865         m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
 866         m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
 867
 868         seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
 869     }
 870
 871     s->noisegen_seed = seed;
 872 }
 873
 874 /** Generate a block of noise, used when restart sync word == 0x31eb. */
 875
 876 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
 877 {
 878     SubStream *s = &m->substream[substr];
 879     unsigned int i;
 880     uint32_t seed = s->noisegen_seed;
 881
 882     for (i = 0; i < m->access_unit_size_pow2; i++) {
 883         uint8_t seed_shr15 = seed >> 15;
 884         m->noise_buffer[i] = noise_table[seed_shr15];
 885         seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
 886     }
 887
 888     s->noisegen_seed = seed;
 889 }
 890
 891
 892 /** Apply the channel matrices in turn to reconstruct the original audio
 893  *  samples. */
 894
 895 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
 896 {
 897     SubStream *s = &m->substream[substr];
 898     unsigned int mat, src_ch, i;
 899     unsigned int maxchan;
 900
 901     maxchan = s->max_matrix_channel;
 902     if (!s->noise_type) {
 903         generate_2_noise_channels(m, substr);
 904         maxchan += 2;
 905     } else {
 906         fill_noise_buffer(m, substr);
 907     }
 908
 909     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
 910         int matrix_noise_shift = s->matrix_noise_shift[mat];
 911         unsigned int dest_ch = s->matrix_out_ch[mat];
 912         int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
 913
 914         /* TODO: DSPContext? */
 915
 916         for (i = 0; i < s->blockpos; i++) {
 917             int64_t accum = 0;
 918             for (src_ch = 0; src_ch <= maxchan; src_ch++) {
 919                 accum += (int64_t)m->sample_buffer[i][src_ch]
 920                                   * s->matrix_coeff[mat][src_ch];
 921             }
 922             if (matrix_noise_shift) {
 923                 uint32_t index = s->num_primitive_matrices - mat;
 924                 index = (i * (index * 2 + 1) + index) & (m->access_unit_size_pow2 - 1);
 925                 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
 926             }
 927             m->sample_buffer[i][dest_ch] = ((accum >> 14) & mask)
 928                                              + m->bypassed_lsbs[i][mat];
 929         }
 930     }
 931 }
 932
 933 /** Write the audio data into the output buffer. */
 934
 935 static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
 936                                 uint8_t *data, unsigned int *data_size, int is32)
 937 {
 938     SubStream *s = &m->substream[substr];
 939     unsigned int i, ch = 0;
 940     int32_t *data_32 = (int32_t*) data;
 941     int16_t *data_16 = (int16_t*) data;
 942
 943     if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
 944         return -1;
 945
 946     for (i = 0; i < s->blockpos; i++) {
 947         for (ch = 0; ch <= s->max_channel; ch++) {
 948             int32_t sample = m->sample_buffer[i][ch] << s->output_shift[ch];
 949             s->lossless_check_data ^= (sample & 0xffffff) << ch;
 950             if (is32) *data_32++ = sample << 8;
 951             else      *data_16++ = sample >> 8;
 952         }
 953     }
 954
 955     *data_size = i * ch * (is32 ? 4 : 2);
 956
 957     return 0;
 958 }
 959
 960 static int output_data(MLPDecodeContext *m, unsigned int substr,
 961                        uint8_t *data, unsigned int *data_size)
 962 {
 963     if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
 964         return output_data_internal(m, substr, data, data_size, 1);
 965     else
 966         return output_data_internal(m, substr, data, data_size, 0);
 967 }
 968
 969
 970 /** XOR together all the bytes of a buffer.
 971  *  Does this belong in dspcontext? */
 972
 973 static uint8_t calculate_parity(const uint8_t *buf, unsigned int buf_size)
 974 {
 975     uint32_t scratch = 0;
 976     const uint8_t *buf_end = buf + buf_size;
 977
 978     for (; buf < buf_end - 3; buf += 4)
 979         scratch ^= *((const uint32_t*)buf);
 980
 981     scratch ^= scratch >> 16;
 982     scratch ^= scratch >> 8;
 983
 984     for (; buf < buf_end; buf++)
 985         scratch ^= *buf;
 986
 987     return scratch;
 988 }
 989
 990 /** Read an access unit from the stream.
 991  *  Returns < 0 on error, 0 if not enough data is present in the input stream
 992  *  otherwise returns the number of bytes consumed. */
 993
 994 static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
 995                             const uint8_t *buf, int buf_size)
 996 {
 997     MLPDecodeContext *m = avctx->priv_data;
 998     GetBitContext gb;
 999     unsigned int length, substr;
1000     unsigned int substream_start;
1001     unsigned int header_size = 4;
1002     unsigned int substr_header_size = 0;
1003     uint8_t substream_parity_present[MAX_SUBSTREAMS];
1004     uint16_t substream_data_len[MAX_SUBSTREAMS];
1005     uint8_t parity_bits;
1006
1007     if (buf_size < 4)
1008         return 0;
1009
1010     length = (AV_RB16(buf) & 0xfff) * 2;
1011
1012     if (length > buf_size)
1013         return -1;
1014
1015     init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1016
1017     if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1018         dprintf(m->avctx, "Found major sync.\n");
1019         if (read_major_sync(m, &gb) < 0)
1020             goto error;
1021         header_size += 28;
1022     }
1023
1024     if (!m->params_valid) {
1025         av_log(m->avctx, AV_LOG_WARNING,
1026                "Stream parameters not seen; skipping frame.\n");
1027         *data_size = 0;
1028         return length;
1029     }
1030
1031     substream_start = 0;
1032
1033     for (substr = 0; substr < m->num_substreams; substr++) {
1034         int extraword_present, checkdata_present, end;
1035
1036         extraword_present = get_bits1(&gb);
1037         skip_bits1(&gb);
1038         checkdata_present = get_bits1(&gb);
1039         skip_bits1(&gb);
1040
1041         end = get_bits(&gb, 12) * 2;
1042
1043         substr_header_size += 2;
1044
1045         if (extraword_present) {
1046             skip_bits(&gb, 16);
1047             substr_header_size += 2;
1048         }
1049
1050         if (end + header_size + substr_header_size > length) {
1051             av_log(m->avctx, AV_LOG_ERROR,
1052                    "Indicated length of substream %d data goes off end of "
1053                    "packet.\n", substr);
1054             end = length - header_size - substr_header_size;
1055         }
1056
1057         if (end < substream_start) {
1058             av_log(avctx, AV_LOG_ERROR,
1059                    "Indicated end offset of substream %d data "
1060                    "is smaller than calculated start offset.\n",
1061                    substr);
1062             goto error;
1063         }
1064
1065         if (substr > m->max_decoded_substream)
1066             continue;
1067
1068         substream_parity_present[substr] = checkdata_present;
1069         substream_data_len[substr] = end - substream_start;
1070         substream_start = end;
1071     }
1072
1073     parity_bits  = calculate_parity(buf, 4);
1074     parity_bits ^= calculate_parity(buf + header_size, substr_header_size);
1075
1076     if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1077         av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1078         goto error;
1079     }
1080
1081     buf += header_size + substr_header_size;
1082
1083     for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1084         SubStream *s = &m->substream[substr];
1085         init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1086
1087         s->blockpos = 0;
1088         do {
1089             if (get_bits1(&gb)) {
1090                 if (get_bits1(&gb)) {
1091                     /* A restart header should be present. */
1092                     if (read_restart_header(m, &gb, buf, substr) < 0)
1093                         goto next_substr;
1094                     s->restart_seen = 1;
1095                 }
1096
1097                 if (!s->restart_seen) {
1098                     av_log(m->avctx, AV_LOG_ERROR,
1099                            "No restart header present in substream %d.\n",
1100                            substr);
1101                     goto next_substr;
1102                 }
1103
1104                 if (read_decoding_params(m, &gb, substr) < 0)
1105                     goto next_substr;
1106             }
1107
1108             if (!s->restart_seen) {
1109                 av_log(m->avctx, AV_LOG_ERROR,
1110                        "No restart header present in substream %d.\n",
1111                        substr);
1112                 goto next_substr;
1113             }
1114
1115             if (read_block_data(m, &gb, substr) < 0)
1116                 return -1;
1117
1118         } while ((get_bits_count(&gb) < substream_data_len[substr] * 8)
1119                  && get_bits1(&gb) == 0);
1120
1121         skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1122         if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32 &&
1123             (show_bits_long(&gb, 32) == 0xd234d234 ||
1124              show_bits_long(&gb, 20) == 0xd234e)) {
1125             skip_bits(&gb, 18);
1126             if (substr == m->max_decoded_substream)
1127                 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1128
1129             if (get_bits1(&gb)) {
1130                 int shorten_by = get_bits(&gb, 13);
1131                 shorten_by = FFMIN(shorten_by, s->blockpos);
1132                 s->blockpos -= shorten_by;
1133             } else
1134                 skip_bits(&gb, 13);
1135         }
1136         if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 16 &&
1137             substream_parity_present[substr]) {
1138             uint8_t parity, checksum;
1139
1140             parity = calculate_parity(buf, substream_data_len[substr] - 2);
1141             if ((parity ^ get_bits(&gb, 8)) != 0xa9)
1142                 av_log(m->avctx, AV_LOG_ERROR,
1143                        "Substream %d parity check failed.\n", substr);
1144
1145             checksum = mlp_checksum8(buf, substream_data_len[substr] - 2);
1146             if (checksum != get_bits(&gb, 8))
1147                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n",
1148                        substr);
1149         }
1150         if (substream_data_len[substr] * 8 != get_bits_count(&gb)) {
1151             av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n",
1152                    substr);
1153             return -1;
1154         }
1155
1156 next_substr:
1157         buf += substream_data_len[substr];
1158     }
1159
1160     rematrix_channels(m, m->max_decoded_substream);
1161
1162     if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1163         return -1;
1164
1165     return length;
1166
1167 error:
1168     m->params_valid = 0;
1169     return -1;
1170 }
1171
1172 AVCodec mlp_decoder = {
1173     "mlp",
1174     CODEC_TYPE_AUDIO,
1175     CODEC_ID_MLP,
1176     sizeof(MLPDecodeContext),
1177     mlp_decode_init,
1178     NULL,
1179     NULL,
1180     read_access_unit,
1181     .long_name = NULL_IF_CONFIG_SMALL("Meridian Lossless Packing"),
1182 };
1183