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