git.sesse.net Git - ffmpeg/blob - libavcodec/mlpdec.c

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