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