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