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