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