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
  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     ChannelParams channel_params[MAX_CHANNELS];
  66
  67     //! The left shift applied to random noise in 0x31ea substreams.
  68     uint8_t     noise_shift;
  69     //! The current seed value for the pseudorandom noise generator(s).
  70     uint32_t    noisegen_seed;
  71
  72     //! Set if the substream contains extra info to check the size of VLC blocks.
  73     uint8_t     data_check_present;
  74
  75     //! Bitmask of which parameter sets are conveyed in a decoding parameter block.
  76     uint8_t     param_presence_flags;
  77 #define PARAM_BLOCKSIZE     (1 << 7)
  78 #define PARAM_MATRIX        (1 << 6)
  79 #define PARAM_OUTSHIFT      (1 << 5)
  80 #define PARAM_QUANTSTEP     (1 << 4)
  81 #define PARAM_FIR           (1 << 3)
  82 #define PARAM_IIR           (1 << 2)
  83 #define PARAM_HUFFOFFSET    (1 << 1)
  84 #define PARAM_PRESENCE      (1 << 0)
  85     //@}
  86
  87     //@{
  88     /** matrix data */
  89
  90     //! Number of matrices to be applied.
  91     uint8_t     num_primitive_matrices;
  92
  93     //! matrix output channel
  94     uint8_t     matrix_out_ch[MAX_MATRICES];
  95
  96     //! Whether the LSBs of the matrix output are encoded in the bitstream.
  97     uint8_t     lsb_bypass[MAX_MATRICES];
  98     //! Matrix coefficients, stored as 2.14 fixed point.
  99     int32_t     matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
 100     //! Left shift to apply to noise values in 0x31eb substreams.
 101     uint8_t     matrix_noise_shift[MAX_MATRICES];
 102     //@}
 103
 104     //! Left shift to apply to Huffman-decoded residuals.
 105     uint8_t     quant_step_size[MAX_CHANNELS];
 106
 107     //! number of PCM samples in current audio block
 108     uint16_t    blocksize;
 109     //! Number of PCM samples decoded so far in this frame.
 110     uint16_t    blockpos;
 111
 112     //! Left shift to apply to decoded PCM values to get final 24-bit output.
 113     int8_t      output_shift[MAX_CHANNELS];
 114
 115     //! Running XOR of all output samples.
 116     int32_t     lossless_check_data;
 117
 118 } SubStream;
 119
 120 typedef struct MLPDecodeContext {
 121     AVCodecContext *avctx;
 122
 123     //! Current access unit being read has a major sync.
 124     int         is_major_sync_unit;
 125
 126     //! Set if a valid major sync block has been read. Otherwise no decoding is possible.
 127     uint8_t     params_valid;
 128
 129     //! Number of substreams contained within this stream.
 130     uint8_t     num_substreams;
 131
 132     //! Index of the last substream to decode - further substreams are skipped.
 133     uint8_t     max_decoded_substream;
 134
 135     //! number of PCM samples contained in each frame
 136     int         access_unit_size;
 137     //! next power of two above the number of samples in each frame
 138     int         access_unit_size_pow2;
 139
 140     SubStream   substream[MAX_SUBSTREAMS];
 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     SubStream *s = &m->substream[substr];
 177     ChannelParams *cp = &s->channel_params[ch];
 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 = &s->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 = &s->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 substr, unsigned int channel,
 476                               unsigned int filter)
 477 {
 478     SubStream *s = &m->substream[substr];
 479     FilterParams *fp = &s->channel_params[channel].filter_params[filter];
 480     const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
 481     const char fchar = filter ? 'I' : 'F';
 482     int i, order;
 483
 484     // Filter is 0 for FIR, 1 for IIR.
 485     assert(filter < 2);
 486
 487     if (m->filter_changed[channel][filter]++ > 1) {
 488         av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
 489         return -1;
 490     }
 491
 492     order = get_bits(gbp, 4);
 493     if (order > max_order) {
 494         av_log(m->avctx, AV_LOG_ERROR,
 495                "%cIR filter order %d is greater than maximum %d.\n",
 496                fchar, order, max_order);
 497         return -1;
 498     }
 499     fp->order = order;
 500
 501     if (order > 0) {
 502         int32_t *fcoeff = s->channel_params[channel].coeff[filter];
 503         int coeff_bits, coeff_shift;
 504
 505         fp->shift = get_bits(gbp, 4);
 506
 507         coeff_bits  = get_bits(gbp, 5);
 508         coeff_shift = get_bits(gbp, 3);
 509         if (coeff_bits < 1 || coeff_bits > 16) {
 510             av_log(m->avctx, AV_LOG_ERROR,
 511                    "%cIR filter coeff_bits must be between 1 and 16.\n",
 512                    fchar);
 513             return -1;
 514         }
 515         if (coeff_bits + coeff_shift > 16) {
 516             av_log(m->avctx, AV_LOG_ERROR,
 517                    "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
 518                    fchar);
 519             return -1;
 520         }
 521
 522         for (i = 0; i < order; i++)
 523             fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
 524
 525         if (get_bits1(gbp)) {
 526             int state_bits, state_shift;
 527
 528             if (filter == FIR) {
 529                 av_log(m->avctx, AV_LOG_ERROR,
 530                        "FIR filter has state data specified.\n");
 531                 return -1;
 532             }
 533
 534             state_bits  = get_bits(gbp, 4);
 535             state_shift = get_bits(gbp, 4);
 536
 537             /* TODO: Check validity of state data. */
 538
 539             for (i = 0; i < order; i++)
 540                 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
 541         }
 542     }
 543
 544     return 0;
 545 }
 546
 547 /** Read parameters for primitive matrices. */
 548
 549 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
 550 {
 551     SubStream *s = &m->substream[substr];
 552     unsigned int mat, ch;
 553     const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
 554                                      ? MAX_MATRICES_MLP
 555                                      : MAX_MATRICES_TRUEHD;
 556
 557     if (m->matrix_changed++ > 1) {
 558         av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
 559         return -1;
 560     }
 561
 562     s->num_primitive_matrices = get_bits(gbp, 4);
 563
 564     if (s->num_primitive_matrices > max_primitive_matrices) {
 565         av_log(m->avctx, AV_LOG_ERROR,
 566                "Number of primitive matrices cannot be greater than %d.\n",
 567                max_primitive_matrices);
 568         return -1;
 569     }
 570
 571     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
 572         int frac_bits, max_chan;
 573         s->matrix_out_ch[mat] = get_bits(gbp, 4);
 574         frac_bits             = get_bits(gbp, 4);
 575         s->lsb_bypass   [mat] = get_bits1(gbp);
 576
 577         if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
 578             av_log(m->avctx, AV_LOG_ERROR,
 579                     "Invalid channel %d specified as output from matrix.\n",
 580                     s->matrix_out_ch[mat]);
 581             return -1;
 582         }
 583         if (frac_bits > 14) {
 584             av_log(m->avctx, AV_LOG_ERROR,
 585                     "Too many fractional bits specified.\n");
 586             return -1;
 587         }
 588
 589         max_chan = s->max_matrix_channel;
 590         if (!s->noise_type)
 591             max_chan+=2;
 592
 593         for (ch = 0; ch <= max_chan; ch++) {
 594             int coeff_val = 0;
 595             if (get_bits1(gbp))
 596                 coeff_val = get_sbits(gbp, frac_bits + 2);
 597
 598             s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
 599         }
 600
 601         if (s->noise_type)
 602             s->matrix_noise_shift[mat] = get_bits(gbp, 4);
 603         else
 604             s->matrix_noise_shift[mat] = 0;
 605     }
 606
 607     return 0;
 608 }
 609
 610 /** Read channel parameters. */
 611
 612 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
 613                                GetBitContext *gbp, unsigned int ch)
 614 {
 615     SubStream *s = &m->substream[substr];
 616     ChannelParams *cp = &s->channel_params[ch];
 617     FilterParams *fir = &cp->filter_params[FIR];
 618     FilterParams *iir = &cp->filter_params[IIR];
 619
 620     if (s->param_presence_flags & PARAM_FIR)
 621         if (get_bits1(gbp))
 622             if (read_filter_params(m, gbp, substr, ch, FIR) < 0)
 623                 return -1;
 624
 625     if (s->param_presence_flags & PARAM_IIR)
 626         if (get_bits1(gbp))
 627             if (read_filter_params(m, gbp, substr, ch, IIR) < 0)
 628                 return -1;
 629
 630     if (fir->order + iir->order > 8) {
 631         av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
 632         return -1;
 633     }
 634
 635     if (fir->order && iir->order &&
 636         fir->shift != iir->shift) {
 637         av_log(m->avctx, AV_LOG_ERROR,
 638                 "FIR and IIR filters must use the same precision.\n");
 639         return -1;
 640     }
 641     /* The FIR and IIR filters must have the same precision.
 642      * To simplify the filtering code, only the precision of the
 643      * FIR filter is considered. If only the IIR filter is employed,
 644      * the FIR filter precision is set to that of the IIR filter, so
 645      * that the filtering code can use it. */
 646     if (!fir->order && iir->order)
 647         fir->shift = iir->shift;
 648
 649     if (s->param_presence_flags & PARAM_HUFFOFFSET)
 650         if (get_bits1(gbp))
 651             cp->huff_offset = get_sbits(gbp, 15);
 652
 653     cp->codebook  = get_bits(gbp, 2);
 654     cp->huff_lsbs = get_bits(gbp, 5);
 655
 656     if (cp->huff_lsbs > 24) {
 657         av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
 658         return -1;
 659     }
 660
 661     cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
 662
 663     return 0;
 664 }
 665
 666 /** Read decoding parameters that change more often than those in the restart
 667  *  header. */
 668
 669 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
 670                                 unsigned int substr)
 671 {
 672     SubStream *s = &m->substream[substr];
 673     unsigned int ch;
 674
 675     if (s->param_presence_flags & PARAM_PRESENCE)
 676         if (get_bits1(gbp))
 677             s->param_presence_flags = get_bits(gbp, 8);
 678
 679     if (s->param_presence_flags & PARAM_BLOCKSIZE)
 680         if (get_bits1(gbp)) {
 681             s->blocksize = get_bits(gbp, 9);
 682             if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
 683                 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
 684                 s->blocksize = 0;
 685                 return -1;
 686             }
 687         }
 688
 689     if (s->param_presence_flags & PARAM_MATRIX)
 690         if (get_bits1(gbp))
 691             if (read_matrix_params(m, substr, gbp) < 0)
 692                 return -1;
 693
 694     if (s->param_presence_flags & PARAM_OUTSHIFT)
 695         if (get_bits1(gbp))
 696             for (ch = 0; ch <= s->max_matrix_channel; ch++)
 697                 s->output_shift[ch] = get_sbits(gbp, 4);
 698
 699     if (s->param_presence_flags & PARAM_QUANTSTEP)
 700         if (get_bits1(gbp))
 701             for (ch = 0; ch <= s->max_channel; ch++) {
 702                 ChannelParams *cp = &s->channel_params[ch];
 703
 704                 s->quant_step_size[ch] = get_bits(gbp, 4);
 705
 706                 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
 707             }
 708
 709     for (ch = s->min_channel; ch <= s->max_channel; ch++)
 710         if (get_bits1(gbp))
 711             if (read_channel_params(m, substr, gbp, ch) < 0)
 712                 return -1;
 713
 714     return 0;
 715 }
 716
 717 #define MSB_MASK(bits)  (-1u << bits)
 718
 719 /** Generate PCM samples using the prediction filters and residual values
 720  *  read from the data stream, and update the filter state. */
 721
 722 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
 723                            unsigned int channel)
 724 {
 725     SubStream *s = &m->substream[substr];
 726     const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
 727     int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
 728     int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
 729     int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
 730     FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
 731     FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
 732     unsigned int filter_shift = fir->shift;
 733     int32_t mask = MSB_MASK(s->quant_step_size[channel]);
 734
 735     memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
 736     memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
 737
 738     m->dsp.mlp_filter_channel(firbuf, fircoeff,
 739                               fir->order, iir->order,
 740                               filter_shift, mask, s->blocksize,
 741                               &m->sample_buffer[s->blockpos][channel]);
 742
 743     memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
 744     memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
 745 }
 746
 747 /** Read a block of PCM residual data (or actual if no filtering active). */
 748
 749 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
 750                            unsigned int substr)
 751 {
 752     SubStream *s = &m->substream[substr];
 753     unsigned int i, ch, expected_stream_pos = 0;
 754
 755     if (s->data_check_present) {
 756         expected_stream_pos  = get_bits_count(gbp);
 757         expected_stream_pos += get_bits(gbp, 16);
 758         av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
 759                "we have not tested yet. %s\n", sample_message);
 760     }
 761
 762     if (s->blockpos + s->blocksize > m->access_unit_size) {
 763         av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
 764         return -1;
 765     }
 766
 767     memset(&m->bypassed_lsbs[s->blockpos][0], 0,
 768            s->blocksize * sizeof(m->bypassed_lsbs[0]));
 769
 770     for (i = 0; i < s->blocksize; i++)
 771         if (read_huff_channels(m, gbp, substr, i) < 0)
 772             return -1;
 773
 774     for (ch = s->min_channel; ch <= s->max_channel; ch++)
 775         filter_channel(m, substr, ch);
 776
 777     s->blockpos += s->blocksize;
 778
 779     if (s->data_check_present) {
 780         if (get_bits_count(gbp) != expected_stream_pos)
 781             av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
 782         skip_bits(gbp, 8);
 783     }
 784
 785     return 0;
 786 }
 787
 788 /** Data table used for TrueHD noise generation function. */
 789
 790 static const int8_t noise_table[256] = {
 791      30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
 792      52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
 793      10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
 794      51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
 795      38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
 796      61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
 797      67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
 798      48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
 799       0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
 800      16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
 801      13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
 802      89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
 803      36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
 804      39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
 805      45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
 806     -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
 807 };
 808
 809 /** Noise generation functions.
 810  *  I'm not sure what these are for - they seem to be some kind of pseudorandom
 811  *  sequence generators, used to generate noise data which is used when the
 812  *  channels are rematrixed. I'm not sure if they provide a practical benefit
 813  *  to compression, or just obfuscate the decoder. Are they for some kind of
 814  *  dithering? */
 815
 816 /** Generate two channels of noise, used in the matrix when
 817  *  restart sync word == 0x31ea. */
 818
 819 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
 820 {
 821     SubStream *s = &m->substream[substr];
 822     unsigned int i;
 823     uint32_t seed = s->noisegen_seed;
 824     unsigned int maxchan = s->max_matrix_channel;
 825
 826     for (i = 0; i < s->blockpos; i++) {
 827         uint16_t seed_shr7 = seed >> 7;
 828         m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
 829         m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
 830
 831         seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
 832     }
 833
 834     s->noisegen_seed = seed;
 835 }
 836
 837 /** Generate a block of noise, used when restart sync word == 0x31eb. */
 838
 839 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
 840 {
 841     SubStream *s = &m->substream[substr];
 842     unsigned int i;
 843     uint32_t seed = s->noisegen_seed;
 844
 845     for (i = 0; i < m->access_unit_size_pow2; i++) {
 846         uint8_t seed_shr15 = seed >> 15;
 847         m->noise_buffer[i] = noise_table[seed_shr15];
 848         seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
 849     }
 850
 851     s->noisegen_seed = seed;
 852 }
 853
 854
 855 /** Apply the channel matrices in turn to reconstruct the original audio
 856  *  samples. */
 857
 858 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
 859 {
 860     SubStream *s = &m->substream[substr];
 861     unsigned int mat, src_ch, i;
 862     unsigned int maxchan;
 863
 864     maxchan = s->max_matrix_channel;
 865     if (!s->noise_type) {
 866         generate_2_noise_channels(m, substr);
 867         maxchan += 2;
 868     } else {
 869         fill_noise_buffer(m, substr);
 870     }
 871
 872     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
 873         int matrix_noise_shift = s->matrix_noise_shift[mat];
 874         unsigned int dest_ch = s->matrix_out_ch[mat];
 875         int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
 876         int32_t *coeffs = s->matrix_coeff[mat];
 877         int index  = s->num_primitive_matrices - mat;
 878         int index2 = 2 * index + 1;
 879
 880         /* TODO: DSPContext? */
 881
 882         for (i = 0; i < s->blockpos; i++) {
 883             int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
 884             int32_t *samples = m->sample_buffer[i];
 885             int64_t accum = 0;
 886
 887             for (src_ch = 0; src_ch <= maxchan; src_ch++)
 888                 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
 889
 890             if (matrix_noise_shift) {
 891                 index &= m->access_unit_size_pow2 - 1;
 892                 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
 893                 index += index2;
 894             }
 895
 896             samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
 897         }
 898     }
 899 }
 900
 901 /** Write the audio data into the output buffer. */
 902
 903 static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
 904                                 uint8_t *data, unsigned int *data_size, int is32)
 905 {
 906     SubStream *s = &m->substream[substr];
 907     unsigned int i, out_ch = 0;
 908     int32_t *data_32 = (int32_t*) data;
 909     int16_t *data_16 = (int16_t*) data;
 910
 911     if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
 912         return -1;
 913
 914     for (i = 0; i < s->blockpos; i++) {
 915         for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
 916             int mat_ch = s->ch_assign[out_ch];
 917             int32_t sample = m->sample_buffer[i][mat_ch]
 918                           << s->output_shift[mat_ch];
 919             s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
 920             if (is32) *data_32++ = sample << 8;
 921             else      *data_16++ = sample >> 8;
 922         }
 923     }
 924
 925     *data_size = i * out_ch * (is32 ? 4 : 2);
 926
 927     return 0;
 928 }
 929
 930 static int output_data(MLPDecodeContext *m, unsigned int substr,
 931                        uint8_t *data, unsigned int *data_size)
 932 {
 933     if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
 934         return output_data_internal(m, substr, data, data_size, 1);
 935     else
 936         return output_data_internal(m, substr, data, data_size, 0);
 937 }
 938
 939
 940 /** Read an access unit from the stream.
 941  *  Returns < 0 on error, 0 if not enough data is present in the input stream
 942  *  otherwise returns the number of bytes consumed. */
 943
 944 static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
 945                             AVPacket *avpkt)
 946 {
 947     const uint8_t *buf = avpkt->data;
 948     int buf_size = avpkt->size;
 949     MLPDecodeContext *m = avctx->priv_data;
 950     GetBitContext gb;
 951     unsigned int length, substr;
 952     unsigned int substream_start;
 953     unsigned int header_size = 4;
 954     unsigned int substr_header_size = 0;
 955     uint8_t substream_parity_present[MAX_SUBSTREAMS];
 956     uint16_t substream_data_len[MAX_SUBSTREAMS];
 957     uint8_t parity_bits;
 958
 959     if (buf_size < 4)
 960         return 0;
 961
 962     length = (AV_RB16(buf) & 0xfff) * 2;
 963
 964     if (length < 4 || length > buf_size)
 965         return -1;
 966
 967     init_get_bits(&gb, (buf + 4), (length - 4) * 8);
 968
 969     m->is_major_sync_unit = 0;
 970     if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
 971         if (read_major_sync(m, &gb) < 0)
 972             goto error;
 973         m->is_major_sync_unit = 1;
 974         header_size += 28;
 975     }
 976
 977     if (!m->params_valid) {
 978         av_log(m->avctx, AV_LOG_WARNING,
 979                "Stream parameters not seen; skipping frame.\n");
 980         *data_size = 0;
 981         return length;
 982     }
 983
 984     substream_start = 0;
 985
 986     for (substr = 0; substr < m->num_substreams; substr++) {
 987         int extraword_present, checkdata_present, end, nonrestart_substr;
 988
 989         extraword_present = get_bits1(&gb);
 990         nonrestart_substr = get_bits1(&gb);
 991         checkdata_present = get_bits1(&gb);
 992         skip_bits1(&gb);
 993
 994         end = get_bits(&gb, 12) * 2;
 995
 996         substr_header_size += 2;
 997
 998         if (extraword_present) {
 999             if (m->avctx->codec_id == CODEC_ID_MLP) {
1000                 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1001                 goto error;
1002             }
1003             skip_bits(&gb, 16);
1004             substr_header_size += 2;
1005         }
1006
1007         if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1008             av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1009             goto error;
1010         }
1011
1012         if (end + header_size + substr_header_size > length) {
1013             av_log(m->avctx, AV_LOG_ERROR,
1014                    "Indicated length of substream %d data goes off end of "
1015                    "packet.\n", substr);
1016             end = length - header_size - substr_header_size;
1017         }
1018
1019         if (end < substream_start) {
1020             av_log(avctx, AV_LOG_ERROR,
1021                    "Indicated end offset of substream %d data "
1022                    "is smaller than calculated start offset.\n",
1023                    substr);
1024             goto error;
1025         }
1026
1027         if (substr > m->max_decoded_substream)
1028             continue;
1029
1030         substream_parity_present[substr] = checkdata_present;
1031         substream_data_len[substr] = end - substream_start;
1032         substream_start = end;
1033     }
1034
1035     parity_bits  = ff_mlp_calculate_parity(buf, 4);
1036     parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1037
1038     if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1039         av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1040         goto error;
1041     }
1042
1043     buf += header_size + substr_header_size;
1044
1045     for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1046         SubStream *s = &m->substream[substr];
1047         init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1048
1049         m->matrix_changed = 0;
1050         memset(m->filter_changed, 0, sizeof(m->filter_changed));
1051
1052         s->blockpos = 0;
1053         do {
1054             if (get_bits1(&gb)) {
1055                 if (get_bits1(&gb)) {
1056                     /* A restart header should be present. */
1057                     if (read_restart_header(m, &gb, buf, substr) < 0)
1058                         goto next_substr;
1059                     s->restart_seen = 1;
1060                 }
1061
1062                 if (!s->restart_seen)
1063                     goto next_substr;
1064                 if (read_decoding_params(m, &gb, substr) < 0)
1065                     goto next_substr;
1066             }
1067
1068             if (!s->restart_seen)
1069                 goto next_substr;
1070
1071             if (read_block_data(m, &gb, substr) < 0)
1072                 return -1;
1073
1074             if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1075                 goto substream_length_mismatch;
1076
1077         } while (!get_bits1(&gb));
1078
1079         skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1080
1081         if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1082             int shorten_by;
1083
1084             if (get_bits(&gb, 16) != 0xD234)
1085                 return -1;
1086
1087             shorten_by = get_bits(&gb, 16);
1088             if      (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by  & 0x2000)
1089                 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1090             else if (m->avctx->codec_id == CODEC_ID_MLP    && shorten_by != 0xD234)
1091                 return -1;
1092
1093             if (substr == m->max_decoded_substream)
1094                 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1095         }
1096
1097         if (substream_parity_present[substr]) {
1098             uint8_t parity, checksum;
1099
1100             if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1101                 goto substream_length_mismatch;
1102
1103             parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1104             checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
1105
1106             if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
1107                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1108             if ( get_bits(&gb, 8)           != checksum)
1109                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
1110         }
1111
1112         if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1113             goto substream_length_mismatch;
1114
1115 next_substr:
1116         if (!s->restart_seen)
1117             av_log(m->avctx, AV_LOG_ERROR,
1118                    "No restart header present in substream %d.\n", substr);
1119
1120         buf += substream_data_len[substr];
1121     }
1122
1123     rematrix_channels(m, m->max_decoded_substream);
1124
1125     if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
1126         return -1;
1127
1128     return length;
1129
1130 substream_length_mismatch:
1131     av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1132     return -1;
1133
1134 error:
1135     m->params_valid = 0;
1136     return -1;
1137 }
1138
1139 AVCodec mlp_decoder = {
1140     "mlp",
1141     AVMEDIA_TYPE_AUDIO,
1142     CODEC_ID_MLP,
1143     sizeof(MLPDecodeContext),
1144     mlp_decode_init,
1145     NULL,
1146     NULL,
1147     read_access_unit,
1148     .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1149 };
1150
1151 #if CONFIG_TRUEHD_DECODER
1152 AVCodec truehd_decoder = {
1153     "truehd",
1154     AVMEDIA_TYPE_AUDIO,
1155     CODEC_ID_TRUEHD,
1156     sizeof(MLPDecodeContext),
1157     mlp_decode_init,
1158     NULL,
1159     NULL,
1160     read_access_unit,
1161     .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1162 };
1163 #endif /* CONFIG_TRUEHD_DECODER */