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