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