libavcodec/mlpdec.c

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