GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mlpenc.c Lines: 0 1150 0.0 %
Date: 2019-11-22 03:34:36 Branches: 0 496 0.0 %

Line Branch Exec Source
1
/**
2
 * MLP encoder
3
 * Copyright (c) 2008 Ramiro Polla
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
#include "avcodec.h"
23
#include "internal.h"
24
#include "put_bits.h"
25
#include "audio_frame_queue.h"
26
#include "libavutil/crc.h"
27
#include "libavutil/avstring.h"
28
#include "libavutil/samplefmt.h"
29
#include "mlp.h"
30
#include "lpc.h"
31
32
#define MAJOR_HEADER_INTERVAL 16
33
34
#define MLP_MIN_LPC_ORDER      1
35
#define MLP_MAX_LPC_ORDER      8
36
#define MLP_MIN_LPC_SHIFT      8
37
#define MLP_MAX_LPC_SHIFT     15
38
39
typedef struct {
40
    uint8_t         min_channel;         ///< The index of the first channel coded in this substream.
41
    uint8_t         max_channel;         ///< The index of the last channel coded in this substream.
42
    uint8_t         max_matrix_channel;  ///< The number of channels input into the rematrix stage.
43
44
    uint8_t         noise_shift;         ///< The left shift applied to random noise in 0x31ea substreams.
45
    uint32_t        noisegen_seed;       ///< The current seed value for the pseudorandom noise generator(s).
46
47
    int             data_check_present;  ///< Set if the substream contains extra info to check the size of VLC blocks.
48
49
    int32_t         lossless_check_data; ///< XOR of all output samples
50
51
    uint8_t         max_huff_lsbs;       ///< largest huff_lsbs
52
    uint8_t         max_output_bits;     ///< largest output bit-depth
53
} RestartHeader;
54
55
typedef struct {
56
    uint8_t         count;                  ///< number of matrices to apply
57
58
    uint8_t         outch[MAX_MATRICES];    ///< output channel for each matrix
59
    int32_t         forco[MAX_MATRICES][MAX_CHANNELS+2];    ///< forward coefficients
60
    int32_t         coeff[MAX_MATRICES][MAX_CHANNELS+2];    ///< decoding coefficients
61
    uint8_t         fbits[MAX_CHANNELS];    ///< fraction bits
62
63
    int8_t          shift[MAX_CHANNELS];    ///< Left shift to apply to decoded PCM values to get final 24-bit output.
64
} MatrixParams;
65
66
enum ParamFlags {
67
    PARAMS_DEFAULT       = 0xff,
68
    PARAM_PRESENCE_FLAGS = 1 << 8,
69
    PARAM_BLOCKSIZE      = 1 << 7,
70
    PARAM_MATRIX         = 1 << 6,
71
    PARAM_OUTSHIFT       = 1 << 5,
72
    PARAM_QUANTSTEP      = 1 << 4,
73
    PARAM_FIR            = 1 << 3,
74
    PARAM_IIR            = 1 << 2,
75
    PARAM_HUFFOFFSET     = 1 << 1,
76
    PARAM_PRESENT        = 1 << 0,
77
};
78
79
typedef struct {
80
    uint16_t        blocksize;                  ///< number of PCM samples in current audio block
81
    uint8_t         quant_step_size[MAX_CHANNELS];  ///< left shift to apply to Huffman-decoded residuals
82
83
    MatrixParams    matrix_params;
84
85
    uint8_t         param_presence_flags;       ///< Bitmask of which parameter sets are conveyed in a decoding parameter block.
86
} DecodingParams;
87
88
typedef struct BestOffset {
89
    int16_t offset;
90
    int bitcount;
91
    int lsb_bits;
92
    int16_t min;
93
    int16_t max;
94
} BestOffset;
95
96
#define HUFF_OFFSET_MIN    -16384
97
#define HUFF_OFFSET_MAX     16383
98
99
/** Number of possible codebooks (counting "no codebooks") */
100
#define NUM_CODEBOOKS       4
101
102
typedef struct {
103
    AVCodecContext *avctx;
104
105
    int             num_substreams;         ///< Number of substreams contained within this stream.
106
107
    int             num_channels;   /**< Number of channels in major_scratch_buffer.
108
                                     *   Normal channels + noise channels. */
109
110
    int             coded_sample_fmt [2];   ///< sample format encoded for MLP
111
    int             coded_sample_rate[2];   ///< sample rate encoded for MLP
112
    int             coded_peak_bitrate;     ///< peak bitrate for this major sync header
113
114
    int             flags;                  ///< major sync info flags
115
116
    /* channel_meaning */
117
    int             substream_info;
118
    int             fs;
119
    int             wordlength;
120
    int             channel_occupancy;
121
    int             summary_info;
122
123
    int32_t        *inout_buffer;           ///< Pointer to data currently being read from lavc or written to bitstream.
124
    int32_t        *major_inout_buffer;     ///< Buffer with all in/out data for one entire major frame interval.
125
    int32_t        *write_buffer;           ///< Pointer to data currently being written to bitstream.
126
    int32_t        *sample_buffer;          ///< Pointer to current access unit samples.
127
    int32_t        *major_scratch_buffer;   ///< Scratch buffer big enough to fit all data for one entire major frame interval.
128
    int32_t        *last_frame;             ///< Pointer to last frame with data to encode.
129
130
    int32_t        *lpc_sample_buffer;
131
132
    unsigned int    major_number_of_frames;
133
    unsigned int    next_major_number_of_frames;
134
135
    unsigned int    major_frame_size;       ///< Number of samples in current major frame being encoded.
136
    unsigned int    next_major_frame_size;  ///< Counter of number of samples for next major frame.
137
138
    int32_t        *lossless_check_data;    ///< Array with lossless_check_data for each access unit.
139
140
    unsigned int   *max_output_bits;        ///< largest output bit-depth
141
    unsigned int   *frame_size;             ///< Array with number of samples/channel in each access unit.
142
    unsigned int    frame_index;            ///< Index of current frame being encoded.
143
144
    unsigned int    one_sample_buffer_size; ///< Number of samples*channel for one access unit.
145
146
    unsigned int    max_restart_interval;   ///< Max interval of access units in between two major frames.
147
    unsigned int    min_restart_interval;   ///< Min interval of access units in between two major frames.
148
    unsigned int    restart_intervals;      ///< Number of possible major frame sizes.
149
150
    uint16_t        timestamp;              ///< Timestamp of current access unit.
151
    uint16_t        dts;                    ///< Decoding timestamp of current access unit.
152
153
    uint8_t         channel_arrangement;    ///< channel arrangement for MLP streams
154
155
    uint8_t         ch_modifier_thd0;       ///< channel modifier for TrueHD stream 0
156
    uint8_t         ch_modifier_thd1;       ///< channel modifier for TrueHD stream 1
157
    uint8_t         ch_modifier_thd2;       ///< channel modifier for TrueHD stream 2
158
159
    unsigned int    seq_size  [MAJOR_HEADER_INTERVAL];
160
    unsigned int    seq_offset[MAJOR_HEADER_INTERVAL];
161
    unsigned int    sequence_size;
162
163
    ChannelParams  *channel_params;
164
165
    BestOffset      best_offset[MAJOR_HEADER_INTERVAL+1][MAX_CHANNELS][NUM_CODEBOOKS];
166
167
    DecodingParams *decoding_params;
168
    RestartHeader   restart_header [MAX_SUBSTREAMS];
169
170
    ChannelParams   major_channel_params[MAJOR_HEADER_INTERVAL+1][MAX_CHANNELS];       ///< ChannelParams to be written to bitstream.
171
    DecodingParams  major_decoding_params[MAJOR_HEADER_INTERVAL+1][MAX_SUBSTREAMS];    ///< DecodingParams to be written to bitstream.
172
    int             major_params_changed[MAJOR_HEADER_INTERVAL+1][MAX_SUBSTREAMS];     ///< params_changed to be written to bitstream.
173
174
    unsigned int    major_cur_subblock_index;
175
    unsigned int    major_filter_state_subblock;
176
    unsigned int    major_number_of_subblocks;
177
178
    BestOffset    (*cur_best_offset)[NUM_CODEBOOKS];
179
    ChannelParams  *cur_channel_params;
180
    DecodingParams *cur_decoding_params;
181
    RestartHeader  *cur_restart_header;
182
183
    AudioFrameQueue afq;
184
185
    /* Analysis stage. */
186
    unsigned int    starting_frame_index;
187
    unsigned int    number_of_frames;
188
    unsigned int    number_of_samples;
189
    unsigned int    number_of_subblocks;
190
    unsigned int    seq_index;              ///< Sequence index for high compression levels.
191
192
    ChannelParams  *prev_channel_params;
193
    DecodingParams *prev_decoding_params;
194
195
    ChannelParams  *seq_channel_params;
196
    DecodingParams *seq_decoding_params;
197
198
    unsigned int    max_codebook_search;
199
200
    LPCContext      lpc_ctx;
201
} MLPEncodeContext;
202
203
static ChannelParams   restart_channel_params[MAX_CHANNELS];
204
static DecodingParams  restart_decoding_params[MAX_SUBSTREAMS];
205
static BestOffset      restart_best_offset[NUM_CODEBOOKS] = {{0}};
206
207
#define SYNC_MAJOR      0xf8726f
208
#define MAJOR_SYNC_INFO_SIGNATURE   0xB752
209
210
#define SYNC_MLP        0xbb
211
#define SYNC_TRUEHD     0xba
212
213
/* must be set for DVD-A */
214
#define FLAGS_DVDA      0x4000
215
/* FIFO delay must be constant */
216
#define FLAGS_CONST     0x8000
217
218
#define SUBSTREAM_INFO_MAX_2_CHAN   0x01
219
#define SUBSTREAM_INFO_HIGH_RATE    0x02
220
#define SUBSTREAM_INFO_ALWAYS_SET   0x04
221
#define SUBSTREAM_INFO_2_SUBSTREAMS 0x08
222
223
/****************************************************************************
224
 ************ Functions that copy, clear, or compare parameters *************
225
 ****************************************************************************/
226
227
/** Compares two FilterParams structures and returns 1 if anything has
228
 *  changed. Returns 0 if they are both equal.
229
 */
230
static int compare_filter_params(const ChannelParams *prev_cp, const ChannelParams *cp, int filter)
231
{
232
    const FilterParams *prev = &prev_cp->filter_params[filter];
233
    const FilterParams *fp = &cp->filter_params[filter];
234
    int i;
235
236
    if (prev->order != fp->order)
237
        return 1;
238
239
    if (!prev->order)
240
        return 0;
241
242
    if (prev->shift != fp->shift)
243
        return 1;
244
245
    for (i = 0; i < fp->order; i++)
246
        if (prev_cp->coeff[filter][i] != cp->coeff[filter][i])
247
            return 1;
248
249
    return 0;
250
}
251
252
/** Compare two primitive matrices and returns 1 if anything has changed.
253
 *  Returns 0 if they are both equal.
254
 */
255
static int compare_matrix_params(MLPEncodeContext *ctx, const MatrixParams *prev, const MatrixParams *mp)
256
{
257
    RestartHeader *rh = ctx->cur_restart_header;
258
    unsigned int channel, mat;
259
260
    if (prev->count != mp->count)
261
        return 1;
262
263
    if (!prev->count)
264
        return 0;
265
266
    for (channel = rh->min_channel; channel <= rh->max_channel; channel++)
267
        if (prev->fbits[channel] != mp->fbits[channel])
268
            return 1;
269
270
    for (mat = 0; mat < mp->count; mat++) {
271
        if (prev->outch[mat] != mp->outch[mat])
272
            return 1;
273
274
        for (channel = 0; channel < ctx->num_channels; channel++)
275
            if (prev->coeff[mat][channel] != mp->coeff[mat][channel])
276
                return 1;
277
    }
278
279
    return 0;
280
}
281
282
/** Compares two DecodingParams and ChannelParams structures to decide if a
283
 *  new decoding params header has to be written.
284
 */
285
static int compare_decoding_params(MLPEncodeContext *ctx)
286
{
287
    DecodingParams *prev = ctx->prev_decoding_params;
288
    DecodingParams *dp = ctx->cur_decoding_params;
289
    MatrixParams *prev_mp = &prev->matrix_params;
290
    MatrixParams *mp = &dp->matrix_params;
291
    RestartHeader  *rh = ctx->cur_restart_header;
292
    unsigned int ch;
293
    int retval = 0;
294
295
    if (prev->param_presence_flags != dp->param_presence_flags)
296
        retval |= PARAM_PRESENCE_FLAGS;
297
298
    if (prev->blocksize != dp->blocksize)
299
        retval |= PARAM_BLOCKSIZE;
300
301
    if (compare_matrix_params(ctx, prev_mp, mp))
302
        retval |= PARAM_MATRIX;
303
304
    for (ch = 0; ch <= rh->max_matrix_channel; ch++)
305
        if (prev_mp->shift[ch] != mp->shift[ch]) {
306
            retval |= PARAM_OUTSHIFT;
307
            break;
308
        }
309
310
    for (ch = 0; ch <= rh->max_channel; ch++)
311
        if (prev->quant_step_size[ch] != dp->quant_step_size[ch]) {
312
            retval |= PARAM_QUANTSTEP;
313
            break;
314
        }
315
316
    for (ch = rh->min_channel; ch <= rh->max_channel; ch++) {
317
        ChannelParams *prev_cp = &ctx->prev_channel_params[ch];
318
        ChannelParams *cp = &ctx->cur_channel_params[ch];
319
320
        if (!(retval & PARAM_FIR) &&
321
            compare_filter_params(prev_cp, cp, FIR))
322
            retval |= PARAM_FIR;
323
324
        if (!(retval & PARAM_IIR) &&
325
            compare_filter_params(prev_cp, cp, IIR))
326
            retval |= PARAM_IIR;
327
328
        if (prev_cp->huff_offset != cp->huff_offset)
329
            retval |= PARAM_HUFFOFFSET;
330
331
        if (prev_cp->codebook    != cp->codebook  ||
332
            prev_cp->huff_lsbs   != cp->huff_lsbs  )
333
            retval |= 0x1;
334
    }
335
336
    return retval;
337
}
338
339
static void copy_filter_params(ChannelParams *dst_cp, ChannelParams *src_cp, int filter)
340
{
341
    FilterParams *dst = &dst_cp->filter_params[filter];
342
    FilterParams *src = &src_cp->filter_params[filter];
343
    unsigned int order;
344
345
    dst->order = src->order;
346
347
    if (dst->order) {
348
        dst->shift = src->shift;
349
350
        dst->coeff_shift = src->coeff_shift;
351
        dst->coeff_bits = src->coeff_bits;
352
    }
353
354
    for (order = 0; order < dst->order; order++)
355
        dst_cp->coeff[filter][order] = src_cp->coeff[filter][order];
356
}
357
358
static void copy_matrix_params(MatrixParams *dst, MatrixParams *src)
359
{
360
    dst->count = src->count;
361
362
    if (dst->count) {
363
        unsigned int channel, count;
364
365
        for (channel = 0; channel < MAX_CHANNELS; channel++) {
366
367
            dst->fbits[channel] = src->fbits[channel];
368
            dst->shift[channel] = src->shift[channel];
369
370
            for (count = 0; count < MAX_MATRICES; count++)
371
                dst->coeff[count][channel] = src->coeff[count][channel];
372
        }
373
374
        for (count = 0; count < MAX_MATRICES; count++)
375
            dst->outch[count] = src->outch[count];
376
    }
377
}
378
379
static void copy_restart_frame_params(MLPEncodeContext *ctx,
380
                                      unsigned int substr)
381
{
382
    unsigned int index;
383
384
    for (index = 0; index < ctx->number_of_subblocks; index++) {
385
        DecodingParams *dp = ctx->seq_decoding_params + index*(ctx->num_substreams) + substr;
386
        unsigned int channel;
387
388
        copy_matrix_params(&dp->matrix_params, &ctx->cur_decoding_params->matrix_params);
389
390
        for (channel = 0; channel < ctx->avctx->channels; channel++) {
391
            ChannelParams *cp = ctx->seq_channel_params + index*(ctx->avctx->channels) + channel;
392
            unsigned int filter;
393
394
            dp->quant_step_size[channel] = ctx->cur_decoding_params->quant_step_size[channel];
395
            dp->matrix_params.shift[channel] = ctx->cur_decoding_params->matrix_params.shift[channel];
396
397
            if (index)
398
                for (filter = 0; filter < NUM_FILTERS; filter++)
399
                    copy_filter_params(cp, &ctx->cur_channel_params[channel], filter);
400
        }
401
    }
402
}
403
404
/** Clears a DecodingParams struct the way it should be after a restart header. */
405
static void clear_decoding_params(MLPEncodeContext *ctx, DecodingParams decoding_params[MAX_SUBSTREAMS])
406
{
407
    unsigned int substr;
408
409
    for (substr = 0; substr < ctx->num_substreams; substr++) {
410
        DecodingParams *dp = &decoding_params[substr];
411
412
        dp->param_presence_flags   = 0xff;
413
        dp->blocksize              = 8;
414
415
        memset(&dp->matrix_params , 0, sizeof(MatrixParams       ));
416
        memset(dp->quant_step_size, 0, sizeof(dp->quant_step_size));
417
    }
418
}
419
420
/** Clears a ChannelParams struct the way it should be after a restart header. */
421
static void clear_channel_params(MLPEncodeContext *ctx, ChannelParams channel_params[MAX_CHANNELS])
422
{
423
    unsigned int channel;
424
425
    for (channel = 0; channel < ctx->avctx->channels; channel++) {
426
        ChannelParams *cp = &channel_params[channel];
427
428
        memset(&cp->filter_params, 0, sizeof(cp->filter_params));
429
430
        /* Default audio coding is 24-bit raw PCM. */
431
        cp->huff_offset      =  0;
432
        cp->codebook         =  0;
433
        cp->huff_lsbs        = 24;
434
    }
435
}
436
437
/** Sets default vales in our encoder for a DecodingParams struct. */
438
static void default_decoding_params(MLPEncodeContext *ctx,
439
     DecodingParams decoding_params[MAX_SUBSTREAMS])
440
{
441
    unsigned int substr;
442
443
    clear_decoding_params(ctx, decoding_params);
444
445
    for (substr = 0; substr < ctx->num_substreams; substr++) {
446
        DecodingParams *dp = &decoding_params[substr];
447
        uint8_t param_presence_flags = 0;
448
449
        param_presence_flags |= PARAM_BLOCKSIZE;
450
        param_presence_flags |= PARAM_MATRIX;
451
        param_presence_flags |= PARAM_OUTSHIFT;
452
        param_presence_flags |= PARAM_QUANTSTEP;
453
        param_presence_flags |= PARAM_FIR;
454
/*      param_presence_flags |= PARAM_IIR; */
455
        param_presence_flags |= PARAM_HUFFOFFSET;
456
        param_presence_flags |= PARAM_PRESENT;
457
458
        dp->param_presence_flags = param_presence_flags;
459
    }
460
}
461
462
/****************************************************************************/
463
464
/** Calculates the smallest number of bits it takes to encode a given signed
465
 *  value in two's complement.
466
 */
467
static int inline number_sbits(int number)
468
{
469
    if (number < 0)
470
        number++;
471
472
    return av_log2(FFABS(number)) + 1 + !!number;
473
}
474
475
enum InputBitDepth {
476
    BITS_16,
477
    BITS_20,
478
    BITS_24,
479
};
480
481
static int mlp_peak_bitrate(int peak_bitrate, int sample_rate)
482
{
483
    return ((peak_bitrate << 4) - 8) / sample_rate;
484
}
485
486
static av_cold int mlp_encode_init(AVCodecContext *avctx)
487
{
488
    MLPEncodeContext *ctx = avctx->priv_data;
489
    unsigned int substr, index;
490
    unsigned int sum = 0;
491
    unsigned int size;
492
    int ret;
493
494
    ctx->avctx = avctx;
495
496
    switch (avctx->sample_rate) {
497
    case 44100 << 0:
498
        avctx->frame_size         = 40  << 0;
499
        ctx->coded_sample_rate[0] = 0x08 + 0;
500
        ctx->fs                   = 0x08 + 1;
501
        break;
502
    case 44100 << 1:
503
        avctx->frame_size         = 40  << 1;
504
        ctx->coded_sample_rate[0] = 0x08 + 1;
505
        ctx->fs                   = 0x0C + 1;
506
        break;
507
    case 44100 << 2:
508
        ctx->substream_info      |= SUBSTREAM_INFO_HIGH_RATE;
509
        avctx->frame_size         = 40  << 2;
510
        ctx->coded_sample_rate[0] = 0x08 + 2;
511
        ctx->fs                   = 0x10 + 1;
512
        break;
513
    case 48000 << 0:
514
        avctx->frame_size         = 40  << 0;
515
        ctx->coded_sample_rate[0] = 0x00 + 0;
516
        ctx->fs                   = 0x08 + 2;
517
        break;
518
    case 48000 << 1:
519
        avctx->frame_size         = 40  << 1;
520
        ctx->coded_sample_rate[0] = 0x00 + 1;
521
        ctx->fs                   = 0x0C + 2;
522
        break;
523
    case 48000 << 2:
524
        ctx->substream_info      |= SUBSTREAM_INFO_HIGH_RATE;
525
        avctx->frame_size         = 40  << 2;
526
        ctx->coded_sample_rate[0] = 0x00 + 2;
527
        ctx->fs                   = 0x10 + 2;
528
        break;
529
    default:
530
        av_log(avctx, AV_LOG_ERROR, "Unsupported sample rate %d. Supported "
531
                            "sample rates are 44100, 88200, 176400, 48000, "
532
                            "96000, and 192000.\n", avctx->sample_rate);
533
        return -1;
534
    }
535
    ctx->coded_sample_rate[1] = -1 & 0xf;
536
537
    /* TODO Keep count of bitrate and calculate real value. */
538
    ctx->coded_peak_bitrate = mlp_peak_bitrate(9600000, avctx->sample_rate);
539
540
    /* TODO support more channels. */
541
    if (avctx->channels > 2) {
542
        av_log(avctx, AV_LOG_WARNING,
543
               "Only mono and stereo are supported at the moment.\n");
544
    }
545
546
    ctx->substream_info |= SUBSTREAM_INFO_ALWAYS_SET;
547
    if (avctx->channels <= 2) {
548
        ctx->substream_info |= SUBSTREAM_INFO_MAX_2_CHAN;
549
    }
550
551
    switch (avctx->sample_fmt) {
552
    case AV_SAMPLE_FMT_S16:
553
        ctx->coded_sample_fmt[0] = BITS_16;
554
        ctx->wordlength = 16;
555
        avctx->bits_per_raw_sample = 16;
556
        break;
557
    /* TODO 20 bits: */
558
    case AV_SAMPLE_FMT_S32:
559
        ctx->coded_sample_fmt[0] = BITS_24;
560
        ctx->wordlength = 24;
561
        avctx->bits_per_raw_sample = 24;
562
        break;
563
    default:
564
        av_log(avctx, AV_LOG_ERROR, "Sample format not supported. "
565
               "Only 16- and 24-bit samples are supported.\n");
566
        return -1;
567
    }
568
    ctx->coded_sample_fmt[1] = -1 & 0xf;
569
570
    ctx->dts = -avctx->frame_size;
571
572
    ctx->num_channels = avctx->channels + 2; /* +2 noise channels */
573
    ctx->one_sample_buffer_size = avctx->frame_size
574
                                * ctx->num_channels;
575
    /* TODO Let user pass major header interval as parameter. */
576
    ctx->max_restart_interval = MAJOR_HEADER_INTERVAL;
577
578
    ctx->max_codebook_search = 3;
579
    ctx->min_restart_interval = MAJOR_HEADER_INTERVAL;
580
    ctx->restart_intervals = ctx->max_restart_interval / ctx->min_restart_interval;
581
582
    /* TODO Let user pass parameters for LPC filter. */
583
584
    size = avctx->frame_size * ctx->max_restart_interval;
585
586
    ctx->lpc_sample_buffer = av_malloc_array(size, sizeof(int32_t));
587
    if (!ctx->lpc_sample_buffer) {
588
        av_log(avctx, AV_LOG_ERROR,
589
               "Not enough memory for buffering samples.\n");
590
        return AVERROR(ENOMEM);
591
    }
592
593
    size = ctx->one_sample_buffer_size * ctx->max_restart_interval;
594
595
    ctx->major_scratch_buffer = av_malloc_array(size, sizeof(int32_t));
596
    if (!ctx->major_scratch_buffer) {
597
        av_log(avctx, AV_LOG_ERROR,
598
               "Not enough memory for buffering samples.\n");
599
        return AVERROR(ENOMEM);
600
    }
601
602
    ctx->major_inout_buffer = av_malloc_array(size, sizeof(int32_t));
603
    if (!ctx->major_inout_buffer) {
604
        av_log(avctx, AV_LOG_ERROR,
605
               "Not enough memory for buffering samples.\n");
606
        return AVERROR(ENOMEM);
607
    }
608
609
    ff_mlp_init_crc();
610
611
    ctx->num_substreams = 1; // TODO: change this after adding multi-channel support for TrueHD
612
613
    if (ctx->avctx->codec_id == AV_CODEC_ID_MLP) {
614
        /* MLP */
615
        switch(avctx->channel_layout) {
616
        case AV_CH_LAYOUT_MONO:
617
            ctx->channel_arrangement = 0; break;
618
        case AV_CH_LAYOUT_STEREO:
619
            ctx->channel_arrangement = 1; break;
620
        case AV_CH_LAYOUT_2_1:
621
            ctx->channel_arrangement = 2; break;
622
        case AV_CH_LAYOUT_QUAD:
623
            ctx->channel_arrangement = 3; break;
624
        case AV_CH_LAYOUT_2POINT1:
625
            ctx->channel_arrangement = 4; break;
626
        case AV_CH_LAYOUT_SURROUND:
627
            ctx->channel_arrangement = 7; break;
628
        case AV_CH_LAYOUT_4POINT0:
629
            ctx->channel_arrangement = 8; break;
630
        case AV_CH_LAYOUT_5POINT0_BACK:
631
            ctx->channel_arrangement = 9; break;
632
        case AV_CH_LAYOUT_3POINT1:
633
            ctx->channel_arrangement = 10; break;
634
        case AV_CH_LAYOUT_4POINT1:
635
            ctx->channel_arrangement = 11; break;
636
        case AV_CH_LAYOUT_5POINT1_BACK:
637
            ctx->channel_arrangement = 12; break;
638
        default:
639
            av_log(avctx, AV_LOG_ERROR, "Unsupported channel arrangement\n");
640
            return -1;
641
        }
642
        ctx->flags = FLAGS_DVDA;
643
        ctx->channel_occupancy = ff_mlp_ch_info[ctx->channel_arrangement].channel_occupancy;
644
        ctx->summary_info      = ff_mlp_ch_info[ctx->channel_arrangement].summary_info     ;
645
    } else {
646
        /* TrueHD */
647
        switch(avctx->channel_layout) {
648
        case AV_CH_LAYOUT_STEREO:
649
            ctx->ch_modifier_thd0    = 0;
650
            ctx->ch_modifier_thd1    = 0;
651
            ctx->ch_modifier_thd2    = 0;
652
            ctx->channel_arrangement = 1;
653
            break;
654
        case AV_CH_LAYOUT_5POINT0_BACK:
655
            ctx->ch_modifier_thd0    = 1;
656
            ctx->ch_modifier_thd1    = 1;
657
            ctx->ch_modifier_thd2    = 1;
658
            ctx->channel_arrangement = 11;
659
            break;
660
        case AV_CH_LAYOUT_5POINT1_BACK:
661
            ctx->ch_modifier_thd0    = 2;
662
            ctx->ch_modifier_thd1    = 1;
663
            ctx->ch_modifier_thd2    = 2;
664
            ctx->channel_arrangement = 15;
665
            break;
666
        default:
667
            av_log(avctx, AV_LOG_ERROR, "Unsupported channel arrangement\n");
668
            return -1;
669
        }
670
        ctx->flags = 0;
671
        ctx->channel_occupancy = 0;
672
        ctx->summary_info = 0;
673
    }
674
675
    size = sizeof(unsigned int) * ctx->max_restart_interval;
676
677
    ctx->frame_size = av_malloc(size);
678
    if (!ctx->frame_size)
679
        return AVERROR(ENOMEM);
680
681
    ctx->max_output_bits = av_malloc(size);
682
    if (!ctx->max_output_bits)
683
        return AVERROR(ENOMEM);
684
685
    size = sizeof(int32_t)
686
         * ctx->num_substreams * ctx->max_restart_interval;
687
688
    ctx->lossless_check_data = av_malloc(size);
689
    if (!ctx->lossless_check_data)
690
        return AVERROR(ENOMEM);
691
692
    for (index = 0; index < ctx->restart_intervals; index++) {
693
        ctx->seq_offset[index] = sum;
694
        ctx->seq_size  [index] = ((index + 1) * ctx->min_restart_interval) + 1;
695
        sum += ctx->seq_size[index];
696
    }
697
    ctx->sequence_size = sum;
698
    size = sizeof(ChannelParams)
699
         * ctx->restart_intervals * ctx->sequence_size * ctx->avctx->channels;
700
    ctx->channel_params = av_malloc(size);
701
    if (!ctx->channel_params) {
702
        av_log(avctx, AV_LOG_ERROR,
703
               "Not enough memory for analysis context.\n");
704
        return AVERROR(ENOMEM);
705
    }
706
707
    size = sizeof(DecodingParams)
708
         * ctx->restart_intervals * ctx->sequence_size * ctx->num_substreams;
709
    ctx->decoding_params = av_malloc(size);
710
    if (!ctx->decoding_params) {
711
        av_log(avctx, AV_LOG_ERROR,
712
               "Not enough memory for analysis context.\n");
713
        return AVERROR(ENOMEM);
714
    }
715
716
    for (substr = 0; substr < ctx->num_substreams; substr++) {
717
        RestartHeader  *rh = &ctx->restart_header [substr];
718
719
        /* TODO see if noisegen_seed is really worth it. */
720
        rh->noisegen_seed      = 0;
721
722
        rh->min_channel        = 0;
723
        rh->max_channel        = avctx->channels - 1;
724
        /* FIXME: this works for 1 and 2 channels, but check for more */
725
        rh->max_matrix_channel = rh->max_channel;
726
    }
727
728
    clear_channel_params(ctx, restart_channel_params);
729
    clear_decoding_params(ctx, restart_decoding_params);
730
731
    if ((ret = ff_lpc_init(&ctx->lpc_ctx, ctx->number_of_samples,
732
                    MLP_MAX_LPC_ORDER, FF_LPC_TYPE_LEVINSON)) < 0) {
733
        av_log(avctx, AV_LOG_ERROR,
734
               "Not enough memory for LPC context.\n");
735
        return ret;
736
    }
737
738
    ff_af_queue_init(avctx, &ctx->afq);
739
740
    return 0;
741
}
742
743
/****************************************************************************
744
 ****************** Functions that write to the bitstream *******************
745
 ****************************************************************************/
746
747
/** Writes a major sync header to the bitstream. */
748
static void write_major_sync(MLPEncodeContext *ctx, uint8_t *buf, int buf_size)
749
{
750
    PutBitContext pb;
751
752
    init_put_bits(&pb, buf, buf_size);
753
754
    put_bits(&pb, 24, SYNC_MAJOR               );
755
756
    if (ctx->avctx->codec_id == AV_CODEC_ID_MLP) {
757
        put_bits(&pb,  8, SYNC_MLP                 );
758
        put_bits(&pb,  4, ctx->coded_sample_fmt [0]);
759
        put_bits(&pb,  4, ctx->coded_sample_fmt [1]);
760
        put_bits(&pb,  4, ctx->coded_sample_rate[0]);
761
        put_bits(&pb,  4, ctx->coded_sample_rate[1]);
762
        put_bits(&pb,  4, 0                        ); /* ignored */
763
        put_bits(&pb,  4, 0                        ); /* multi_channel_type */
764
        put_bits(&pb,  3, 0                        ); /* ignored */
765
        put_bits(&pb,  5, ctx->channel_arrangement );
766
    } else if (ctx->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
767
        put_bits(&pb,  8, SYNC_TRUEHD              );
768
        put_bits(&pb,  4, ctx->coded_sample_rate[0]);
769
        put_bits(&pb,  4, 0                        ); /* ignored */
770
        put_bits(&pb,  2, ctx->ch_modifier_thd0    );
771
        put_bits(&pb,  2, ctx->ch_modifier_thd1    );
772
        put_bits(&pb,  5, ctx->channel_arrangement );
773
        put_bits(&pb,  2, ctx->ch_modifier_thd2    );
774
        put_bits(&pb, 13, ctx->channel_arrangement );
775
    }
776
777
    put_bits(&pb, 16, MAJOR_SYNC_INFO_SIGNATURE);
778
    put_bits(&pb, 16, ctx->flags               );
779
    put_bits(&pb, 16, 0                        ); /* ignored */
780
    put_bits(&pb,  1, 1                        ); /* is_vbr */
781
    put_bits(&pb, 15, ctx->coded_peak_bitrate  );
782
    put_bits(&pb,  4, 1                        ); /* num_substreams */
783
    put_bits(&pb,  4, 0x1                      ); /* ignored */
784
785
    /* channel_meaning */
786
    put_bits(&pb,  8, ctx->substream_info      );
787
    put_bits(&pb,  5, ctx->fs                  );
788
    put_bits(&pb,  5, ctx->wordlength          );
789
    put_bits(&pb,  6, ctx->channel_occupancy   );
790
    put_bits(&pb,  3, 0                        ); /* ignored */
791
    put_bits(&pb, 10, 0                        ); /* speaker_layout */
792
    put_bits(&pb,  3, 0                        ); /* copy_protection */
793
    put_bits(&pb, 16, 0x8080                   ); /* ignored */
794
    put_bits(&pb,  7, 0                        ); /* ignored */
795
    put_bits(&pb,  4, 0                        ); /* source_format */
796
    put_bits(&pb,  5, ctx->summary_info        );
797
798
    flush_put_bits(&pb);
799
800
    AV_WL16(buf+26, ff_mlp_checksum16(buf, 26));
801
}
802
803
/** Writes a restart header to the bitstream. Damaged streams can start being
804
 *  decoded losslessly again after such a header and the subsequent decoding
805
 *  params header.
806
 */
807
static void write_restart_header(MLPEncodeContext *ctx, PutBitContext *pb)
808
{
809
    RestartHeader *rh = ctx->cur_restart_header;
810
    int32_t lossless_check = xor_32_to_8(rh->lossless_check_data);
811
    unsigned int start_count = put_bits_count(pb);
812
    PutBitContext tmpb;
813
    uint8_t checksum;
814
    unsigned int ch;
815
816
    put_bits(pb, 14, 0x31ea                ); /* TODO 0x31eb */
817
    put_bits(pb, 16, ctx->timestamp        );
818
    put_bits(pb,  4, rh->min_channel       );
819
    put_bits(pb,  4, rh->max_channel       );
820
    put_bits(pb,  4, rh->max_matrix_channel);
821
    put_bits(pb,  4, rh->noise_shift       );
822
    put_bits(pb, 23, rh->noisegen_seed     );
823
    put_bits(pb,  4, 0                     ); /* TODO max_shift */
824
    put_bits(pb,  5, rh->max_huff_lsbs     );
825
    put_bits(pb,  5, rh->max_output_bits   );
826
    put_bits(pb,  5, rh->max_output_bits   );
827
    put_bits(pb,  1, rh->data_check_present);
828
    put_bits(pb,  8, lossless_check        );
829
    put_bits(pb, 16, 0                     ); /* ignored */
830
831
    for (ch = 0; ch <= rh->max_matrix_channel; ch++)
832
        put_bits(pb, 6, ch);
833
834
    /* Data must be flushed for the checksum to be correct. */
835
    tmpb = *pb;
836
    flush_put_bits(&tmpb);
837
838
    checksum = ff_mlp_restart_checksum(pb->buf, put_bits_count(pb) - start_count);
839
840
    put_bits(pb,  8, checksum);
841
}
842
843
/** Writes matrix params for all primitive matrices to the bitstream. */
844
static void write_matrix_params(MLPEncodeContext *ctx, PutBitContext *pb)
845
{
846
    DecodingParams *dp = ctx->cur_decoding_params;
847
    MatrixParams *mp = &dp->matrix_params;
848
    unsigned int mat;
849
850
    put_bits(pb, 4, mp->count);
851
852
    for (mat = 0; mat < mp->count; mat++) {
853
        unsigned int channel;
854
855
        put_bits(pb, 4, mp->outch[mat]); /* matrix_out_ch */
856
        put_bits(pb, 4, mp->fbits[mat]);
857
        put_bits(pb, 1, 0             ); /* lsb_bypass */
858
859
        for (channel = 0; channel < ctx->num_channels; channel++) {
860
            int32_t coeff = mp->coeff[mat][channel];
861
862
            if (coeff) {
863
                put_bits(pb, 1, 1);
864
865
                coeff >>= 14 - mp->fbits[mat];
866
867
                put_sbits(pb, mp->fbits[mat] + 2, coeff);
868
            } else {
869
                put_bits(pb, 1, 0);
870
            }
871
        }
872
    }
873
}
874
875
/** Writes filter parameters for one filter to the bitstream. */
876
static void write_filter_params(MLPEncodeContext *ctx, PutBitContext *pb,
877
                                unsigned int channel, unsigned int filter)
878
{
879
    FilterParams *fp = &ctx->cur_channel_params[channel].filter_params[filter];
880
881
    put_bits(pb, 4, fp->order);
882
883
    if (fp->order > 0) {
884
        int i;
885
        int32_t *fcoeff = ctx->cur_channel_params[channel].coeff[filter];
886
887
        put_bits(pb, 4, fp->shift      );
888
        put_bits(pb, 5, fp->coeff_bits );
889
        put_bits(pb, 3, fp->coeff_shift);
890
891
        for (i = 0; i < fp->order; i++) {
892
            put_sbits(pb, fp->coeff_bits, fcoeff[i] >> fp->coeff_shift);
893
        }
894
895
        /* TODO state data for IIR filter. */
896
        put_bits(pb, 1, 0);
897
    }
898
}
899
900
/** Writes decoding parameters to the bitstream. These change very often,
901
 *  usually at almost every frame.
902
 */
903
static void write_decoding_params(MLPEncodeContext *ctx, PutBitContext *pb,
904
                                  int params_changed)
905
{
906
    DecodingParams *dp = ctx->cur_decoding_params;
907
    RestartHeader  *rh = ctx->cur_restart_header;
908
    MatrixParams *mp = &dp->matrix_params;
909
    unsigned int ch;
910
911
    if (dp->param_presence_flags != PARAMS_DEFAULT &&
912
        params_changed & PARAM_PRESENCE_FLAGS) {
913
        put_bits(pb, 1, 1);
914
        put_bits(pb, 8, dp->param_presence_flags);
915
    } else {
916
        put_bits(pb, 1, 0);
917
    }
918
919
    if (dp->param_presence_flags & PARAM_BLOCKSIZE) {
920
        if (params_changed       & PARAM_BLOCKSIZE) {
921
            put_bits(pb, 1, 1);
922
            put_bits(pb, 9, dp->blocksize);
923
        } else {
924
            put_bits(pb, 1, 0);
925
        }
926
    }
927
928
    if (dp->param_presence_flags & PARAM_MATRIX) {
929
        if (params_changed       & PARAM_MATRIX) {
930
            put_bits(pb, 1, 1);
931
            write_matrix_params(ctx, pb);
932
        } else {
933
            put_bits(pb, 1, 0);
934
        }
935
    }
936
937
    if (dp->param_presence_flags & PARAM_OUTSHIFT) {
938
        if (params_changed       & PARAM_OUTSHIFT) {
939
            put_bits(pb, 1, 1);
940
            for (ch = 0; ch <= rh->max_matrix_channel; ch++)
941
                put_sbits(pb, 4, mp->shift[ch]);
942
        } else {
943
            put_bits(pb, 1, 0);
944
        }
945
    }
946
947
    if (dp->param_presence_flags & PARAM_QUANTSTEP) {
948
        if (params_changed       & PARAM_QUANTSTEP) {
949
            put_bits(pb, 1, 1);
950
            for (ch = 0; ch <= rh->max_channel; ch++)
951
                put_bits(pb, 4, dp->quant_step_size[ch]);
952
        } else {
953
            put_bits(pb, 1, 0);
954
        }
955
    }
956
957
    for (ch = rh->min_channel; ch <= rh->max_channel; ch++) {
958
        ChannelParams *cp = &ctx->cur_channel_params[ch];
959
960
        if (dp->param_presence_flags & 0xF) {
961
            put_bits(pb, 1, 1);
962
963
            if (dp->param_presence_flags & PARAM_FIR) {
964
                if (params_changed       & PARAM_FIR) {
965
                    put_bits(pb, 1, 1);
966
                    write_filter_params(ctx, pb, ch, FIR);
967
                } else {
968
                    put_bits(pb, 1, 0);
969
                }
970
            }
971
972
            if (dp->param_presence_flags & PARAM_IIR) {
973
                if (params_changed       & PARAM_IIR) {
974
                    put_bits(pb, 1, 1);
975
                    write_filter_params(ctx, pb, ch, IIR);
976
                } else {
977
                    put_bits(pb, 1, 0);
978
                }
979
            }
980
981
            if (dp->param_presence_flags & PARAM_HUFFOFFSET) {
982
                if (params_changed       & PARAM_HUFFOFFSET) {
983
                    put_bits (pb,  1, 1);
984
                    put_sbits(pb, 15, cp->huff_offset);
985
                } else {
986
                    put_bits(pb, 1, 0);
987
                }
988
            }
989
990
            put_bits(pb, 2, cp->codebook );
991
            put_bits(pb, 5, cp->huff_lsbs);
992
        } else {
993
            put_bits(pb, 1, 0);
994
        }
995
    }
996
}
997
998
/** Writes the residuals to the bitstream. That is, the VLC codes from the
999
 *  codebooks (if any is used), and then the residual.
1000
 */
1001
static void write_block_data(MLPEncodeContext *ctx, PutBitContext *pb)
1002
{
1003
    DecodingParams *dp = ctx->cur_decoding_params;
1004
    RestartHeader  *rh = ctx->cur_restart_header;
1005
    int32_t *sample_buffer = ctx->write_buffer;
1006
    int32_t sign_huff_offset[MAX_CHANNELS];
1007
    int codebook_index      [MAX_CHANNELS];
1008
    int lsb_bits            [MAX_CHANNELS];
1009
    unsigned int i, ch;
1010
1011
    for (ch = rh->min_channel; ch <= rh->max_channel; ch++) {
1012
        ChannelParams *cp = &ctx->cur_channel_params[ch];
1013
        int sign_shift;
1014
1015
        lsb_bits        [ch] = cp->huff_lsbs - dp->quant_step_size[ch];
1016
        codebook_index  [ch] = cp->codebook  - 1;
1017
        sign_huff_offset[ch] = cp->huff_offset;
1018
1019
        sign_shift = lsb_bits[ch] - 1;
1020
1021
        if (cp->codebook > 0) {
1022
            sign_huff_offset[ch] -= 7 << lsb_bits[ch];
1023
            sign_shift += 3 - cp->codebook;
1024
        }
1025
1026
        /* Unsign if needed. */
1027
        if (sign_shift >= 0)
1028
            sign_huff_offset[ch] -= 1 << sign_shift;
1029
    }
1030
1031
    for (i = 0; i < dp->blocksize; i++) {
1032
        for (ch = rh->min_channel; ch <= rh->max_channel; ch++) {
1033
            int32_t sample = *sample_buffer++ >> dp->quant_step_size[ch];
1034
1035
            sample -= sign_huff_offset[ch];
1036
1037
            if (codebook_index[ch] >= 0) {
1038
                int vlc = sample >> lsb_bits[ch];
1039
                put_bits(pb, ff_mlp_huffman_tables[codebook_index[ch]][vlc][1],
1040
                             ff_mlp_huffman_tables[codebook_index[ch]][vlc][0]);
1041
            }
1042
1043
            put_sbits(pb, lsb_bits[ch], sample);
1044
        }
1045
        sample_buffer += 2; /* noise channels */
1046
    }
1047
1048
    ctx->write_buffer = sample_buffer;
1049
}
1050
1051
/** Writes the substreams data to the bitstream. */
1052
static uint8_t *write_substrs(MLPEncodeContext *ctx, uint8_t *buf, int buf_size,
1053
                              int restart_frame,
1054
                              uint16_t substream_data_len[MAX_SUBSTREAMS])
1055
{
1056
    int32_t *lossless_check_data = ctx->lossless_check_data;
1057
    unsigned int substr;
1058
    int end = 0;
1059
1060
    lossless_check_data += ctx->frame_index * ctx->num_substreams;
1061
1062
    for (substr = 0; substr < ctx->num_substreams; substr++) {
1063
        unsigned int cur_subblock_index = ctx->major_cur_subblock_index;
1064
        unsigned int num_subblocks = ctx->major_filter_state_subblock;
1065
        unsigned int subblock;
1066
        RestartHeader  *rh = &ctx->restart_header [substr];
1067
        int substr_restart_frame = restart_frame;
1068
        uint8_t parity, checksum;
1069
        PutBitContext pb, tmpb;
1070
        int params_changed;
1071
1072
        ctx->cur_restart_header = rh;
1073
1074
        init_put_bits(&pb, buf, buf_size);
1075
1076
        for (subblock = 0; subblock <= num_subblocks; subblock++) {
1077
            unsigned int subblock_index;
1078
1079
            subblock_index = cur_subblock_index++;
1080
1081
            ctx->cur_decoding_params = &ctx->major_decoding_params[subblock_index][substr];
1082
            ctx->cur_channel_params = ctx->major_channel_params[subblock_index];
1083
1084
            params_changed = ctx->major_params_changed[subblock_index][substr];
1085
1086
            if (substr_restart_frame || params_changed) {
1087
                put_bits(&pb, 1, 1);
1088
1089
                if (substr_restart_frame) {
1090
                    put_bits(&pb, 1, 1);
1091
1092
                    write_restart_header(ctx, &pb);
1093
                    rh->lossless_check_data = 0;
1094
                } else {
1095
                    put_bits(&pb, 1, 0);
1096
                }
1097
1098
                write_decoding_params(ctx, &pb, params_changed);
1099
            } else {
1100
                put_bits(&pb, 1, 0);
1101
            }
1102
1103
            write_block_data(ctx, &pb);
1104
1105
            put_bits(&pb, 1, !substr_restart_frame);
1106
1107
            substr_restart_frame = 0;
1108
        }
1109
1110
        put_bits(&pb, (-put_bits_count(&pb)) & 15, 0);
1111
1112
        rh->lossless_check_data ^= *lossless_check_data++;
1113
1114
        if (ctx->last_frame == ctx->inout_buffer) {
1115
            /* TODO find a sample and implement shorten_by. */
1116
            put_bits(&pb, 32, END_OF_STREAM);
1117
        }
1118
1119
        /* Data must be flushed for the checksum and parity to be correct. */
1120
        tmpb = pb;
1121
        flush_put_bits(&tmpb);
1122
1123
        parity   = ff_mlp_calculate_parity(buf, put_bits_count(&pb) >> 3) ^ 0xa9;
1124
        checksum = ff_mlp_checksum8       (buf, put_bits_count(&pb) >> 3);
1125
1126
        put_bits(&pb, 8, parity  );
1127
        put_bits(&pb, 8, checksum);
1128
1129
        flush_put_bits(&pb);
1130
1131
        end += put_bits_count(&pb) >> 3;
1132
        substream_data_len[substr] = end;
1133
1134
        buf += put_bits_count(&pb) >> 3;
1135
    }
1136
1137
    ctx->major_cur_subblock_index += ctx->major_filter_state_subblock + 1;
1138
    ctx->major_filter_state_subblock = 0;
1139
1140
    return buf;
1141
}
1142
1143
/** Writes the access unit and substream headers to the bitstream. */
1144
static void write_frame_headers(MLPEncodeContext *ctx, uint8_t *frame_header,
1145
                                uint8_t *substream_headers, unsigned int length,
1146
                                int restart_frame,
1147
                                uint16_t substream_data_len[MAX_SUBSTREAMS])
1148
{
1149
    uint16_t access_unit_header = 0;
1150
    uint16_t parity_nibble = 0;
1151
    unsigned int substr;
1152
1153
    parity_nibble  = ctx->dts;
1154
    parity_nibble ^= length;
1155
1156
    for (substr = 0; substr < ctx->num_substreams; substr++) {
1157
        uint16_t substr_hdr = 0;
1158
1159
        substr_hdr |= (0 << 15); /* extraword */
1160
        substr_hdr |= (!restart_frame << 14); /* !restart_frame */
1161
        substr_hdr |= (1 << 13); /* checkdata */
1162
        substr_hdr |= (0 << 12); /* ??? */
1163
        substr_hdr |= (substream_data_len[substr] / 2) & 0x0FFF;
1164
1165
        AV_WB16(substream_headers, substr_hdr);
1166
1167
        parity_nibble ^= *substream_headers++;
1168
        parity_nibble ^= *substream_headers++;
1169
    }
1170
1171
    parity_nibble ^= parity_nibble >> 8;
1172
    parity_nibble ^= parity_nibble >> 4;
1173
    parity_nibble &= 0xF;
1174
1175
    access_unit_header |= (parity_nibble ^ 0xF) << 12;
1176
    access_unit_header |= length & 0xFFF;
1177
1178
    AV_WB16(frame_header  , access_unit_header);
1179
    AV_WB16(frame_header+2, ctx->dts          );
1180
}
1181
1182
/** Writes an entire access unit to the bitstream. */
1183
static unsigned int write_access_unit(MLPEncodeContext *ctx, uint8_t *buf,
1184
                                      int buf_size, int restart_frame)
1185
{
1186
    uint16_t substream_data_len[MAX_SUBSTREAMS];
1187
    uint8_t *buf1, *buf0 = buf;
1188
    unsigned int substr;
1189
    int total_length;
1190
1191
    if (buf_size < 4)
1192
        return -1;
1193
1194
    /* Frame header will be written at the end. */
1195
    buf      += 4;
1196
    buf_size -= 4;
1197
1198
    if (restart_frame) {
1199
        if (buf_size < 28)
1200
            return -1;
1201
        write_major_sync(ctx, buf, buf_size);
1202
        buf      += 28;
1203
        buf_size -= 28;
1204
    }
1205
1206
    buf1 = buf;
1207
1208
    /* Substream headers will be written at the end. */
1209
    for (substr = 0; substr < ctx->num_substreams; substr++) {
1210
        buf      += 2;
1211
        buf_size -= 2;
1212
    }
1213
1214
    buf = write_substrs(ctx, buf, buf_size, restart_frame, substream_data_len);
1215
1216
    total_length = buf - buf0;
1217
1218
    write_frame_headers(ctx, buf0, buf1, total_length / 2, restart_frame, substream_data_len);
1219
1220
    return total_length;
1221
}
1222
1223
/****************************************************************************
1224
 ****************** Functions that input data to context ********************
1225
 ****************************************************************************/
1226
1227
/** Inputs data from the samples passed by lavc into the context, shifts them
1228
 *  appropriately depending on the bit-depth, and calculates the
1229
 *  lossless_check_data that will be written to the restart header.
1230
 */
1231
static void input_data_internal(MLPEncodeContext *ctx, const uint8_t *samples,
1232
                                int is24)
1233
{
1234
    int32_t *lossless_check_data = ctx->lossless_check_data;
1235
    const int32_t *samples_32 = (const int32_t *) samples;
1236
    const int16_t *samples_16 = (const int16_t *) samples;
1237
    unsigned int substr;
1238
1239
    lossless_check_data += ctx->frame_index * ctx->num_substreams;
1240
1241
    for (substr = 0; substr < ctx->num_substreams; substr++) {
1242
        RestartHeader  *rh = &ctx->restart_header [substr];
1243
        int32_t *sample_buffer = ctx->inout_buffer;
1244
        int32_t temp_lossless_check_data = 0;
1245
        uint32_t greatest = 0;
1246
        unsigned int channel;
1247
        int i;
1248
1249
        for (i = 0; i < ctx->frame_size[ctx->frame_index]; i++) {
1250
            for (channel = 0; channel <= rh->max_channel; channel++) {
1251
                uint32_t abs_sample;
1252
                int32_t sample;
1253
1254
                sample = is24 ? *samples_32++ >> 8 : *samples_16++ << 8;
1255
1256
                /* TODO Find out if number_sbits can be used for negative values. */
1257
                abs_sample = FFABS(sample);
1258
                if (greatest < abs_sample)
1259
                    greatest = abs_sample;
1260
1261
                temp_lossless_check_data ^= (sample & 0x00ffffff) << channel;
1262
                *sample_buffer++ = sample;
1263
            }
1264
1265
            sample_buffer += 2; /* noise channels */
1266
        }
1267
1268
        ctx->max_output_bits[ctx->frame_index] = number_sbits(greatest);
1269
1270
        *lossless_check_data++ = temp_lossless_check_data;
1271
    }
1272
}
1273
1274
/** Wrapper function for inputting data in two different bit-depths. */
1275
static void input_data(MLPEncodeContext *ctx, void *samples)
1276
{
1277
    if (ctx->avctx->sample_fmt == AV_SAMPLE_FMT_S32)
1278
        input_data_internal(ctx, samples, 1);
1279
    else
1280
        input_data_internal(ctx, samples, 0);
1281
}
1282
1283
static void input_to_sample_buffer(MLPEncodeContext *ctx)
1284
{
1285
    int32_t *sample_buffer = ctx->sample_buffer;
1286
    unsigned int index;
1287
1288
    for (index = 0; index < ctx->number_of_frames; index++) {
1289
        unsigned int cur_index = (ctx->starting_frame_index + index) % ctx->max_restart_interval;
1290
        int32_t *input_buffer = ctx->inout_buffer + cur_index * ctx->one_sample_buffer_size;
1291
        unsigned int i, channel;
1292
1293
        for (i = 0; i < ctx->frame_size[cur_index]; i++) {
1294
            for (channel = 0; channel < ctx->avctx->channels; channel++)
1295
                *sample_buffer++ = *input_buffer++;
1296
            sample_buffer += 2; /* noise_channels */
1297
            input_buffer += 2; /* noise_channels */
1298
        }
1299
    }
1300
}
1301
1302
/****************************************************************************
1303
 ********* Functions that analyze the data and set the parameters ***********
1304
 ****************************************************************************/
1305
1306
/** Counts the number of trailing zeroes in a value */
1307
static int number_trailing_zeroes(int32_t sample)
1308
{
1309
    int bits;
1310
1311
    for (bits = 0; bits < 24 && !(sample & (1<<bits)); bits++);
1312
1313
    /* All samples are 0. TODO Return previous quant_step_size to avoid
1314
     * writing a new header. */
1315
    if (bits == 24)
1316
        return 0;
1317
1318
    return bits;
1319
}
1320
1321
/** Determines how many bits are zero at the end of all samples so they can be
1322
 *  shifted out.
1323
 */
1324
static void determine_quant_step_size(MLPEncodeContext *ctx)
1325
{
1326
    DecodingParams *dp = ctx->cur_decoding_params;
1327
    RestartHeader  *rh = ctx->cur_restart_header;
1328
    MatrixParams *mp = &dp->matrix_params;
1329
    int32_t *sample_buffer = ctx->sample_buffer;
1330
    int32_t sample_mask[MAX_CHANNELS];
1331
    unsigned int channel;
1332
    int i;
1333
1334
    memset(sample_mask, 0x00, sizeof(sample_mask));
1335
1336
    for (i = 0; i < ctx->number_of_samples; i++) {
1337
        for (channel = 0; channel <= rh->max_channel; channel++)
1338
            sample_mask[channel] |= *sample_buffer++;
1339
1340
        sample_buffer += 2; /* noise channels */
1341
    }
1342
1343
    for (channel = 0; channel <= rh->max_channel; channel++)
1344
        dp->quant_step_size[channel] = number_trailing_zeroes(sample_mask[channel]) - mp->shift[channel];
1345
}
1346
1347
/** Determines the smallest number of bits needed to encode the filter
1348
 *  coefficients, and if it's possible to right-shift their values without
1349
 *  losing any precision.
1350
 */
1351
static void code_filter_coeffs(MLPEncodeContext *ctx, FilterParams *fp, int32_t *fcoeff)
1352
{
1353
    int min = INT_MAX, max = INT_MIN;
1354
    int bits, shift;
1355
    int coeff_mask = 0;
1356
    int order;
1357
1358
    for (order = 0; order < fp->order; order++) {
1359
        int coeff = fcoeff[order];
1360
1361
        if (coeff < min)
1362
            min = coeff;
1363
        if (coeff > max)
1364
            max = coeff;
1365
1366
        coeff_mask |= coeff;
1367
    }
1368
1369
    bits = FFMAX(number_sbits(min), number_sbits(max));
1370
1371
    for (shift = 0; shift < 7 && bits + shift < 16 && !(coeff_mask & (1<<shift)); shift++);
1372
1373
    fp->coeff_bits  = bits;
1374
    fp->coeff_shift = shift;
1375
}
1376
1377
/** Determines the best filter parameters for the given data and writes the
1378
 *  necessary information to the context.
1379
 *  TODO Add IIR filter predictor!
1380
 */
1381
static void set_filter_params(MLPEncodeContext *ctx,
1382
                              unsigned int channel, unsigned int filter,
1383
                              int clear_filter)
1384
{
1385
    ChannelParams *cp = &ctx->cur_channel_params[channel];
1386
    FilterParams *fp = &cp->filter_params[filter];
1387
1388
    if ((filter == IIR && ctx->substream_info & SUBSTREAM_INFO_HIGH_RATE) ||
1389
        clear_filter) {
1390
        fp->order = 0;
1391
    } else if (filter == IIR) {
1392
        fp->order = 0;
1393
    } else if (filter == FIR) {
1394
        const int max_order = (ctx->substream_info & SUBSTREAM_INFO_HIGH_RATE)
1395
                              ? 4 : MLP_MAX_LPC_ORDER;
1396
        int32_t *sample_buffer = ctx->sample_buffer + channel;
1397
        int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
1398
        int32_t *lpc_samples = ctx->lpc_sample_buffer;
1399
        int32_t *fcoeff = ctx->cur_channel_params[channel].coeff[filter];
1400
        int shift[MLP_MAX_LPC_ORDER];
1401
        unsigned int i;
1402
        int order;
1403
1404
        for (i = 0; i < ctx->number_of_samples; i++) {
1405
            *lpc_samples++ = *sample_buffer;
1406
            sample_buffer += ctx->num_channels;
1407
        }
1408
1409
        order = ff_lpc_calc_coefs(&ctx->lpc_ctx, ctx->lpc_sample_buffer,
1410
                                  ctx->number_of_samples, MLP_MIN_LPC_ORDER,
1411
                                  max_order, 11, coefs, shift, FF_LPC_TYPE_LEVINSON, 0,
1412
                                  ORDER_METHOD_EST, MLP_MIN_LPC_SHIFT,
1413
                                  MLP_MAX_LPC_SHIFT, MLP_MIN_LPC_SHIFT);
1414
1415
        fp->order = order;
1416
        fp->shift = shift[order-1];
1417
1418
        for (i = 0; i < order; i++)
1419
            fcoeff[i] = coefs[order-1][i];
1420
1421
        code_filter_coeffs(ctx, fp, fcoeff);
1422
    }
1423
}
1424
1425
/** Tries to determine a good prediction filter, and applies it to the samples
1426
 *  buffer if the filter is good enough. Sets the filter data to be cleared if
1427
 *  no good filter was found.
1428
 */
1429
static void determine_filters(MLPEncodeContext *ctx)
1430
{
1431
    RestartHeader *rh = ctx->cur_restart_header;
1432
    int channel, filter;
1433
1434
    for (channel = rh->min_channel; channel <= rh->max_channel; channel++) {
1435
        for (filter = 0; filter < NUM_FILTERS; filter++)
1436
            set_filter_params(ctx, channel, filter, 0);
1437
    }
1438
}
1439
1440
enum MLPChMode {
1441
    MLP_CHMODE_LEFT_RIGHT,
1442
    MLP_CHMODE_LEFT_SIDE,
1443
    MLP_CHMODE_RIGHT_SIDE,
1444
    MLP_CHMODE_MID_SIDE,
1445
};
1446
1447
static enum MLPChMode estimate_stereo_mode(MLPEncodeContext *ctx)
1448
{
1449
    uint64_t score[4], sum[4] = { 0, 0, 0, 0, };
1450
    int32_t *right_ch = ctx->sample_buffer + 1;
1451
    int32_t *left_ch  = ctx->sample_buffer;
1452
    int i;
1453
    enum MLPChMode best = 0;
1454
1455
    for(i = 2; i < ctx->number_of_samples; i++) {
1456
        int32_t left  = left_ch [i * ctx->num_channels] - 2 * left_ch [(i - 1) * ctx->num_channels] + left_ch [(i - 2) * ctx->num_channels];
1457
        int32_t right = right_ch[i * ctx->num_channels] - 2 * right_ch[(i - 1) * ctx->num_channels] + right_ch[(i - 2) * ctx->num_channels];
1458
1459
        sum[0] += FFABS( left        );
1460
        sum[1] += FFABS(        right);
1461
        sum[2] += FFABS((left + right) >> 1);
1462
        sum[3] += FFABS( left - right);
1463
    }
1464
1465
    score[MLP_CHMODE_LEFT_RIGHT] = sum[0] + sum[1];
1466
    score[MLP_CHMODE_LEFT_SIDE]  = sum[0] + sum[3];
1467
    score[MLP_CHMODE_RIGHT_SIDE] = sum[1] + sum[3];
1468
    score[MLP_CHMODE_MID_SIDE]   = sum[2] + sum[3];
1469
1470
    for(i = 1; i < 3; i++)
1471
        if(score[i] < score[best])
1472
            best = i;
1473
1474
    return best;
1475
}
1476
1477
/** Determines how many fractional bits are needed to encode matrix
1478
 *  coefficients. Also shifts the coefficients to fit within 2.14 bits.
1479
 */
1480
static void code_matrix_coeffs(MLPEncodeContext *ctx, unsigned int mat)
1481
{
1482
    DecodingParams *dp = ctx->cur_decoding_params;
1483
    MatrixParams *mp = &dp->matrix_params;
1484
    int32_t coeff_mask = 0;
1485
    unsigned int channel;
1486
    unsigned int bits;
1487
1488
    for (channel = 0; channel < ctx->num_channels; channel++) {
1489
        int32_t coeff = mp->coeff[mat][channel];
1490
        coeff_mask |= coeff;
1491
    }
1492
1493
    for (bits = 0; bits < 14 && !(coeff_mask & (1<<bits)); bits++);
1494
1495
    mp->fbits   [mat] = 14 - bits;
1496
}
1497
1498
/** Determines best coefficients to use for the lossless matrix. */
1499
static void lossless_matrix_coeffs(MLPEncodeContext *ctx)
1500
{
1501
    DecodingParams *dp = ctx->cur_decoding_params;
1502
    MatrixParams *mp = &dp->matrix_params;
1503
    unsigned int shift = 0;
1504
    unsigned int channel;
1505
    int mat;
1506
    enum MLPChMode mode;
1507
1508
    /* No decorrelation for non-stereo. */
1509
    if (ctx->num_channels - 2 != 2) {
1510
        mp->count = 0;
1511
        return;
1512
    }
1513
1514
    mode = estimate_stereo_mode(ctx);
1515
1516
    switch(mode) {
1517
        /* TODO: add matrix for MID_SIDE */
1518
        case MLP_CHMODE_MID_SIDE:
1519
        case MLP_CHMODE_LEFT_RIGHT:
1520
            mp->count    = 0;
1521
            break;
1522
        case MLP_CHMODE_LEFT_SIDE:
1523
            mp->count    = 1;
1524
            mp->outch[0] = 1;
1525
            mp->coeff[0][0] =  1 << 14; mp->coeff[0][1] = -(1 << 14);
1526
            mp->coeff[0][2] =  0 << 14; mp->coeff[0][2] =   0 << 14;
1527
            mp->forco[0][0] =  1 << 14; mp->forco[0][1] = -(1 << 14);
1528
            mp->forco[0][2] =  0 << 14; mp->forco[0][2] =   0 << 14;
1529
            break;
1530
        case MLP_CHMODE_RIGHT_SIDE:
1531
            mp->count    = 1;
1532
            mp->outch[0] = 0;
1533
            mp->coeff[0][0] =  1 << 14; mp->coeff[0][1] =   1 << 14;
1534
            mp->coeff[0][2] =  0 << 14; mp->coeff[0][2] =   0 << 14;
1535
            mp->forco[0][0] =  1 << 14; mp->forco[0][1] = -(1 << 14);
1536
            mp->forco[0][2] =  0 << 14; mp->forco[0][2] =   0 << 14;
1537
            break;
1538
    }
1539
1540
    for (mat = 0; mat < mp->count; mat++)
1541
        code_matrix_coeffs(ctx, mat);
1542
1543
    for (channel = 0; channel < ctx->num_channels; channel++)
1544
        mp->shift[channel] = shift;
1545
}
1546
1547
/** Min and max values that can be encoded with each codebook. The values for
1548
 *  the third codebook take into account the fact that the sign shift for this
1549
 *  codebook is outside the coded value, so it has one more bit of precision.
1550
 *  It should actually be -7 -> 7, shifted down by 0.5.
1551
 */
1552
static const int codebook_extremes[3][2] = {
1553
    {-9, 8}, {-8, 7}, {-15, 14},
1554
};
1555
1556
/** Determines the amount of bits needed to encode the samples using no
1557
 *  codebooks and a specified offset.
1558
 */
1559
static void no_codebook_bits_offset(MLPEncodeContext *ctx,
1560
                                    unsigned int channel, int16_t offset,
1561
                                    int32_t min, int32_t max,
1562
                                    BestOffset *bo)
1563
{
1564
    DecodingParams *dp = ctx->cur_decoding_params;
1565
    int32_t unsign;
1566
    int lsb_bits;
1567
1568
    min -= offset;
1569
    max -= offset;
1570
1571
    lsb_bits = FFMAX(number_sbits(min), number_sbits(max)) - 1;
1572
1573
    lsb_bits += !!lsb_bits;
1574
1575
    unsign = 1 << (lsb_bits - 1);
1576
1577
    bo->offset   = offset;
1578
    bo->lsb_bits = lsb_bits;
1579
    bo->bitcount = lsb_bits * dp->blocksize;
1580
    bo->min      = offset - unsign + 1;
1581
    bo->max      = offset + unsign;
1582
}
1583
1584
/** Determines the least amount of bits needed to encode the samples using no
1585
 *  codebooks.
1586
 */
1587
static void no_codebook_bits(MLPEncodeContext *ctx,
1588
                             unsigned int channel,
1589
                             int32_t min, int32_t max,
1590
                             BestOffset *bo)
1591
{
1592
    DecodingParams *dp = ctx->cur_decoding_params;
1593
    int16_t offset;
1594
    int32_t unsign;
1595
    uint32_t diff;
1596
    int lsb_bits;
1597
1598
    /* Set offset inside huffoffset's boundaries by adjusting extremes
1599
     * so that more bits are used, thus shifting the offset. */
1600
    if (min < HUFF_OFFSET_MIN)
1601
        max = FFMAX(max, 2 * HUFF_OFFSET_MIN - min + 1);
1602
    if (max > HUFF_OFFSET_MAX)
1603
        min = FFMIN(min, 2 * HUFF_OFFSET_MAX - max - 1);
1604
1605
    /* Determine offset and minimum number of bits. */
1606
    diff = max - min;
1607
1608
    lsb_bits = number_sbits(diff) - 1;
1609
1610
    unsign = 1 << (lsb_bits - 1);
1611
1612
    /* If all samples are the same (lsb_bits == 0), offset must be
1613
     * adjusted because of sign_shift. */
1614
    offset = min + diff / 2 + !!lsb_bits;
1615
1616
    bo->offset   = offset;
1617
    bo->lsb_bits = lsb_bits;
1618
    bo->bitcount = lsb_bits * dp->blocksize;
1619
    bo->min      = max - unsign + 1;
1620
    bo->max      = min + unsign;
1621
}
1622
1623
/** Determines the least amount of bits needed to encode the samples using a
1624
 *  given codebook and a given offset.
1625
 */
1626
static inline void codebook_bits_offset(MLPEncodeContext *ctx,
1627
                                        unsigned int channel, int codebook,
1628
                                        int32_t sample_min, int32_t sample_max,
1629
                                        int16_t offset, BestOffset *bo)
1630
{
1631
    int32_t codebook_min = codebook_extremes[codebook][0];
1632
    int32_t codebook_max = codebook_extremes[codebook][1];
1633
    int32_t *sample_buffer = ctx->sample_buffer + channel;
1634
    DecodingParams *dp = ctx->cur_decoding_params;
1635
    int codebook_offset  = 7 + (2 - codebook);
1636
    int32_t unsign_offset = offset;
1637
    int lsb_bits = 0, bitcount = 0;
1638
    int offset_min = INT_MAX, offset_max = INT_MAX;
1639
    int unsign, mask;
1640
    int i;
1641
1642
    sample_min -= offset;
1643
    sample_max -= offset;
1644
1645
    while (sample_min < codebook_min || sample_max > codebook_max) {
1646
        lsb_bits++;
1647
        sample_min >>= 1;
1648
        sample_max >>= 1;
1649
    }
1650
1651
    unsign = 1 << lsb_bits;
1652
    mask   = unsign - 1;
1653
1654
    if (codebook == 2) {
1655
        unsign_offset -= unsign;
1656
        lsb_bits++;
1657
    }
1658
1659
    for (i = 0; i < dp->blocksize; i++) {
1660
        int32_t sample = *sample_buffer >> dp->quant_step_size[channel];
1661
        int temp_min, temp_max;
1662
1663
        sample -= unsign_offset;
1664
1665
        temp_min = sample & mask;
1666
        if (temp_min < offset_min)
1667
            offset_min = temp_min;
1668
1669
        temp_max = unsign - temp_min - 1;
1670
        if (temp_max < offset_max)
1671
            offset_max = temp_max;
1672
1673
        sample >>= lsb_bits;
1674
1675
        bitcount += ff_mlp_huffman_tables[codebook][sample + codebook_offset][1];
1676
1677
        sample_buffer += ctx->num_channels;
1678
    }
1679
1680
    bo->offset   = offset;
1681
    bo->lsb_bits = lsb_bits;
1682
    bo->bitcount = lsb_bits * dp->blocksize + bitcount;
1683
    bo->min      = FFMAX(offset - offset_min, HUFF_OFFSET_MIN);
1684
    bo->max      = FFMIN(offset + offset_max, HUFF_OFFSET_MAX);
1685
}
1686
1687
/** Determines the least amount of bits needed to encode the samples using a
1688
 *  given codebook. Searches for the best offset to minimize the bits.
1689
 */
1690
static inline void codebook_bits(MLPEncodeContext *ctx,
1691
                                 unsigned int channel, int codebook,
1692
                                 int offset, int32_t min, int32_t max,
1693
                                 BestOffset *bo, int direction)
1694
{
1695
    int previous_count = INT_MAX;
1696
    int offset_min, offset_max;
1697
    int is_greater = 0;
1698
1699
    offset_min = FFMAX(min, HUFF_OFFSET_MIN);
1700
    offset_max = FFMIN(max, HUFF_OFFSET_MAX);
1701
1702
    for (;;) {
1703
        BestOffset temp_bo;
1704
1705
        codebook_bits_offset(ctx, channel, codebook,
1706
                             min, max, offset,
1707
                             &temp_bo);
1708
1709
        if (temp_bo.bitcount < previous_count) {
1710
            if (temp_bo.bitcount < bo->bitcount)
1711
                *bo = temp_bo;
1712
1713
            is_greater = 0;
1714
        } else if (++is_greater >= ctx->max_codebook_search)
1715
            break;
1716
1717
        previous_count = temp_bo.bitcount;
1718
1719
        if (direction) {
1720
            offset = temp_bo.max + 1;
1721
            if (offset > offset_max)
1722
                break;
1723
        } else {
1724
            offset = temp_bo.min - 1;
1725
            if (offset < offset_min)
1726
                break;
1727
        }
1728
    }
1729
}
1730
1731
/** Determines the least amount of bits needed to encode the samples using
1732
 *  any or no codebook.
1733
 */
1734
static void determine_bits(MLPEncodeContext *ctx)
1735
{
1736
    DecodingParams *dp = ctx->cur_decoding_params;
1737
    RestartHeader  *rh = ctx->cur_restart_header;
1738
    unsigned int channel;
1739
1740
    for (channel = 0; channel <= rh->max_channel; channel++) {
1741
        ChannelParams *cp = &ctx->cur_channel_params[channel];
1742
        int32_t *sample_buffer = ctx->sample_buffer + channel;
1743
        int32_t min = INT32_MAX, max = INT32_MIN;
1744
        int no_filters_used = !cp->filter_params[FIR].order;
1745
        int average = 0;
1746
        int offset = 0;
1747
        int i;
1748
1749
        /* Determine extremes and average. */
1750
        for (i = 0; i < dp->blocksize; i++) {
1751
            int32_t sample = *sample_buffer >> dp->quant_step_size[channel];
1752
            if (sample < min)
1753
                min = sample;
1754
            if (sample > max)
1755
                max = sample;
1756
            average += sample;
1757
            sample_buffer += ctx->num_channels;
1758
        }
1759
        average /= dp->blocksize;
1760
1761
        /* If filtering is used, we always set the offset to zero, otherwise
1762
         * we search for the offset that minimizes the bitcount. */
1763
        if (no_filters_used) {
1764
            no_codebook_bits(ctx, channel, min, max, &ctx->cur_best_offset[channel][0]);
1765
            offset = av_clip(average, HUFF_OFFSET_MIN, HUFF_OFFSET_MAX);
1766
        } else {
1767
            no_codebook_bits_offset(ctx, channel, offset, min, max, &ctx->cur_best_offset[channel][0]);
1768
        }
1769
1770
        for (i = 1; i < NUM_CODEBOOKS; i++) {
1771
            BestOffset temp_bo = { 0, INT_MAX, 0, 0, 0, };
1772
            int16_t offset_max;
1773
1774
            codebook_bits_offset(ctx, channel, i - 1,
1775
                                 min, max, offset,
1776
                                 &temp_bo);
1777
1778
            if (no_filters_used) {
1779
                offset_max = temp_bo.max;
1780
1781
                codebook_bits(ctx, channel, i - 1, temp_bo.min - 1,
1782
                            min, max, &temp_bo, 0);
1783
                codebook_bits(ctx, channel, i - 1, offset_max + 1,
1784
                            min, max, &temp_bo, 1);
1785
            }
1786
1787
            ctx->cur_best_offset[channel][i] = temp_bo;
1788
        }
1789
    }
1790
}
1791
1792
/****************************************************************************
1793
 *************** Functions that process the data in some way ****************
1794
 ****************************************************************************/
1795
1796
#define SAMPLE_MAX(bitdepth) ((1 << (bitdepth - 1)) - 1)
1797
#define SAMPLE_MIN(bitdepth) (~SAMPLE_MAX(bitdepth))
1798
1799
#define MSB_MASK(bits)  (-1u << bits)
1800
1801
/** Applies the filter to the current samples, and saves the residual back
1802
 *  into the samples buffer. If the filter is too bad and overflows the
1803
 *  maximum amount of bits allowed (16 or 24), the samples buffer is left as is and
1804
 *  the function returns -1.
1805
 */
1806
static int apply_filter(MLPEncodeContext *ctx, unsigned int channel)
1807
{
1808
    FilterParams *fp[NUM_FILTERS] = { &ctx->cur_channel_params[channel].filter_params[FIR],
1809
                                      &ctx->cur_channel_params[channel].filter_params[IIR], };
1810
    int32_t *filter_state_buffer[NUM_FILTERS];
1811
    int32_t mask = MSB_MASK(ctx->cur_decoding_params->quant_step_size[channel]);
1812
    int32_t *sample_buffer = ctx->sample_buffer + channel;
1813
    unsigned int number_of_samples = ctx->number_of_samples;
1814
    unsigned int filter_shift = fp[FIR]->shift;
1815
    int filter;
1816
    int i;
1817
1818
    for (i = 0; i < NUM_FILTERS; i++) {
1819
        unsigned int size = ctx->number_of_samples;
1820
        filter_state_buffer[i] = av_malloc(size*sizeof(int32_t));
1821
        if (!filter_state_buffer[i]) {
1822
            av_log(ctx->avctx, AV_LOG_ERROR,
1823
                   "Not enough memory for applying filters.\n");
1824
            return -1;
1825
        }
1826
    }
1827
1828
    for (i = 0; i < 8; i++) {
1829
        filter_state_buffer[FIR][i] = *sample_buffer;
1830
        filter_state_buffer[IIR][i] = *sample_buffer;
1831
1832
        sample_buffer += ctx->num_channels;
1833
    }
1834
1835
    for (i = 8; i < number_of_samples; i++) {
1836
        int32_t sample = *sample_buffer;
1837
        unsigned int order;
1838
        int64_t accum = 0;
1839
        int32_t residual;
1840
1841
        for (filter = 0; filter < NUM_FILTERS; filter++) {
1842
            int32_t *fcoeff = ctx->cur_channel_params[channel].coeff[filter];
1843
            for (order = 0; order < fp[filter]->order; order++)
1844
                accum += (int64_t)filter_state_buffer[filter][i - 1 - order] *
1845
                         fcoeff[order];
1846
        }
1847
1848
        accum  >>= filter_shift;
1849
        residual = sample - (accum & mask);
1850
1851
        if (residual < SAMPLE_MIN(ctx->wordlength) || residual > SAMPLE_MAX(ctx->wordlength))
1852
            return -1;
1853
1854
        filter_state_buffer[FIR][i] = sample;
1855
        filter_state_buffer[IIR][i] = residual;
1856
1857
        sample_buffer += ctx->num_channels;
1858
    }
1859
1860
    sample_buffer = ctx->sample_buffer + channel;
1861
    for (i = 0; i < number_of_samples; i++) {
1862
        *sample_buffer = filter_state_buffer[IIR][i];
1863
1864
        sample_buffer += ctx->num_channels;
1865
    }
1866
1867
    for (i = 0; i < NUM_FILTERS; i++) {
1868
        av_freep(&filter_state_buffer[i]);
1869
    }
1870
1871
    return 0;
1872
}
1873
1874
static void apply_filters(MLPEncodeContext *ctx)
1875
{
1876
    RestartHeader *rh = ctx->cur_restart_header;
1877
    int channel;
1878
1879
    for (channel = rh->min_channel; channel <= rh->max_channel; channel++) {
1880
        if (apply_filter(ctx, channel) < 0) {
1881
            /* Filter is horribly wrong.
1882
             * Clear filter params and update state. */
1883
            set_filter_params(ctx, channel, FIR, 1);
1884
            set_filter_params(ctx, channel, IIR, 1);
1885
            apply_filter(ctx, channel);
1886
        }
1887
    }
1888
}
1889
1890
/** Generates two noise channels worth of data. */
1891
static void generate_2_noise_channels(MLPEncodeContext *ctx)
1892
{
1893
    int32_t *sample_buffer = ctx->sample_buffer + ctx->num_channels - 2;
1894
    RestartHeader *rh = ctx->cur_restart_header;
1895
    unsigned int i;
1896
    uint32_t seed = rh->noisegen_seed;
1897
1898
    for (i = 0; i < ctx->number_of_samples; i++) {
1899
        uint16_t seed_shr7 = seed >> 7;
1900
        *sample_buffer++ = ((int8_t)(seed >> 15)) << rh->noise_shift;
1901
        *sample_buffer++ = ((int8_t) seed_shr7)   << rh->noise_shift;
1902
1903
        seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1904
1905
        sample_buffer += ctx->num_channels - 2;
1906
    }
1907
1908
    rh->noisegen_seed = seed & ((1 << 24)-1);
1909
}
1910
1911
/** Rematrixes all channels using chosen coefficients. */
1912
static void rematrix_channels(MLPEncodeContext *ctx)
1913
{
1914
    DecodingParams *dp = ctx->cur_decoding_params;
1915
    MatrixParams *mp = &dp->matrix_params;
1916
    int32_t *sample_buffer = ctx->sample_buffer;
1917
    unsigned int mat, i, maxchan;
1918
1919
    maxchan = ctx->num_channels;
1920
1921
    for (mat = 0; mat < mp->count; mat++) {
1922
        unsigned int msb_mask_bits = (ctx->avctx->sample_fmt == AV_SAMPLE_FMT_S16 ? 8 : 0) - mp->shift[mat];
1923
        int32_t mask = MSB_MASK(msb_mask_bits);
1924
        unsigned int outch = mp->outch[mat];
1925
1926
        sample_buffer = ctx->sample_buffer;
1927
        for (i = 0; i < ctx->number_of_samples; i++) {
1928
            unsigned int src_ch;
1929
            int64_t accum = 0;
1930
1931
            for (src_ch = 0; src_ch < maxchan; src_ch++) {
1932
                int32_t sample = *(sample_buffer + src_ch);
1933
                accum += (int64_t) sample * mp->forco[mat][src_ch];
1934
            }
1935
            sample_buffer[outch] = (accum >> 14) & mask;
1936
1937
            sample_buffer += ctx->num_channels;
1938
        }
1939
    }
1940
}
1941
1942
/****************************************************************************
1943
 **** Functions that deal with determining the best parameters and output ***
1944
 ****************************************************************************/
1945
1946
typedef struct {
1947
    char    path[MAJOR_HEADER_INTERVAL + 3];
1948
    int     bitcount;
1949
} PathCounter;
1950
1951
static const char *path_counter_codebook[] = { "0", "1", "2", "3", };
1952
1953
#define ZERO_PATH               '0'
1954
#define CODEBOOK_CHANGE_BITS    21
1955
1956
static void clear_path_counter(PathCounter *path_counter)
1957
{
1958
    unsigned int i;
1959
1960
    for (i = 0; i < NUM_CODEBOOKS + 1; i++) {
1961
        path_counter[i].path[0]  = ZERO_PATH;
1962
        path_counter[i].path[1]  =      0x00;
1963
        path_counter[i].bitcount =         0;
1964
    }
1965
}
1966
1967
static int compare_best_offset(BestOffset *prev, BestOffset *cur)
1968
{
1969
    if (prev->lsb_bits != cur->lsb_bits)
1970
        return 1;
1971
1972
    return 0;
1973
}
1974
1975
static int best_codebook_path_cost(MLPEncodeContext *ctx, unsigned int channel,
1976
                                   PathCounter *src, int cur_codebook)
1977
{
1978
    BestOffset *cur_bo, *prev_bo = restart_best_offset;
1979
    int bitcount = src->bitcount;
1980
    char *path = src->path + 1;
1981
    int prev_codebook;
1982
    int i;
1983
1984
    for (i = 0; path[i]; i++)
1985
        prev_bo = ctx->best_offset[i][channel];
1986
1987
    prev_codebook = path[i - 1] - ZERO_PATH;
1988
1989
    cur_bo = ctx->best_offset[i][channel];
1990
1991
    bitcount += cur_bo[cur_codebook].bitcount;
1992
1993
    if (prev_codebook != cur_codebook ||
1994
        compare_best_offset(&prev_bo[prev_codebook], &cur_bo[cur_codebook]))
1995
        bitcount += CODEBOOK_CHANGE_BITS;
1996
1997
    return bitcount;
1998
}
1999
2000
static void set_best_codebook(MLPEncodeContext *ctx)
2001
{
2002
    DecodingParams *dp = ctx->cur_decoding_params;
2003
    RestartHeader *rh = ctx->cur_restart_header;
2004
    unsigned int channel;
2005
2006
    for (channel = rh->min_channel; channel <= rh->max_channel; channel++) {
2007
        BestOffset *cur_bo, *prev_bo = restart_best_offset;
2008
        PathCounter path_counter[NUM_CODEBOOKS + 1];
2009
        unsigned int best_codebook;
2010
        unsigned int index;
2011
        char *best_path;
2012
2013
        clear_path_counter(path_counter);
2014
2015
        for (index = 0; index < ctx->number_of_subblocks; index++) {
2016
            unsigned int best_bitcount = INT_MAX;
2017
            unsigned int codebook;
2018
2019
            cur_bo = ctx->best_offset[index][channel];
2020
2021
            for (codebook = 0; codebook < NUM_CODEBOOKS; codebook++) {
2022
                int prev_best_bitcount = INT_MAX;
2023
                int last_best;
2024
2025
                for (last_best = 0; last_best < 2; last_best++) {
2026
                    PathCounter *dst_path = &path_counter[codebook];
2027
                    PathCounter *src_path;
2028
                    int  temp_bitcount;
2029
2030
                    /* First test last path with same headers,
2031
                     * then with last best. */
2032
                    if (last_best) {
2033
                        src_path = &path_counter[NUM_CODEBOOKS];
2034
                    } else {
2035
                        if (compare_best_offset(&prev_bo[codebook], &cur_bo[codebook]))
2036
                            continue;
2037
                        else
2038
                            src_path = &path_counter[codebook];
2039
                    }
2040
2041
                    temp_bitcount = best_codebook_path_cost(ctx, channel, src_path, codebook);
2042
2043
                    if (temp_bitcount < best_bitcount) {
2044
                        best_bitcount = temp_bitcount;
2045
                        best_codebook = codebook;
2046
                    }
2047
2048
                    if (temp_bitcount < prev_best_bitcount) {
2049
                        prev_best_bitcount = temp_bitcount;
2050
                        if (src_path != dst_path)
2051
                            memcpy(dst_path, src_path, sizeof(PathCounter));
2052
                        av_strlcat(dst_path->path, path_counter_codebook[codebook], sizeof(dst_path->path));
2053
                        dst_path->bitcount = temp_bitcount;
2054
                    }
2055
                }
2056
            }
2057
2058
            prev_bo = cur_bo;
2059
2060
            memcpy(&path_counter[NUM_CODEBOOKS], &path_counter[best_codebook], sizeof(PathCounter));
2061
        }
2062
2063
        best_path = path_counter[NUM_CODEBOOKS].path + 1;
2064
2065
        /* Update context. */
2066
        for (index = 0; index < ctx->number_of_subblocks; index++) {
2067
            ChannelParams *cp = ctx->seq_channel_params + index*(ctx->avctx->channels) + channel;
2068
2069
            best_codebook = *best_path++ - ZERO_PATH;
2070
            cur_bo = &ctx->best_offset[index][channel][best_codebook];
2071
2072
            cp->huff_offset = cur_bo->offset;
2073
            cp->huff_lsbs   = cur_bo->lsb_bits + dp->quant_step_size[channel];
2074
            cp->codebook    = best_codebook;
2075
        }
2076
    }
2077
}
2078
2079
/** Analyzes all collected bitcounts and selects the best parameters for each
2080
 *  individual access unit.
2081
 *  TODO This is just a stub!
2082
 */
2083
static void set_major_params(MLPEncodeContext *ctx)
2084
{
2085
    RestartHeader *rh = ctx->cur_restart_header;
2086
    unsigned int index;
2087
    unsigned int substr;
2088
    uint8_t max_huff_lsbs = 0;
2089
    uint8_t max_output_bits = 0;
2090
2091
    for (substr = 0; substr < ctx->num_substreams; substr++) {
2092
        DecodingParams *seq_dp = (DecodingParams *) ctx->decoding_params+
2093
                                 (ctx->restart_intervals - 1)*(ctx->sequence_size)*(ctx->avctx->channels) +
2094
                                 (ctx->seq_offset[ctx->restart_intervals - 1])*(ctx->avctx->channels);
2095
2096
        ChannelParams *seq_cp = (ChannelParams *) ctx->channel_params +
2097
                                (ctx->restart_intervals - 1)*(ctx->sequence_size)*(ctx->avctx->channels) +
2098
                                (ctx->seq_offset[ctx->restart_intervals - 1])*(ctx->avctx->channels);
2099
        unsigned int channel;
2100
        for (index = 0; index < ctx->seq_size[ctx->restart_intervals-1]; index++) {
2101
            memcpy(&ctx->major_decoding_params[index][substr], seq_dp + index*(ctx->num_substreams) + substr, sizeof(DecodingParams));
2102
            for (channel = 0; channel < ctx->avctx->channels; channel++) {
2103
                uint8_t huff_lsbs = (seq_cp + index*(ctx->avctx->channels) + channel)->huff_lsbs;
2104
                if (max_huff_lsbs < huff_lsbs)
2105
                    max_huff_lsbs = huff_lsbs;
2106
                memcpy(&ctx->major_channel_params[index][channel],
2107
                       (seq_cp + index*(ctx->avctx->channels) + channel),
2108
                       sizeof(ChannelParams));
2109
            }
2110
        }
2111
    }
2112
2113
    rh->max_huff_lsbs = max_huff_lsbs;
2114
2115
    for (index = 0; index < ctx->number_of_frames; index++)
2116
        if (max_output_bits < ctx->max_output_bits[index])
2117
            max_output_bits = ctx->max_output_bits[index];
2118
    rh->max_output_bits = max_output_bits;
2119
2120
    for (substr = 0; substr < ctx->num_substreams; substr++) {
2121
2122
        ctx->cur_restart_header = &ctx->restart_header[substr];
2123
2124
        ctx->prev_decoding_params = &restart_decoding_params[substr];
2125
        ctx->prev_channel_params = restart_channel_params;
2126
2127
        for (index = 0; index < MAJOR_HEADER_INTERVAL + 1; index++) {
2128
                ctx->cur_decoding_params = &ctx->major_decoding_params[index][substr];
2129
                ctx->cur_channel_params = ctx->major_channel_params[index];
2130
2131
                ctx->major_params_changed[index][substr] = compare_decoding_params(ctx);
2132
2133
                ctx->prev_decoding_params = ctx->cur_decoding_params;
2134
                ctx->prev_channel_params = ctx->cur_channel_params;
2135
        }
2136
    }
2137
2138
    ctx->major_number_of_subblocks = ctx->number_of_subblocks;
2139
    ctx->major_filter_state_subblock = 1;
2140
    ctx->major_cur_subblock_index = 0;
2141
}
2142
2143
static void analyze_sample_buffer(MLPEncodeContext *ctx)
2144
{
2145
    ChannelParams *seq_cp = ctx->seq_channel_params;
2146
    DecodingParams *seq_dp = ctx->seq_decoding_params;
2147
    unsigned int index;
2148
    unsigned int substr;
2149
2150
    for (substr = 0; substr < ctx->num_substreams; substr++) {
2151
2152
        ctx->cur_restart_header = &ctx->restart_header[substr];
2153
        ctx->cur_decoding_params = seq_dp + 1*(ctx->num_substreams) + substr;
2154
        ctx->cur_channel_params = seq_cp + 1*(ctx->avctx->channels);
2155
2156
        determine_quant_step_size(ctx);
2157
        generate_2_noise_channels(ctx);
2158
        lossless_matrix_coeffs   (ctx);
2159
        rematrix_channels        (ctx);
2160
        determine_filters        (ctx);
2161
        apply_filters            (ctx);
2162
2163
        copy_restart_frame_params(ctx, substr);
2164
2165
        /* Copy frame_size from frames 0...max to decoding_params 1...max + 1
2166
         * decoding_params[0] is for the filter state subblock.
2167
         */
2168
        for (index = 0; index < ctx->number_of_frames; index++) {
2169
            DecodingParams *dp = seq_dp + (index + 1)*(ctx->num_substreams) + substr;
2170
            dp->blocksize = ctx->frame_size[index];
2171
        }
2172
        /* The official encoder seems to always encode a filter state subblock
2173
         * even if there are no filters. TODO check if it is possible to skip
2174
         * the filter state subblock for no filters.
2175
         */
2176
        (seq_dp + substr)->blocksize  = 8;
2177
        (seq_dp + 1*(ctx->num_substreams) + substr)->blocksize -= 8;
2178
2179
        for (index = 0; index < ctx->number_of_subblocks; index++) {
2180
                ctx->cur_decoding_params = seq_dp + index*(ctx->num_substreams) + substr;
2181
                ctx->cur_channel_params = seq_cp + index*(ctx->avctx->channels);
2182
                ctx->cur_best_offset = ctx->best_offset[index];
2183
                determine_bits(ctx);
2184
                ctx->sample_buffer += ctx->cur_decoding_params->blocksize * ctx->num_channels;
2185
        }
2186
2187
        set_best_codebook(ctx);
2188
    }
2189
}
2190
2191
static void process_major_frame(MLPEncodeContext *ctx)
2192
{
2193
    unsigned int substr;
2194
2195
    ctx->sample_buffer = ctx->major_inout_buffer;
2196
2197
    ctx->starting_frame_index = 0;
2198
    ctx->number_of_frames = ctx->major_number_of_frames;
2199
    ctx->number_of_samples = ctx->major_frame_size;
2200
2201
    for (substr = 0; substr < ctx->num_substreams; substr++) {
2202
        RestartHeader *rh = ctx->cur_restart_header;
2203
        unsigned int channel;
2204
2205
        ctx->cur_restart_header = &ctx->restart_header[substr];
2206
2207
        ctx->cur_decoding_params = &ctx->major_decoding_params[1][substr];
2208
        ctx->cur_channel_params = ctx->major_channel_params[1];
2209
2210
        generate_2_noise_channels(ctx);
2211
        rematrix_channels        (ctx);
2212
2213
        for (channel = rh->min_channel; channel <= rh->max_channel; channel++)
2214
            apply_filter(ctx, channel);
2215
    }
2216
}
2217
2218
/****************************************************************************/
2219
2220
static int mlp_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
2221
                            const AVFrame *frame, int *got_packet)
2222
{
2223
    MLPEncodeContext *ctx = avctx->priv_data;
2224
    unsigned int bytes_written = 0;
2225
    int restart_frame, ret;
2226
    uint8_t *data;
2227
2228
    if ((ret = ff_alloc_packet2(avctx, avpkt, 87500 * avctx->channels, 0)) < 0)
2229
        return ret;
2230
2231
    if (!frame)
2232
        return 1;
2233
2234
    /* add current frame to queue */
2235
    if ((ret = ff_af_queue_add(&ctx->afq, frame)) < 0)
2236
        return ret;
2237
2238
    data = frame->data[0];
2239
2240
    ctx->frame_index = avctx->frame_number % ctx->max_restart_interval;
2241
2242
    ctx->inout_buffer = ctx->major_inout_buffer
2243
                      + ctx->frame_index * ctx->one_sample_buffer_size;
2244
2245
    if (ctx->last_frame == ctx->inout_buffer) {
2246
        return 0;
2247
    }
2248
2249
    ctx->sample_buffer = ctx->major_scratch_buffer
2250
                       + ctx->frame_index * ctx->one_sample_buffer_size;
2251
2252
    ctx->write_buffer = ctx->inout_buffer;
2253
2254
    if (avctx->frame_number < ctx->max_restart_interval) {
2255
        if (data) {
2256
            goto input_and_return;
2257
        } else {
2258
            /* There are less frames than the requested major header interval.
2259
             * Update the context to reflect this.
2260
             */
2261
            ctx->max_restart_interval = avctx->frame_number;
2262
            ctx->frame_index = 0;
2263
2264
            ctx->sample_buffer = ctx->major_scratch_buffer;
2265
            ctx->inout_buffer = ctx->major_inout_buffer;
2266
        }
2267
    }
2268
2269
    if (ctx->frame_size[ctx->frame_index] > MAX_BLOCKSIZE) {
2270
        av_log(avctx, AV_LOG_ERROR, "Invalid frame size (%d > %d)\n",
2271
               ctx->frame_size[ctx->frame_index], MAX_BLOCKSIZE);
2272
        return -1;
2273
    }
2274
2275
    restart_frame = !ctx->frame_index;
2276
2277
    if (restart_frame) {
2278
        set_major_params(ctx);
2279
        if (ctx->min_restart_interval != ctx->max_restart_interval)
2280
        process_major_frame(ctx);
2281
    }
2282
2283
    if (ctx->min_restart_interval == ctx->max_restart_interval)
2284
        ctx->write_buffer = ctx->sample_buffer;
2285
2286
    bytes_written = write_access_unit(ctx, avpkt->data, avpkt->size, restart_frame);
2287
2288
    ctx->timestamp += ctx->frame_size[ctx->frame_index];
2289
    ctx->dts       += ctx->frame_size[ctx->frame_index];
2290
2291
input_and_return:
2292
2293
    if (data) {
2294
        ctx->frame_size[ctx->frame_index] = avctx->frame_size;
2295
        ctx->next_major_frame_size += avctx->frame_size;
2296
        ctx->next_major_number_of_frames++;
2297
        input_data(ctx, data);
2298
    } else if (!ctx->last_frame) {
2299
        ctx->last_frame = ctx->inout_buffer;
2300
    }
2301
2302
    restart_frame = (ctx->frame_index + 1) % ctx->min_restart_interval;
2303
2304
    if (!restart_frame) {
2305
        int seq_index;
2306
2307
        for (seq_index = 0;
2308
             seq_index < ctx->restart_intervals && (seq_index * ctx->min_restart_interval) <= ctx->avctx->frame_number;
2309
             seq_index++) {
2310
            unsigned int number_of_samples = 0;
2311
            unsigned int index;
2312
2313
            ctx->sample_buffer = ctx->major_scratch_buffer;
2314
            ctx->inout_buffer = ctx->major_inout_buffer;
2315
            ctx->seq_index = seq_index;
2316
2317
            ctx->starting_frame_index = (ctx->avctx->frame_number - (ctx->avctx->frame_number % ctx->min_restart_interval)
2318
                                      - (seq_index * ctx->min_restart_interval)) % ctx->max_restart_interval;
2319
            ctx->number_of_frames = ctx->next_major_number_of_frames;
2320
            ctx->number_of_subblocks = ctx->next_major_number_of_frames + 1;
2321
2322
            ctx->seq_channel_params = (ChannelParams *) ctx->channel_params +
2323
                                      (ctx->frame_index / ctx->min_restart_interval)*(ctx->sequence_size)*(ctx->avctx->channels) +
2324
                                      (ctx->seq_offset[seq_index])*(ctx->avctx->channels);
2325
2326
            ctx->seq_decoding_params = (DecodingParams *) ctx->decoding_params +
2327
                                       (ctx->frame_index / ctx->min_restart_interval)*(ctx->sequence_size)*(ctx->num_substreams) +
2328
                                       (ctx->seq_offset[seq_index])*(ctx->num_substreams);
2329
2330
            for (index = 0; index < ctx->number_of_frames; index++) {
2331
                number_of_samples += ctx->frame_size[(ctx->starting_frame_index + index) % ctx->max_restart_interval];
2332
            }
2333
            ctx->number_of_samples = number_of_samples;
2334
2335
            for (index = 0; index < ctx->seq_size[seq_index]; index++) {
2336
                clear_channel_params(ctx, ctx->seq_channel_params + index*(ctx->avctx->channels));
2337
                default_decoding_params(ctx, ctx->seq_decoding_params + index*(ctx->num_substreams));
2338
            }
2339
2340
            input_to_sample_buffer(ctx);
2341
2342
            analyze_sample_buffer(ctx);
2343
        }
2344
2345
        if (ctx->frame_index == (ctx->max_restart_interval - 1)) {
2346
            ctx->major_frame_size = ctx->next_major_frame_size;
2347
            ctx->next_major_frame_size = 0;
2348
            ctx->major_number_of_frames = ctx->next_major_number_of_frames;
2349
            ctx->next_major_number_of_frames = 0;
2350
2351
            if (!ctx->major_frame_size)
2352
                goto no_data_left;
2353
        }
2354
    }
2355
2356
no_data_left:
2357
2358
    ff_af_queue_remove(&ctx->afq, avctx->frame_size, &avpkt->pts,
2359
                       &avpkt->duration);
2360
    avpkt->size = bytes_written;
2361
    *got_packet = 1;
2362
    return 0;
2363
}
2364
2365
static av_cold int mlp_encode_close(AVCodecContext *avctx)
2366
{
2367
    MLPEncodeContext *ctx = avctx->priv_data;
2368
2369
    ff_lpc_end(&ctx->lpc_ctx);
2370
2371
    av_freep(&ctx->lossless_check_data);
2372
    av_freep(&ctx->major_scratch_buffer);
2373
    av_freep(&ctx->major_inout_buffer);
2374
    av_freep(&ctx->lpc_sample_buffer);
2375
    av_freep(&ctx->decoding_params);
2376
    av_freep(&ctx->channel_params);
2377
    av_freep(&ctx->frame_size);
2378
    ff_af_queue_close(&ctx->afq);
2379
2380
    return 0;
2381
}
2382
2383
#if CONFIG_MLP_ENCODER
2384
AVCodec ff_mlp_encoder = {
2385
    .name                   ="mlp",
2386
    .long_name              = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
2387
    .type                   = AVMEDIA_TYPE_AUDIO,
2388
    .id                     = AV_CODEC_ID_MLP,
2389
    .priv_data_size         = sizeof(MLPEncodeContext),
2390
    .init                   = mlp_encode_init,
2391
    .encode2                = mlp_encode_frame,
2392
    .close                  = mlp_encode_close,
2393
    .capabilities           = AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_EXPERIMENTAL,
2394
    .sample_fmts            = (const enum AVSampleFormat[]) {AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE},
2395
    .supported_samplerates  = (const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
2396
    .channel_layouts        = ff_mlp_channel_layouts,
2397
};
2398
#endif
2399
#if CONFIG_TRUEHD_ENCODER
2400
AVCodec ff_truehd_encoder = {
2401
    .name                   ="truehd",
2402
    .long_name              = NULL_IF_CONFIG_SMALL("TrueHD"),
2403
    .type                   = AVMEDIA_TYPE_AUDIO,
2404
    .id                     = AV_CODEC_ID_TRUEHD,
2405
    .priv_data_size         = sizeof(MLPEncodeContext),
2406
    .init                   = mlp_encode_init,
2407
    .encode2                = mlp_encode_frame,
2408
    .close                  = mlp_encode_close,
2409
    .capabilities           = AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_EXPERIMENTAL,
2410
    .sample_fmts            = (const enum AVSampleFormat[]) {AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE},
2411
    .supported_samplerates  = (const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
2412
    .channel_layouts        = (const uint64_t[]) {AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_5POINT0_BACK, AV_CH_LAYOUT_5POINT1_BACK, 0},
2413
};
2414
#endif