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     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     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 ((unsigned)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
1042 /** Apply the channel matrices in turn to reconstruct the original audio
1043  *  samples. */
1044
1045 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
1046 {
1047     SubStream *s = &m->substream[substr];
1048     unsigned int mat;
1049     unsigned int maxchan;
1050
1051     maxchan = s->max_matrix_channel;
1052     if (!s->noise_type) {
1053         generate_2_noise_channels(m, substr);
1054         maxchan += 2;
1055     } else {
1056         fill_noise_buffer(m, substr);
1057     }
1058
1059     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
1060         unsigned int dest_ch = s->matrix_out_ch[mat];
1061         m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
1062                                     s->matrix_coeff[mat],
1063                                     &m->bypassed_lsbs[0][mat],
1064                                     m->noise_buffer,
1065                                     s->num_primitive_matrices - mat,
1066                                     dest_ch,
1067                                     s->blockpos,
1068                                     maxchan,
1069                                     s->matrix_noise_shift[mat],
1070                                     m->access_unit_size_pow2,
1071                                     MSB_MASK(s->quant_step_size[dest_ch]));
1072     }
1073 }
1074
1075 /** Write the audio data into the output buffer. */
1076
1077 static int output_data(MLPDecodeContext *m, unsigned int substr,
1078                        AVFrame *frame, int *got_frame_ptr)
1079 {
1080     AVCodecContext *avctx = m->avctx;
1081     SubStream *s = &m->substream[substr];
1082     int ret;
1083     int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
1084
1085     if (m->avctx->channels != s->max_matrix_channel + 1) {
1086         av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
1087         return AVERROR_INVALIDDATA;
1088     }
1089
1090     if (!s->blockpos) {
1091         av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
1092         return AVERROR_INVALIDDATA;
1093     }
1094
1095     /* get output buffer */
1096     frame->nb_samples = s->blockpos;
1097     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1098         return ret;
1099     s->lossless_check_data = m->dsp.mlp_pack_output(s->lossless_check_data,
1100                                                     s->blockpos,
1101                                                     m->sample_buffer,
1102                                                     frame->data[0],
1103                                                     s->ch_assign,
1104                                                     s->output_shift,
1105                                                     s->max_matrix_channel,
1106                                                     is32);
1107
1108     /* Update matrix encoding side data */
1109     if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
1110         return ret;
1111
1112     *got_frame_ptr = 1;
1113
1114     return 0;
1115 }
1116
1117 /** Read an access unit from the stream.
1118  *  @return negative on error, 0 if not enough data is present in the input stream,
1119  *  otherwise the number of bytes consumed. */
1120
1121 static int read_access_unit(AVCodecContext *avctx, void* data,
1122                             int *got_frame_ptr, AVPacket *avpkt)
1123 {
1124     const uint8_t *buf = avpkt->data;
1125     int buf_size = avpkt->size;
1126     MLPDecodeContext *m = avctx->priv_data;
1127     GetBitContext gb;
1128     unsigned int length, substr;
1129     unsigned int substream_start;
1130     unsigned int header_size = 4;
1131     unsigned int substr_header_size = 0;
1132     uint8_t substream_parity_present[MAX_SUBSTREAMS];
1133     uint16_t substream_data_len[MAX_SUBSTREAMS];
1134     uint8_t parity_bits;
1135     int ret;
1136
1137     if (buf_size < 4)
1138         return AVERROR_INVALIDDATA;
1139
1140     length = (AV_RB16(buf) & 0xfff) * 2;
1141
1142     if (length < 4 || length > buf_size)
1143         return AVERROR_INVALIDDATA;
1144
1145     init_get_bits(&gb, (buf + 4), (length - 4) * 8);
1146
1147     m->is_major_sync_unit = 0;
1148     if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
1149         if (read_major_sync(m, &gb) < 0)
1150             goto error;
1151         m->is_major_sync_unit = 1;
1152         header_size += m->major_sync_header_size;
1153     }
1154
1155     if (!m->params_valid) {
1156         av_log(m->avctx, AV_LOG_WARNING,
1157                "Stream parameters not seen; skipping frame.\n");
1158         *got_frame_ptr = 0;
1159         return length;
1160     }
1161
1162     substream_start = 0;
1163
1164     for (substr = 0; substr < m->num_substreams; substr++) {
1165         int extraword_present, checkdata_present, end, nonrestart_substr;
1166
1167         extraword_present = get_bits1(&gb);
1168         nonrestart_substr = get_bits1(&gb);
1169         checkdata_present = get_bits1(&gb);
1170         skip_bits1(&gb);
1171
1172         end = get_bits(&gb, 12) * 2;
1173
1174         substr_header_size += 2;
1175
1176         if (extraword_present) {
1177             if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1178                 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
1179                 goto error;
1180             }
1181             skip_bits(&gb, 16);
1182             substr_header_size += 2;
1183         }
1184
1185         if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
1186             av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
1187             goto error;
1188         }
1189
1190         if (end + header_size + substr_header_size > length) {
1191             av_log(m->avctx, AV_LOG_ERROR,
1192                    "Indicated length of substream %d data goes off end of "
1193                    "packet.\n", substr);
1194             end = length - header_size - substr_header_size;
1195         }
1196
1197         if (end < substream_start) {
1198             av_log(avctx, AV_LOG_ERROR,
1199                    "Indicated end offset of substream %d data "
1200                    "is smaller than calculated start offset.\n",
1201                    substr);
1202             goto error;
1203         }
1204
1205         if (substr > m->max_decoded_substream)
1206             continue;
1207
1208         substream_parity_present[substr] = checkdata_present;
1209         substream_data_len[substr] = end - substream_start;
1210         substream_start = end;
1211     }
1212
1213     parity_bits  = ff_mlp_calculate_parity(buf, 4);
1214     parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
1215
1216     if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1217         av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
1218         goto error;
1219     }
1220
1221     buf += header_size + substr_header_size;
1222
1223     for (substr = 0; substr <= m->max_decoded_substream; substr++) {
1224         SubStream *s = &m->substream[substr];
1225         init_get_bits(&gb, buf, substream_data_len[substr] * 8);
1226
1227         m->matrix_changed = 0;
1228         memset(m->filter_changed, 0, sizeof(m->filter_changed));
1229
1230         s->blockpos = 0;
1231         do {
1232             if (get_bits1(&gb)) {
1233                 if (get_bits1(&gb)) {
1234                     /* A restart header should be present. */
1235                     if (read_restart_header(m, &gb, buf, substr) < 0)
1236                         goto next_substr;
1237                     s->restart_seen = 1;
1238                 }
1239
1240                 if (!s->restart_seen)
1241                     goto next_substr;
1242                 if (read_decoding_params(m, &gb, substr) < 0)
1243                     goto next_substr;
1244             }
1245
1246             if (!s->restart_seen)
1247                 goto next_substr;
1248
1249             if ((ret = read_block_data(m, &gb, substr)) < 0)
1250                 return ret;
1251
1252             if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
1253                 goto substream_length_mismatch;
1254
1255         } while (!get_bits1(&gb));
1256
1257         skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1258
1259         if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
1260             int shorten_by;
1261
1262             if (get_bits(&gb, 16) != 0xD234)
1263                 return AVERROR_INVALIDDATA;
1264
1265             shorten_by = get_bits(&gb, 16);
1266             if      (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by  & 0x2000)
1267                 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1268             else if (m->avctx->codec_id == AV_CODEC_ID_MLP    && shorten_by != 0xD234)
1269                 return AVERROR_INVALIDDATA;
1270
1271             if (substr == m->max_decoded_substream)
1272                 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
1273         }
1274
1275         if (substream_parity_present[substr]) {
1276             uint8_t parity, checksum;
1277
1278             if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
1279                 goto substream_length_mismatch;
1280
1281             parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
1282             checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
1283
1284             if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
1285                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
1286             if ( get_bits(&gb, 8)           != checksum)
1287                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
1288         }
1289
1290         if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1291             goto substream_length_mismatch;
1292
1293 next_substr:
1294         if (!s->restart_seen)
1295             av_log(m->avctx, AV_LOG_ERROR,
1296                    "No restart header present in substream %d.\n", substr);
1297
1298         buf += substream_data_len[substr];
1299     }
1300
1301     rematrix_channels(m, m->max_decoded_substream);
1302
1303     if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1304         return ret;
1305
1306     return length;
1307
1308 substream_length_mismatch:
1309     av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1310     return AVERROR_INVALIDDATA;
1311
1312 error:
1313     m->params_valid = 0;
1314     return AVERROR_INVALIDDATA;
1315 }
1316
1317 #if CONFIG_MLP_DECODER
1318 AVCodec ff_mlp_decoder = {
1319     .name           = "mlp",
1320     .long_name      = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1321     .type           = AVMEDIA_TYPE_AUDIO,
1322     .id             = AV_CODEC_ID_MLP,
1323     .priv_data_size = sizeof(MLPDecodeContext),
1324     .init           = mlp_decode_init,
1325     .decode         = read_access_unit,
1326     .capabilities   = CODEC_CAP_DR1,
1327 };
1328 #endif
1329 #if CONFIG_TRUEHD_DECODER
1330 AVCodec ff_truehd_decoder = {
1331     .name           = "truehd",
1332     .long_name      = NULL_IF_CONFIG_SMALL("TrueHD"),
1333     .type           = AVMEDIA_TYPE_AUDIO,
1334     .id             = AV_CODEC_ID_TRUEHD,
1335     .priv_data_size = sizeof(MLPDecodeContext),
1336     .init           = mlp_decode_init,
1337     .decode         = read_access_unit,
1338     .capabilities   = CODEC_CAP_DR1,
1339 };
1340 #endif /* CONFIG_TRUEHD_DECODER */