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