mlpdec.c 43.7 KB
Newer Older
Ramiro Polla's avatar
Ramiro Polla committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * MLP decoder
 * Copyright (c) 2007-2008 Ian Caulfield
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
23
 * @file
Ramiro Polla's avatar
Ramiro Polla committed
24 25 26
 * MLP decoder
 */

27 28
#include <stdint.h>

Ramiro Polla's avatar
Ramiro Polla committed
29 30
#include "avcodec.h"
#include "libavutil/intreadwrite.h"
31
#include "libavutil/channel_layout.h"
32
#include "get_bits.h"
33
#include "internal.h"
Ramiro Polla's avatar
Ramiro Polla committed
34 35 36
#include "libavutil/crc.h"
#include "parser.h"
#include "mlp_parser.h"
37
#include "mlpdsp.h"
38
#include "mlp.h"
Ramiro Polla's avatar
Ramiro Polla committed
39

Diego Biurrun's avatar
Diego Biurrun committed
40
/** number of bits used for VLC lookup - longest Huffman code is 9 */
Ramiro Polla's avatar
Ramiro Polla committed
41 42 43
#define VLC_BITS            9

typedef struct SubStream {
44
    /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
Ramiro Polla's avatar
Ramiro Polla committed
45 46 47 48
    uint8_t     restart_seen;

    //@{
    /** restart header data */
49
    /// The type of noise to be used in the rematrix stage.
Ramiro Polla's avatar
Ramiro Polla committed
50 51
    uint16_t    noise_type;

52
    /// The index of the first channel coded in this substream.
Ramiro Polla's avatar
Ramiro Polla committed
53
    uint8_t     min_channel;
54
    /// The index of the last channel coded in this substream.
Ramiro Polla's avatar
Ramiro Polla committed
55
    uint8_t     max_channel;
56
    /// The number of channels input into the rematrix stage.
Ramiro Polla's avatar
Ramiro Polla committed
57
    uint8_t     max_matrix_channel;
58
    /// For each channel output by the matrix, the output channel to map it to
59
    uint8_t     ch_assign[MAX_CHANNELS];
60 61
    /// The channel layout for this substream
    uint64_t    ch_layout;
Ramiro Polla's avatar
Ramiro Polla committed
62

63
    /// Channel coding parameters for channels in the substream
64 65
    ChannelParams channel_params[MAX_CHANNELS];

66
    /// The left shift applied to random noise in 0x31ea substreams.
Ramiro Polla's avatar
Ramiro Polla committed
67
    uint8_t     noise_shift;
68
    /// The current seed value for the pseudorandom noise generator(s).
Ramiro Polla's avatar
Ramiro Polla committed
69 70
    uint32_t    noisegen_seed;

71
    /// Set if the substream contains extra info to check the size of VLC blocks.
Ramiro Polla's avatar
Ramiro Polla committed
72 73
    uint8_t     data_check_present;

74
    /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
Ramiro Polla's avatar
Ramiro Polla committed
75 76 77 78 79 80 81 82
    uint8_t     param_presence_flags;
#define PARAM_BLOCKSIZE     (1 << 7)
#define PARAM_MATRIX        (1 << 6)
#define PARAM_OUTSHIFT      (1 << 5)
#define PARAM_QUANTSTEP     (1 << 4)
#define PARAM_FIR           (1 << 3)
#define PARAM_IIR           (1 << 2)
#define PARAM_HUFFOFFSET    (1 << 1)
83
#define PARAM_PRESENCE      (1 << 0)
Ramiro Polla's avatar
Ramiro Polla committed
84 85 86 87 88
    //@}

    //@{
    /** matrix data */

89
    /// Number of matrices to be applied.
Ramiro Polla's avatar
Ramiro Polla committed
90 91
    uint8_t     num_primitive_matrices;

92
    /// matrix output channel
Ramiro Polla's avatar
Ramiro Polla committed
93 94
    uint8_t     matrix_out_ch[MAX_MATRICES];

95
    /// Whether the LSBs of the matrix output are encoded in the bitstream.
Ramiro Polla's avatar
Ramiro Polla committed
96
    uint8_t     lsb_bypass[MAX_MATRICES];
97
    /// Matrix coefficients, stored as 2.14 fixed point.
98
    int32_t     matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
99
    /// Left shift to apply to noise values in 0x31eb substreams.
Ramiro Polla's avatar
Ramiro Polla committed
100 101 102
    uint8_t     matrix_noise_shift[MAX_MATRICES];
    //@}

103
    /// Left shift to apply to Huffman-decoded residuals.
Ramiro Polla's avatar
Ramiro Polla committed
104 105
    uint8_t     quant_step_size[MAX_CHANNELS];

106
    /// number of PCM samples in current audio block
Ramiro Polla's avatar
Ramiro Polla committed
107
    uint16_t    blocksize;
108
    /// Number of PCM samples decoded so far in this frame.
Ramiro Polla's avatar
Ramiro Polla committed
109 110
    uint16_t    blockpos;

111
    /// Left shift to apply to decoded PCM values to get final 24-bit output.
Ramiro Polla's avatar
Ramiro Polla committed
112 113
    int8_t      output_shift[MAX_CHANNELS];

114
    /// Running XOR of all output samples.
Ramiro Polla's avatar
Ramiro Polla committed
115 116 117 118 119 120
    int32_t     lossless_check_data;

} SubStream;

typedef struct MLPDecodeContext {
    AVCodecContext *avctx;
121
    AVFrame     frame;
Ramiro Polla's avatar
Ramiro Polla committed
122

123
    /// Current access unit being read has a major sync.
124 125
    int         is_major_sync_unit;

126
    /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
Ramiro Polla's avatar
Ramiro Polla committed
127 128
    uint8_t     params_valid;

129
    /// Number of substreams contained within this stream.
Ramiro Polla's avatar
Ramiro Polla committed
130 131
    uint8_t     num_substreams;

132
    /// Index of the last substream to decode - further substreams are skipped.
Ramiro Polla's avatar
Ramiro Polla committed
133 134
    uint8_t     max_decoded_substream;

135
    /// Stream needs channel reordering to comply with FFmpeg's channel order
136 137
    uint8_t     needs_reordering;

138
    /// number of PCM samples contained in each frame
Ramiro Polla's avatar
Ramiro Polla committed
139
    int         access_unit_size;
140
    /// next power of two above the number of samples in each frame
Ramiro Polla's avatar
Ramiro Polla committed
141 142 143 144
    int         access_unit_size_pow2;

    SubStream   substream[MAX_SUBSTREAMS];

145 146 147
    int         matrix_changed;
    int         filter_changed[MAX_CHANNELS][NUM_FILTERS];

Ramiro Polla's avatar
Ramiro Polla committed
148 149
    int8_t      noise_buffer[MAX_BLOCKSIZE_POW2];
    int8_t      bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
150
    int32_t     sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
151

152
    MLPDSPContext dsp;
Ramiro Polla's avatar
Ramiro Polla committed
153 154
} MLPDecodeContext;

155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
static const uint64_t thd_channel_order[] = {
    AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT,                     // LR
    AV_CH_FRONT_CENTER,                                      // C
    AV_CH_LOW_FREQUENCY,                                     // LFE
    AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT,                       // LRs
    AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT,             // LRvh
    AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
    AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT,                       // LRrs
    AV_CH_BACK_CENTER,                                       // Cs
    AV_CH_TOP_CENTER,                                        // Ts
    AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
    AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT,                       // LRw
    AV_CH_TOP_FRONT_CENTER,                                  // Cvh
    AV_CH_LOW_FREQUENCY_2,                                   // LFE2
};

static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
                                                   int index)
{
    int i;

    if (av_get_channel_layout_nb_channels(channel_layout) <= index)
        return 0;

    for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
        if (channel_layout & thd_channel_order[i] && !index--)
            return thd_channel_order[i];
    return 0;
}

Ramiro Polla's avatar
Ramiro Polla committed
185 186 187 188
static VLC huff_vlc[3];

/** Initialize static data, constant between all invocations of the codec. */

189
static av_cold void init_static(void)
Ramiro Polla's avatar
Ramiro Polla committed
190
{
191
    if (!huff_vlc[0].bits) {
Ramiro Polla's avatar
Ramiro Polla committed
192 193 194 195 196 197 198 199 200
        INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
                    &ff_mlp_huffman_tables[0][0][1], 2, 1,
                    &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
        INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
                    &ff_mlp_huffman_tables[1][0][1], 2, 1,
                    &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
        INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
                    &ff_mlp_huffman_tables[2][0][1], 2, 1,
                    &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
201
    }
Ramiro Polla's avatar
Ramiro Polla committed
202

203
    ff_mlp_init_crc();
Ramiro Polla's avatar
Ramiro Polla committed
204 205 206 207 208 209
}

static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
                                          unsigned int substr, unsigned int ch)
{
    SubStream *s = &m->substream[substr];
210
    ChannelParams *cp = &s->channel_params[ch];
211 212 213
    int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
    int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
    int32_t sign_huff_offset = cp->huff_offset;
Ramiro Polla's avatar
Ramiro Polla committed
214

215
    if (cp->codebook > 0)
Ramiro Polla's avatar
Ramiro Polla committed
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
        sign_huff_offset -= 7 << lsb_bits;

    if (sign_shift >= 0)
        sign_huff_offset -= 1 << sign_shift;

    return sign_huff_offset;
}

/** Read a sample, consisting of either, both or neither of entropy-coded MSBs
 *  and plain LSBs. */

static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
                                     unsigned int substr, unsigned int pos)
{
    SubStream *s = &m->substream[substr];
    unsigned int mat, channel;

    for (mat = 0; mat < s->num_primitive_matrices; mat++)
        if (s->lsb_bypass[mat])
            m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);

    for (channel = s->min_channel; channel <= s->max_channel; channel++) {
238
        ChannelParams *cp = &s->channel_params[channel];
239
        int codebook = cp->codebook;
Ramiro Polla's avatar
Ramiro Polla committed
240
        int quant_step_size = s->quant_step_size[channel];
241
        int lsb_bits = cp->huff_lsbs - quant_step_size;
Ramiro Polla's avatar
Ramiro Polla committed
242 243 244 245 246 247 248
        int result = 0;

        if (codebook > 0)
            result = get_vlc2(gbp, huff_vlc[codebook-1].table,
                            VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);

        if (result < 0)
249
            return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
250 251 252 253

        if (lsb_bits > 0)
            result = (result << lsb_bits) + get_bits(gbp, lsb_bits);

254
        result  += cp->sign_huff_offset;
Ramiro Polla's avatar
Ramiro Polla committed
255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
        result <<= quant_step_size;

        m->sample_buffer[pos + s->blockpos][channel] = result;
    }

    return 0;
}

static av_cold int mlp_decode_init(AVCodecContext *avctx)
{
    MLPDecodeContext *m = avctx->priv_data;
    int substr;

    init_static();
    m->avctx = avctx;
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
        m->substream[substr].lossless_check_data = 0xffffffff;
272
    ff_mlpdsp_init(&m->dsp);
273

274 275 276
    avcodec_get_frame_defaults(&m->frame);
    avctx->coded_frame = &m->frame;

Ramiro Polla's avatar
Ramiro Polla committed
277 278 279 280 281 282 283 284 285 286 287
    return 0;
}

/** Read a major sync info header - contains high level information about
 *  the stream - sample rate, channel arrangement etc. Most of this
 *  information is not actually necessary for decoding, only for playback.
 */

static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
{
    MLPHeaderInfo mh;
288
    int substr, ret;
Ramiro Polla's avatar
Ramiro Polla committed
289

290 291
    if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
        return ret;
Ramiro Polla's avatar
Ramiro Polla committed
292 293

    if (mh.group1_bits == 0) {
Diego Biurrun's avatar
Diego Biurrun committed
294
        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
295
        return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
296 297 298
    }
    if (mh.group2_bits > mh.group1_bits) {
        av_log(m->avctx, AV_LOG_ERROR,
Diego Biurrun's avatar
Diego Biurrun committed
299
               "Channel group 2 cannot have more bits per sample than group 1.\n");
300
        return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
301 302 303 304
    }

    if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
        av_log(m->avctx, AV_LOG_ERROR,
Diego Biurrun's avatar
Diego Biurrun committed
305
               "Channel groups with differing sample rates are not currently supported.\n");
306
        return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
307 308 309
    }

    if (mh.group1_samplerate == 0) {
Diego Biurrun's avatar
Diego Biurrun committed
310
        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
311
        return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
312 313 314
    }
    if (mh.group1_samplerate > MAX_SAMPLERATE) {
        av_log(m->avctx, AV_LOG_ERROR,
Diego Biurrun's avatar
Diego Biurrun committed
315
               "Sampling rate %d is greater than the supported maximum (%d).\n",
Ramiro Polla's avatar
Ramiro Polla committed
316
               mh.group1_samplerate, MAX_SAMPLERATE);
317
        return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
318 319 320
    }
    if (mh.access_unit_size > MAX_BLOCKSIZE) {
        av_log(m->avctx, AV_LOG_ERROR,
Diego Biurrun's avatar
Diego Biurrun committed
321
               "Block size %d is greater than the supported maximum (%d).\n",
Ramiro Polla's avatar
Ramiro Polla committed
322
               mh.access_unit_size, MAX_BLOCKSIZE);
323
        return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
324 325 326
    }
    if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
        av_log(m->avctx, AV_LOG_ERROR,
Diego Biurrun's avatar
Diego Biurrun committed
327
               "Block size pow2 %d is greater than the supported maximum (%d).\n",
Ramiro Polla's avatar
Ramiro Polla committed
328
               mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
329
        return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
330 331 332
    }

    if (mh.num_substreams == 0)
333
        return AVERROR_INVALIDDATA;
334
    if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
335
        av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
336
        return AVERROR_INVALIDDATA;
337
    }
Ramiro Polla's avatar
Ramiro Polla committed
338
    if (mh.num_substreams > MAX_SUBSTREAMS) {
339
        av_log_ask_for_sample(m->avctx,
Diego Biurrun's avatar
Diego Biurrun committed
340
               "Number of substreams %d is larger than the maximum supported "
341 342
               "by the decoder.\n", mh.num_substreams);
        return AVERROR_PATCHWELCOME;
Ramiro Polla's avatar
Ramiro Polla committed
343 344 345 346 347 348 349 350 351 352 353
    }

    m->access_unit_size      = mh.access_unit_size;
    m->access_unit_size_pow2 = mh.access_unit_size_pow2;

    m->num_substreams        = mh.num_substreams;
    m->max_decoded_substream = m->num_substreams - 1;

    m->avctx->sample_rate    = mh.group1_samplerate;
    m->avctx->frame_size     = mh.access_unit_size;

354
    m->avctx->bits_per_raw_sample = mh.group1_bits;
355
    if (mh.group1_bits > 16)
356
        m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
357
    else
358
        m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
Ramiro Polla's avatar
Ramiro Polla committed
359 360 361 362 363

    m->params_valid = 1;
    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
        m->substream[substr].restart_seen = 0;

364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
    /* Set the layout for each substream. When there's more than one, the first
     * substream is Stereo. Subsequent substreams' layouts are indicated in the
     * major sync. */
    if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
        if ((substr = (mh.num_substreams > 1)))
            m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
        m->substream[substr].ch_layout = mh.channel_layout_mlp;
    } else {
        if ((substr = (mh.num_substreams > 1)))
            m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;
        if (mh.num_substreams > 2)
            if (mh.channel_layout_thd_stream2)
                m->substream[2].ch_layout = mh.channel_layout_thd_stream2;
            else
                m->substream[2].ch_layout = mh.channel_layout_thd_stream1;
        m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;
380 381 382 383 384 385 386

        if (m->avctx->channels<=2 && m->substream[substr].ch_layout == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
            av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
            m->max_decoded_substream = 0;
            if (m->avctx->channels==2)
                m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
        }
387 388
    }

389
    m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
390

Ramiro Polla's avatar
Ramiro Polla committed
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
    return 0;
}

/** Read a restart header from a block in a substream. This contains parameters
 *  required to decode the audio that do not change very often. Generally
 *  (always) present only in blocks following a major sync. */

static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
                               const uint8_t *buf, unsigned int substr)
{
    SubStream *s = &m->substream[substr];
    unsigned int ch;
    int sync_word, tmp;
    uint8_t checksum;
    uint8_t lossless_check;
    int start_count = get_bits_count(gbp);
407
    const int max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
408 409
                                 ? MAX_MATRIX_CHANNEL_MLP
                                 : MAX_MATRIX_CHANNEL_TRUEHD;
410
    int max_channel, min_channel, matrix_channel;
Ramiro Polla's avatar
Ramiro Polla committed
411 412 413

    sync_word = get_bits(gbp, 13);

414
    if (sync_word != 0x31ea >> 1) {
Ramiro Polla's avatar
Ramiro Polla committed
415
        av_log(m->avctx, AV_LOG_ERROR,
Diego Biurrun's avatar
Diego Biurrun committed
416
               "restart header sync incorrect (got 0x%04x)\n", sync_word);
417
        return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
418 419
    }

420 421
    s->noise_type = get_bits1(gbp);

422
    if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
423
        av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
424
        return AVERROR_INVALIDDATA;
425 426
    }

Ramiro Polla's avatar
Ramiro Polla committed
427 428
    skip_bits(gbp, 16); /* Output timestamp */

429 430 431
    min_channel    = get_bits(gbp, 4);
    max_channel    = get_bits(gbp, 4);
    matrix_channel = get_bits(gbp, 4);
Ramiro Polla's avatar
Ramiro Polla committed
432

433
    if (matrix_channel > max_matrix_channel) {
434 435 436
        av_log(m->avctx, AV_LOG_ERROR,
               "Max matrix channel cannot be greater than %d.\n",
               max_matrix_channel);
437
        return AVERROR_INVALIDDATA;
438 439
    }

440
    if (max_channel != matrix_channel) {
441 442
        av_log(m->avctx, AV_LOG_ERROR,
               "Max channel must be equal max matrix channel.\n");
443
        return AVERROR_INVALIDDATA;
444 445
    }

446 447
    /* This should happen for TrueHD streams with >6 channels and MLP's noise
     * type. It is not yet known if this is allowed. */
448
    if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
449
        av_log_ask_for_sample(m->avctx,
450
               "Number of channels %d is larger than the maximum supported "
451
               "by the decoder.\n", max_channel + 2);
452
        return AVERROR_PATCHWELCOME;
453 454
    }

455
    if (min_channel > max_channel) {
Ramiro Polla's avatar
Ramiro Polla committed
456 457
        av_log(m->avctx, AV_LOG_ERROR,
               "Substream min channel cannot be greater than max channel.\n");
458
        return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
459 460
    }

461 462 463 464
    s->min_channel = min_channel;
    s->max_channel = max_channel;
    s->max_matrix_channel = matrix_channel;

465 466 467 468
#if FF_API_REQUEST_CHANNELS
    if (m->avctx->request_channels > 0 &&
        m->avctx->request_channels <= s->max_channel + 1 &&
        m->max_decoded_substream > substr) {
469
        av_log(m->avctx, AV_LOG_DEBUG,
470
               "Extracting %d-channel downmix from substream %d. "
Ramiro Polla's avatar
Ramiro Polla committed
471 472 473
               "Further substreams will be skipped.\n",
               s->max_channel + 1, substr);
        m->max_decoded_substream = substr;
474 475 476 477 478 479 480 481 482
    } else
#endif
    if (m->avctx->request_channel_layout == s->ch_layout &&
        m->max_decoded_substream > substr) {
        av_log(m->avctx, AV_LOG_DEBUG,
               "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
               "Further substreams will be skipped.\n",
               s->max_channel + 1, s->ch_layout, substr);
        m->max_decoded_substream = substr;
Ramiro Polla's avatar
Ramiro Polla committed
483 484 485 486 487 488 489 490 491 492 493
    }

    s->noise_shift   = get_bits(gbp,  4);
    s->noisegen_seed = get_bits(gbp, 23);

    skip_bits(gbp, 19);

    s->data_check_present = get_bits1(gbp);
    lossless_check = get_bits(gbp, 8);
    if (substr == m->max_decoded_substream
        && s->lossless_check_data != 0xffffffff) {
494
        tmp = xor_32_to_8(s->lossless_check_data);
Ramiro Polla's avatar
Ramiro Polla committed
495 496
        if (tmp != lossless_check)
            av_log(m->avctx, AV_LOG_WARNING,
Diego Biurrun's avatar
Diego Biurrun committed
497
                   "Lossless check failed - expected %02x, calculated %02x.\n",
Ramiro Polla's avatar
Ramiro Polla committed
498 499 500 501 502
                   lossless_check, tmp);
    }

    skip_bits(gbp, 16);

503 504
    memset(s->ch_assign, 0, sizeof(s->ch_assign));

Ramiro Polla's avatar
Ramiro Polla committed
505 506
    for (ch = 0; ch <= s->max_matrix_channel; ch++) {
        int ch_assign = get_bits(gbp, 6);
507 508 509 510 511 512
        if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
            uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,
                                                                  ch_assign);
            ch_assign = av_get_channel_layout_channel_index(s->ch_layout,
                                                            channel);
        }
513
        if (ch_assign > s->max_matrix_channel) {
514 515 516 517
            av_log_ask_for_sample(m->avctx,
                   "Assignment of matrix channel %d to invalid output channel %d.\n",
                   ch, ch_assign);
            return AVERROR_PATCHWELCOME;
Ramiro Polla's avatar
Ramiro Polla committed
518
        }
519
        s->ch_assign[ch_assign] = ch;
Ramiro Polla's avatar
Ramiro Polla committed
520 521
    }

522
    checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
Ramiro Polla's avatar
Ramiro Polla committed
523 524

    if (checksum != get_bits(gbp, 8))
Diego Biurrun's avatar
Diego Biurrun committed
525
        av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
Ramiro Polla's avatar
Ramiro Polla committed
526

Diego Biurrun's avatar
Diego Biurrun committed
527
    /* Set default decoding parameters. */
Ramiro Polla's avatar
Ramiro Polla committed
528 529 530 531 532 533 534 535 536
    s->param_presence_flags   = 0xff;
    s->num_primitive_matrices = 0;
    s->blocksize              = 8;
    s->lossless_check_data    = 0;

    memset(s->output_shift   , 0, sizeof(s->output_shift   ));
    memset(s->quant_step_size, 0, sizeof(s->quant_step_size));

    for (ch = s->min_channel; ch <= s->max_channel; ch++) {
537
        ChannelParams *cp = &s->channel_params[ch];
538 539 540 541
        cp->filter_params[FIR].order = 0;
        cp->filter_params[IIR].order = 0;
        cp->filter_params[FIR].shift = 0;
        cp->filter_params[IIR].shift = 0;
Ramiro Polla's avatar
Ramiro Polla committed
542

Diego Biurrun's avatar
Diego Biurrun committed
543
        /* Default audio coding is 24-bit raw PCM. */
544 545 546 547
        cp->huff_offset      = 0;
        cp->sign_huff_offset = (-1) << 23;
        cp->codebook         = 0;
        cp->huff_lsbs        = 24;
Ramiro Polla's avatar
Ramiro Polla committed
548 549
    }

550 551 552
    if (substr == m->max_decoded_substream) {
        m->avctx->channels       = s->max_matrix_channel + 1;
        m->avctx->channel_layout = s->ch_layout;
553 554 555 556 557 558 559 560 561 562 563 564 565 566

        if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
            if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
                m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
                int i = s->ch_assign[4];
                s->ch_assign[4] = s->ch_assign[3];
                s->ch_assign[3] = s->ch_assign[2];
                s->ch_assign[2] = i;
            } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
                FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
                FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
            }
        }

567
    }
Ramiro Polla's avatar
Ramiro Polla committed
568 569 570 571 572 573 574

    return 0;
}

/** Read parameters for one of the prediction filters. */

static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
575 576
                              unsigned int substr, unsigned int channel,
                              unsigned int filter)
Ramiro Polla's avatar
Ramiro Polla committed
577
{
578 579
    SubStream *s = &m->substream[substr];
    FilterParams *fp = &s->channel_params[channel].filter_params[filter];
580
    const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
Ramiro Polla's avatar
Ramiro Polla committed
581 582 583
    const char fchar = filter ? 'I' : 'F';
    int i, order;

Diego Biurrun's avatar
Diego Biurrun committed
584
    // Filter is 0 for FIR, 1 for IIR.
585
    av_assert0(filter < 2);
Ramiro Polla's avatar
Ramiro Polla committed
586

587 588
    if (m->filter_changed[channel][filter]++ > 1) {
        av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
589
        return AVERROR_INVALIDDATA;
590
    }
591

Ramiro Polla's avatar
Ramiro Polla committed
592
    order = get_bits(gbp, 4);
593
    if (order > max_order) {
Ramiro Polla's avatar
Ramiro Polla committed
594
        av_log(m->avctx, AV_LOG_ERROR,
Diego Biurrun's avatar
Diego Biurrun committed
595
               "%cIR filter order %d is greater than maximum %d.\n",
596
               fchar, order, max_order);
597
        return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
598
    }
599
    fp->order = order;
Ramiro Polla's avatar
Ramiro Polla committed
600 601

    if (order > 0) {
602
        int32_t *fcoeff = s->channel_params[channel].coeff[filter];
Ramiro Polla's avatar
Ramiro Polla committed
603 604
        int coeff_bits, coeff_shift;

605
        fp->shift = get_bits(gbp, 4);
Ramiro Polla's avatar
Ramiro Polla committed
606 607 608 609 610

        coeff_bits  = get_bits(gbp, 5);
        coeff_shift = get_bits(gbp, 3);
        if (coeff_bits < 1 || coeff_bits > 16) {
            av_log(m->avctx, AV_LOG_ERROR,
Diego Biurrun's avatar
Diego Biurrun committed
611
                   "%cIR filter coeff_bits must be between 1 and 16.\n",
Ramiro Polla's avatar
Ramiro Polla committed
612
                   fchar);
613
            return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
614 615 616
        }
        if (coeff_bits + coeff_shift > 16) {
            av_log(m->avctx, AV_LOG_ERROR,
Diego Biurrun's avatar
Diego Biurrun committed
617
                   "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
Ramiro Polla's avatar
Ramiro Polla committed
618
                   fchar);
619
            return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
620 621 622
        }

        for (i = 0; i < order; i++)
623
            fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
Ramiro Polla's avatar
Ramiro Polla committed
624 625 626 627 628 629

        if (get_bits1(gbp)) {
            int state_bits, state_shift;

            if (filter == FIR) {
                av_log(m->avctx, AV_LOG_ERROR,
Diego Biurrun's avatar
Diego Biurrun committed
630
                       "FIR filter has state data specified.\n");
631
                return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
632 633 634 635 636
            }

            state_bits  = get_bits(gbp, 4);
            state_shift = get_bits(gbp, 4);

Diego Biurrun's avatar
Diego Biurrun committed
637
            /* TODO: Check validity of state data. */
Ramiro Polla's avatar
Ramiro Polla committed
638 639

            for (i = 0; i < order; i++)
640
                fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
Ramiro Polla's avatar
Ramiro Polla committed
641 642 643 644 645 646
        }
    }

    return 0;
}

647 648
/** Read parameters for primitive matrices. */

649
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
650
{
651
    SubStream *s = &m->substream[substr];
652
    unsigned int mat, ch;
653
    const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
654 655
                                     ? MAX_MATRICES_MLP
                                     : MAX_MATRICES_TRUEHD;
656

657 658
    if (m->matrix_changed++ > 1) {
        av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
659
        return AVERROR_INVALIDDATA;
660 661
    }

662 663
    s->num_primitive_matrices = get_bits(gbp, 4);

664 665 666 667
    if (s->num_primitive_matrices > max_primitive_matrices) {
        av_log(m->avctx, AV_LOG_ERROR,
               "Number of primitive matrices cannot be greater than %d.\n",
               max_primitive_matrices);
668
        return AVERROR_INVALIDDATA;
669 670
    }

671 672 673 674 675 676
    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
        int frac_bits, max_chan;
        s->matrix_out_ch[mat] = get_bits(gbp, 4);
        frac_bits             = get_bits(gbp, 4);
        s->lsb_bypass   [mat] = get_bits1(gbp);

677
        if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
678 679 680
            av_log(m->avctx, AV_LOG_ERROR,
                    "Invalid channel %d specified as output from matrix.\n",
                    s->matrix_out_ch[mat]);
681
            return AVERROR_INVALIDDATA;
682 683 684 685
        }
        if (frac_bits > 14) {
            av_log(m->avctx, AV_LOG_ERROR,
                    "Too many fractional bits specified.\n");
686
            return AVERROR_INVALIDDATA;
687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
        }

        max_chan = s->max_matrix_channel;
        if (!s->noise_type)
            max_chan+=2;

        for (ch = 0; ch <= max_chan; ch++) {
            int coeff_val = 0;
            if (get_bits1(gbp))
                coeff_val = get_sbits(gbp, frac_bits + 2);

            s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
        }

        if (s->noise_type)
            s->matrix_noise_shift[mat] = get_bits(gbp, 4);
        else
            s->matrix_noise_shift[mat] = 0;
    }

    return 0;
}

710 711 712 713 714
/** Read channel parameters. */

static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
                               GetBitContext *gbp, unsigned int ch)
{
715 716
    SubStream *s = &m->substream[substr];
    ChannelParams *cp = &s->channel_params[ch];
717 718
    FilterParams *fir = &cp->filter_params[FIR];
    FilterParams *iir = &cp->filter_params[IIR];
719
    int ret;
720 721 722

    if (s->param_presence_flags & PARAM_FIR)
        if (get_bits1(gbp))
723 724
            if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
                return ret;
725 726 727

    if (s->param_presence_flags & PARAM_IIR)
        if (get_bits1(gbp))
728 729
            if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
                return ret;
730

731 732
    if (fir->order + iir->order > 8) {
        av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
733
        return AVERROR_INVALIDDATA;
734 735
    }

736 737 738 739
    if (fir->order && iir->order &&
        fir->shift != iir->shift) {
        av_log(m->avctx, AV_LOG_ERROR,
                "FIR and IIR filters must use the same precision.\n");
740
        return AVERROR_INVALIDDATA;
741 742
    }
    /* The FIR and IIR filters must have the same precision.
743 744 745 746
     * To simplify the filtering code, only the precision of the
     * FIR filter is considered. If only the IIR filter is employed,
     * the FIR filter precision is set to that of the IIR filter, so
     * that the filtering code can use it. */
747 748 749 750 751 752 753 754 755 756
    if (!fir->order && iir->order)
        fir->shift = iir->shift;

    if (s->param_presence_flags & PARAM_HUFFOFFSET)
        if (get_bits1(gbp))
            cp->huff_offset = get_sbits(gbp, 15);

    cp->codebook  = get_bits(gbp, 2);
    cp->huff_lsbs = get_bits(gbp, 5);

757 758
    if (cp->huff_lsbs > 24) {
        av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
759
        cp->huff_lsbs = 0;
760
        return AVERROR_INVALIDDATA;
761
    }
762

763
    cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
764 765 766 767

    return 0;
}

Ramiro Polla's avatar
Ramiro Polla committed
768 769 770 771 772 773 774
/** Read decoding parameters that change more often than those in the restart
 *  header. */

static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
                                unsigned int substr)
{
    SubStream *s = &m->substream[substr];
775
    unsigned int ch;
776
    int ret;
Ramiro Polla's avatar
Ramiro Polla committed
777

778
    if (s->param_presence_flags & PARAM_PRESENCE)
779 780
        if (get_bits1(gbp))
            s->param_presence_flags = get_bits(gbp, 8);
Ramiro Polla's avatar
Ramiro Polla committed
781 782 783 784

    if (s->param_presence_flags & PARAM_BLOCKSIZE)
        if (get_bits1(gbp)) {
            s->blocksize = get_bits(gbp, 9);
785
            if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
786
                av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
Ramiro Polla's avatar
Ramiro Polla committed
787
                s->blocksize = 0;
788
                return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
789 790 791 792
            }
        }

    if (s->param_presence_flags & PARAM_MATRIX)
793
        if (get_bits1(gbp))
794 795
            if ((ret = read_matrix_params(m, substr, gbp)) < 0)
                return ret;
Ramiro Polla's avatar
Ramiro Polla committed
796 797 798

    if (s->param_presence_flags & PARAM_OUTSHIFT)
        if (get_bits1(gbp))
799
            for (ch = 0; ch <= s->max_matrix_channel; ch++)
800
                s->output_shift[ch] = get_sbits(gbp, 4);
Ramiro Polla's avatar
Ramiro Polla committed
801 802 803 804

    if (s->param_presence_flags & PARAM_QUANTSTEP)
        if (get_bits1(gbp))
            for (ch = 0; ch <= s->max_channel; ch++) {
805
                ChannelParams *cp = &s->channel_params[ch];
806

Ramiro Polla's avatar
Ramiro Polla committed
807 808
                s->quant_step_size[ch] = get_bits(gbp, 4);

809
                cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
Ramiro Polla's avatar
Ramiro Polla committed
810 811 812
            }

    for (ch = s->min_channel; ch <= s->max_channel; ch++)
813
        if (get_bits1(gbp))
814 815
            if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
                return ret;
Ramiro Polla's avatar
Ramiro Polla committed
816 817 818 819 820 821 822 823 824 825 826 827 828

    return 0;
}

#define MSB_MASK(bits)  (-1u << bits)

/** Generate PCM samples using the prediction filters and residual values
 *  read from the data stream, and update the filter state. */

static void filter_channel(MLPDecodeContext *m, unsigned int substr,
                           unsigned int channel)
{
    SubStream *s = &m->substream[substr];
829
    const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
830 831 832
    int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
    int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
    int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
833 834
    FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
    FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
835
    unsigned int filter_shift = fir->shift;
Ramiro Polla's avatar
Ramiro Polla committed
836 837
    int32_t mask = MSB_MASK(s->quant_step_size[channel]);

838 839
    memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
    memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
Ramiro Polla's avatar
Ramiro Polla committed
840

841 842
    m->dsp.mlp_filter_channel(firbuf, fircoeff,
                              fir->order, iir->order,
843 844
                              filter_shift, mask, s->blocksize,
                              &m->sample_buffer[s->blockpos][channel]);
Ramiro Polla's avatar
Ramiro Polla committed
845

846 847
    memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
    memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
Ramiro Polla's avatar
Ramiro Polla committed
848 849 850 851 852 853 854 855 856
}

/** Read a block of PCM residual data (or actual if no filtering active). */

static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
                           unsigned int substr)
{
    SubStream *s = &m->substream[substr];
    unsigned int i, ch, expected_stream_pos = 0;
857
    int ret;
Ramiro Polla's avatar
Ramiro Polla committed
858 859 860 861

    if (s->data_check_present) {
        expected_stream_pos  = get_bits_count(gbp);
        expected_stream_pos += get_bits(gbp, 16);
862 863
        av_log_ask_for_sample(m->avctx, "This file contains some features "
                              "we have not tested yet.\n");
Ramiro Polla's avatar
Ramiro Polla committed
864 865 866
    }

    if (s->blockpos + s->blocksize > m->access_unit_size) {
Diego Biurrun's avatar
Diego Biurrun committed
867
        av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
868
        return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
869 870 871 872 873
    }

    memset(&m->bypassed_lsbs[s->blockpos][0], 0,
           s->blocksize * sizeof(m->bypassed_lsbs[0]));

874
    for (i = 0; i < s->blocksize; i++)
875 876
        if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
            return ret;
Ramiro Polla's avatar
Ramiro Polla committed
877

878
    for (ch = s->min_channel; ch <= s->max_channel; ch++)
Ramiro Polla's avatar
Ramiro Polla committed
879 880 881 882 883 884
        filter_channel(m, substr, ch);

    s->blockpos += s->blocksize;

    if (s->data_check_present) {
        if (get_bits_count(gbp) != expected_stream_pos)
Diego Biurrun's avatar
Diego Biurrun committed
885
            av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
Ramiro Polla's avatar
Ramiro Polla committed
886 887 888 889 890 891
        skip_bits(gbp, 8);
    }

    return 0;
}

Diego Biurrun's avatar
Diego Biurrun committed
892
/** Data table used for TrueHD noise generation function. */
Ramiro Polla's avatar
Ramiro Polla committed
893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979

static const int8_t noise_table[256] = {
     30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
     52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
     10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
     51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
     38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
     61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
     67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
     48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
      0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
     16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
     13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
     89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
     36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
     39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
     45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
    -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
};

/** Noise generation functions.
 *  I'm not sure what these are for - they seem to be some kind of pseudorandom
 *  sequence generators, used to generate noise data which is used when the
 *  channels are rematrixed. I'm not sure if they provide a practical benefit
 *  to compression, or just obfuscate the decoder. Are they for some kind of
 *  dithering? */

/** Generate two channels of noise, used in the matrix when
 *  restart sync word == 0x31ea. */

static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
{
    SubStream *s = &m->substream[substr];
    unsigned int i;
    uint32_t seed = s->noisegen_seed;
    unsigned int maxchan = s->max_matrix_channel;

    for (i = 0; i < s->blockpos; i++) {
        uint16_t seed_shr7 = seed >> 7;
        m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
        m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;

        seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
    }

    s->noisegen_seed = seed;
}

/** Generate a block of noise, used when restart sync word == 0x31eb. */

static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
{
    SubStream *s = &m->substream[substr];
    unsigned int i;
    uint32_t seed = s->noisegen_seed;

    for (i = 0; i < m->access_unit_size_pow2; i++) {
        uint8_t seed_shr15 = seed >> 15;
        m->noise_buffer[i] = noise_table[seed_shr15];
        seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
    }

    s->noisegen_seed = seed;
}


/** Apply the channel matrices in turn to reconstruct the original audio
 *  samples. */

static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
{
    SubStream *s = &m->substream[substr];
    unsigned int mat, src_ch, i;
    unsigned int maxchan;

    maxchan = s->max_matrix_channel;
    if (!s->noise_type) {
        generate_2_noise_channels(m, substr);
        maxchan += 2;
    } else {
        fill_noise_buffer(m, substr);
    }

    for (mat = 0; mat < s->num_primitive_matrices; mat++) {
        int matrix_noise_shift = s->matrix_noise_shift[mat];
        unsigned int dest_ch = s->matrix_out_ch[mat];
        int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
980
        int32_t *coeffs = s->matrix_coeff[mat];
981 982
        int index  = s->num_primitive_matrices - mat;
        int index2 = 2 * index + 1;
Ramiro Polla's avatar
Ramiro Polla committed
983 984 985 986

        /* TODO: DSPContext? */

        for (i = 0; i < s->blockpos; i++) {
987
            int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
988
            int32_t *samples = m->sample_buffer[i];
Ramiro Polla's avatar
Ramiro Polla committed
989
            int64_t accum = 0;
990 991 992 993

            for (src_ch = 0; src_ch <= maxchan; src_ch++)
                accum += (int64_t) samples[src_ch] * coeffs[src_ch];

Ramiro Polla's avatar
Ramiro Polla committed
994
            if (matrix_noise_shift) {
995
                index &= m->access_unit_size_pow2 - 1;
Ramiro Polla's avatar
Ramiro Polla committed
996
                accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
997
                index += index2;
Ramiro Polla's avatar
Ramiro Polla committed
998
            }
999

1000
            samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
Ramiro Polla's avatar
Ramiro Polla committed
1001 1002 1003 1004 1005 1006
        }
    }
}

/** Write the audio data into the output buffer. */

1007
static int output_data(MLPDecodeContext *m, unsigned int substr,
1008
                       void *data, int *got_frame_ptr)
Ramiro Polla's avatar
Ramiro Polla committed
1009
{
1010
    AVCodecContext *avctx = m->avctx;
Ramiro Polla's avatar
Ramiro Polla committed
1011
    SubStream *s = &m->substream[substr];
1012
    unsigned int i, out_ch = 0;
1013 1014 1015
    int32_t *data_32;
    int16_t *data_16;
    int ret;
1016
    int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
Ramiro Polla's avatar
Ramiro Polla committed
1017

1018 1019 1020 1021 1022
    if (m->avctx->channels != s->max_matrix_channel + 1) {
        av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
        return AVERROR_INVALIDDATA;
    }

1023 1024
    /* get output buffer */
    m->frame.nb_samples = s->blockpos;
1025
    if ((ret = ff_get_buffer(avctx, &m->frame)) < 0) {
1026 1027 1028 1029 1030
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
        return ret;
    }
    data_32 = (int32_t *)m->frame.data[0];
    data_16 = (int16_t *)m->frame.data[0];
Ramiro Polla's avatar
Ramiro Polla committed
1031 1032

    for (i = 0; i < s->blockpos; i++) {
1033 1034 1035 1036 1037
        for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
            int mat_ch = s->ch_assign[out_ch];
            int32_t sample = m->sample_buffer[i][mat_ch]
                          << s->output_shift[mat_ch];
            s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
Ramiro Polla's avatar
Ramiro Polla committed
1038 1039 1040 1041 1042
            if (is32) *data_32++ = sample << 8;
            else      *data_16++ = sample >> 8;
        }
    }

1043 1044
    *got_frame_ptr   = 1;
    *(AVFrame *)data = m->frame;
Ramiro Polla's avatar
Ramiro Polla committed
1045 1046 1047 1048 1049

    return 0;
}

/** Read an access unit from the stream.
1050 1051
 *  @return negative on error, 0 if not enough data is present in the input stream,
 *  otherwise the number of bytes consumed. */
Ramiro Polla's avatar
Ramiro Polla committed
1052

1053 1054
static int read_access_unit(AVCodecContext *avctx, void* data,
                            int *got_frame_ptr, AVPacket *avpkt)
Ramiro Polla's avatar
Ramiro Polla committed
1055
{
1056 1057
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
Ramiro Polla's avatar
Ramiro Polla committed
1058 1059 1060 1061 1062 1063 1064 1065 1066
    MLPDecodeContext *m = avctx->priv_data;
    GetBitContext gb;
    unsigned int length, substr;
    unsigned int substream_start;
    unsigned int header_size = 4;
    unsigned int substr_header_size = 0;
    uint8_t substream_parity_present[MAX_SUBSTREAMS];
    uint16_t substream_data_len[MAX_SUBSTREAMS];
    uint8_t parity_bits;
1067
    int ret;
Ramiro Polla's avatar
Ramiro Polla committed
1068 1069 1070 1071 1072 1073

    if (buf_size < 4)
        return 0;

    length = (AV_RB16(buf) & 0xfff) * 2;

1074
    if (length < 4 || length > buf_size)
1075
        return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
1076 1077 1078

    init_get_bits(&gb, (buf + 4), (length - 4) * 8);

1079
    m->is_major_sync_unit = 0;
Ramiro Polla's avatar
Ramiro Polla committed
1080 1081 1082
    if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
        if (read_major_sync(m, &gb) < 0)
            goto error;
1083
        m->is_major_sync_unit = 1;
Ramiro Polla's avatar
Ramiro Polla committed
1084 1085 1086 1087 1088
        header_size += 28;
    }

    if (!m->params_valid) {
        av_log(m->avctx, AV_LOG_WARNING,
Diego Biurrun's avatar
Diego Biurrun committed
1089
               "Stream parameters not seen; skipping frame.\n");
1090
        *got_frame_ptr = 0;
Ramiro Polla's avatar
Ramiro Polla committed
1091 1092 1093 1094 1095 1096
        return length;
    }

    substream_start = 0;

    for (substr = 0; substr < m->num_substreams; substr++) {
1097
        int extraword_present, checkdata_present, end, nonrestart_substr;
Ramiro Polla's avatar
Ramiro Polla committed
1098 1099

        extraword_present = get_bits1(&gb);
1100
        nonrestart_substr = get_bits1(&gb);
Ramiro Polla's avatar
Ramiro Polla committed
1101 1102 1103 1104 1105 1106 1107 1108
        checkdata_present = get_bits1(&gb);
        skip_bits1(&gb);

        end = get_bits(&gb, 12) * 2;

        substr_header_size += 2;

        if (extraword_present) {
1109
            if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
1110 1111 1112
                av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
                goto error;
            }
Ramiro Polla's avatar
Ramiro Polla committed
1113 1114 1115 1116
            skip_bits(&gb, 16);
            substr_header_size += 2;
        }

1117 1118 1119 1120 1121
        if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
            av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
            goto error;
        }

Ramiro Polla's avatar
Ramiro Polla committed
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
        if (end + header_size + substr_header_size > length) {
            av_log(m->avctx, AV_LOG_ERROR,
                   "Indicated length of substream %d data goes off end of "
                   "packet.\n", substr);
            end = length - header_size - substr_header_size;
        }

        if (end < substream_start) {
            av_log(avctx, AV_LOG_ERROR,
                   "Indicated end offset of substream %d data "
                   "is smaller than calculated start offset.\n",
                   substr);
            goto error;
        }

        if (substr > m->max_decoded_substream)
            continue;

        substream_parity_present[substr] = checkdata_present;
        substream_data_len[substr] = end - substream_start;
        substream_start = end;
    }

1145 1146
    parity_bits  = ff_mlp_calculate_parity(buf, 4);
    parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
Ramiro Polla's avatar
Ramiro Polla committed
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158

    if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
        av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
        goto error;
    }

    buf += header_size + substr_header_size;

    for (substr = 0; substr <= m->max_decoded_substream; substr++) {
        SubStream *s = &m->substream[substr];
        init_get_bits(&gb, buf, substream_data_len[substr] * 8);

1159 1160 1161
        m->matrix_changed = 0;
        memset(m->filter_changed, 0, sizeof(m->filter_changed));

Ramiro Polla's avatar
Ramiro Polla committed
1162 1163 1164 1165
        s->blockpos = 0;
        do {
            if (get_bits1(&gb)) {
                if (get_bits1(&gb)) {
Diego Biurrun's avatar
Diego Biurrun committed
1166
                    /* A restart header should be present. */
Ramiro Polla's avatar
Ramiro Polla committed
1167 1168 1169 1170 1171
                    if (read_restart_header(m, &gb, buf, substr) < 0)
                        goto next_substr;
                    s->restart_seen = 1;
                }

1172
                if (!s->restart_seen)
Ramiro Polla's avatar
Ramiro Polla committed
1173 1174 1175 1176 1177
                    goto next_substr;
                if (read_decoding_params(m, &gb, substr) < 0)
                    goto next_substr;
            }

1178
            if (!s->restart_seen)
Ramiro Polla's avatar
Ramiro Polla committed
1179 1180
                goto next_substr;

1181 1182
            if ((ret = read_block_data(m, &gb, substr)) < 0)
                return ret;
Ramiro Polla's avatar
Ramiro Polla committed
1183

1184 1185 1186 1187
            if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
                goto substream_length_mismatch;

        } while (!get_bits1(&gb));
Ramiro Polla's avatar
Ramiro Polla committed
1188 1189

        skip_bits(&gb, (-get_bits_count(&gb)) & 15);
1190

1191 1192 1193 1194
        if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
            int shorten_by;

            if (get_bits(&gb, 16) != 0xD234)
1195
                return AVERROR_INVALIDDATA;
1196 1197

            shorten_by = get_bits(&gb, 16);
1198
            if      (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by  & 0x2000)
1199
                s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
1200
            else if (m->avctx->codec_id == AV_CODEC_ID_MLP    && shorten_by != 0xD234)
1201
                return AVERROR_INVALIDDATA;
1202

Ramiro Polla's avatar
Ramiro Polla committed
1203
            if (substr == m->max_decoded_substream)
Diego Biurrun's avatar
Diego Biurrun committed
1204
                av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
Ramiro Polla's avatar
Ramiro Polla committed
1205
        }
1206

1207
        if (substream_parity_present[substr]) {
Ramiro Polla's avatar
Ramiro Polla committed
1208 1209
            uint8_t parity, checksum;

1210 1211 1212
            if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
                goto substream_length_mismatch;

1213 1214
            parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
            checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
Ramiro Polla's avatar
Ramiro Polla committed
1215

1216 1217 1218 1219
            if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
            if ( get_bits(&gb, 8)           != checksum)
                av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
Ramiro Polla's avatar
Ramiro Polla committed
1220
        }
1221 1222

        if (substream_data_len[substr] * 8 != get_bits_count(&gb))
1223
            goto substream_length_mismatch;
Ramiro Polla's avatar
Ramiro Polla committed
1224 1225

next_substr:
1226
        if (!s->restart_seen)
1227 1228 1229
            av_log(m->avctx, AV_LOG_ERROR,
                   "No restart header present in substream %d.\n", substr);

Ramiro Polla's avatar
Ramiro Polla committed
1230 1231 1232 1233 1234
        buf += substream_data_len[substr];
    }

    rematrix_channels(m, m->max_decoded_substream);

1235
    if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1236
        return ret;
Ramiro Polla's avatar
Ramiro Polla committed
1237 1238 1239

    return length;

1240 1241
substream_length_mismatch:
    av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
1242
    return AVERROR_INVALIDDATA;
1243

Ramiro Polla's avatar
Ramiro Polla committed
1244 1245
error:
    m->params_valid = 0;
1246
    return AVERROR_INVALIDDATA;
Ramiro Polla's avatar
Ramiro Polla committed
1247 1248
}

1249
#if CONFIG_MLP_DECODER
1250
AVCodec ff_mlp_decoder = {
1251 1252
    .name           = "mlp",
    .type           = AVMEDIA_TYPE_AUDIO,
1253
    .id             = AV_CODEC_ID_MLP,
1254 1255 1256
    .priv_data_size = sizeof(MLPDecodeContext),
    .init           = mlp_decode_init,
    .decode         = read_access_unit,
1257
    .capabilities   = CODEC_CAP_DR1,
1258
    .long_name      = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
Ramiro Polla's avatar
Ramiro Polla committed
1259
};
1260
#endif
1261
#if CONFIG_TRUEHD_DECODER
1262
AVCodec ff_truehd_decoder = {
1263 1264
    .name           = "truehd",
    .type           = AVMEDIA_TYPE_AUDIO,
1265
    .id             = AV_CODEC_ID_TRUEHD,
1266 1267 1268
    .priv_data_size = sizeof(MLPDecodeContext),
    .init           = mlp_decode_init,
    .decode         = read_access_unit,
1269
    .capabilities   = CODEC_CAP_DR1,
1270
    .long_name      = NULL_IF_CONFIG_SMALL("TrueHD"),
1271 1272
};
#endif /* CONFIG_TRUEHD_DECODER */