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

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