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