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