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