GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/apedec.c Lines: 564 769 73.3 %
Date: 2020-01-28 04:56:05 Branches: 207 322 64.3 %

Line Branch Exec Source
1
/*
2
 * Monkey's Audio lossless audio decoder
3
 * Copyright (c) 2007 Benjamin Zores <ben@geexbox.org>
4
 *  based upon libdemac from Dave Chapman.
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22
23
#include <inttypes.h>
24
25
#include "libavutil/avassert.h"
26
#include "libavutil/channel_layout.h"
27
#include "libavutil/opt.h"
28
#include "lossless_audiodsp.h"
29
#include "avcodec.h"
30
#include "bswapdsp.h"
31
#include "bytestream.h"
32
#include "internal.h"
33
#include "get_bits.h"
34
#include "unary.h"
35
36
/**
37
 * @file
38
 * Monkey's Audio lossless audio decoder
39
 */
40
41
#define MAX_CHANNELS        2
42
#define MAX_BYTESPERSAMPLE  3
43
44
#define APE_FRAMECODE_MONO_SILENCE    1
45
#define APE_FRAMECODE_STEREO_SILENCE  3
46
#define APE_FRAMECODE_PSEUDO_STEREO   4
47
48
#define HISTORY_SIZE 512
49
#define PREDICTOR_ORDER 8
50
/** Total size of all predictor histories */
51
#define PREDICTOR_SIZE 50
52
53
#define YDELAYA (18 + PREDICTOR_ORDER*4)
54
#define YDELAYB (18 + PREDICTOR_ORDER*3)
55
#define XDELAYA (18 + PREDICTOR_ORDER*2)
56
#define XDELAYB (18 + PREDICTOR_ORDER)
57
58
#define YADAPTCOEFFSA 18
59
#define XADAPTCOEFFSA 14
60
#define YADAPTCOEFFSB 10
61
#define XADAPTCOEFFSB 5
62
63
/**
64
 * Possible compression levels
65
 * @{
66
 */
67
enum APECompressionLevel {
68
    COMPRESSION_LEVEL_FAST       = 1000,
69
    COMPRESSION_LEVEL_NORMAL     = 2000,
70
    COMPRESSION_LEVEL_HIGH       = 3000,
71
    COMPRESSION_LEVEL_EXTRA_HIGH = 4000,
72
    COMPRESSION_LEVEL_INSANE     = 5000
73
};
74
/** @} */
75
76
#define APE_FILTER_LEVELS 3
77
78
/** Filter orders depending on compression level */
79
static const uint16_t ape_filter_orders[5][APE_FILTER_LEVELS] = {
80
    {  0,   0,    0 },
81
    { 16,   0,    0 },
82
    { 64,   0,    0 },
83
    { 32, 256,    0 },
84
    { 16, 256, 1280 }
85
};
86
87
/** Filter fraction bits depending on compression level */
88
static const uint8_t ape_filter_fracbits[5][APE_FILTER_LEVELS] = {
89
    {  0,  0,  0 },
90
    { 11,  0,  0 },
91
    { 11,  0,  0 },
92
    { 10, 13,  0 },
93
    { 11, 13, 15 }
94
};
95
96
97
/** Filters applied to the decoded data */
98
typedef struct APEFilter {
99
    int16_t *coeffs;        ///< actual coefficients used in filtering
100
    int16_t *adaptcoeffs;   ///< adaptive filter coefficients used for correcting of actual filter coefficients
101
    int16_t *historybuffer; ///< filter memory
102
    int16_t *delay;         ///< filtered values
103
104
    int avg;
105
} APEFilter;
106
107
typedef struct APERice {
108
    uint32_t k;
109
    uint32_t ksum;
110
} APERice;
111
112
typedef struct APERangecoder {
113
    uint32_t low;           ///< low end of interval
114
    uint32_t range;         ///< length of interval
115
    uint32_t help;          ///< bytes_to_follow resp. intermediate value
116
    unsigned int buffer;    ///< buffer for input/output
117
} APERangecoder;
118
119
/** Filter histories */
120
typedef struct APEPredictor {
121
    int32_t *buf;
122
123
    int32_t lastA[2];
124
125
    int32_t filterA[2];
126
    int32_t filterB[2];
127
128
    uint32_t coeffsA[2][4];  ///< adaption coefficients
129
    uint32_t coeffsB[2][5];  ///< adaption coefficients
130
    int32_t historybuffer[HISTORY_SIZE + PREDICTOR_SIZE];
131
132
    unsigned int sample_pos;
133
} APEPredictor;
134
135
/** Decoder context */
136
typedef struct APEContext {
137
    AVClass *class;                          ///< class for AVOptions
138
    AVCodecContext *avctx;
139
    BswapDSPContext bdsp;
140
    LLAudDSPContext adsp;
141
    int channels;
142
    int samples;                             ///< samples left to decode in current frame
143
    int bps;
144
145
    int fileversion;                         ///< codec version, very important in decoding process
146
    int compression_level;                   ///< compression levels
147
    int fset;                                ///< which filter set to use (calculated from compression level)
148
    int flags;                               ///< global decoder flags
149
150
    uint32_t CRC;                            ///< frame CRC
151
    int frameflags;                          ///< frame flags
152
    APEPredictor predictor;                  ///< predictor used for final reconstruction
153
154
    int32_t *decoded_buffer;
155
    int decoded_size;
156
    int32_t *decoded[MAX_CHANNELS];          ///< decoded data for each channel
157
    int blocks_per_loop;                     ///< maximum number of samples to decode for each call
158
159
    int16_t* filterbuf[APE_FILTER_LEVELS];   ///< filter memory
160
161
    APERangecoder rc;                        ///< rangecoder used to decode actual values
162
    APERice riceX;                           ///< rice code parameters for the second channel
163
    APERice riceY;                           ///< rice code parameters for the first channel
164
    APEFilter filters[APE_FILTER_LEVELS][2]; ///< filters used for reconstruction
165
    GetBitContext gb;
166
167
    uint8_t *data;                           ///< current frame data
168
    uint8_t *data_end;                       ///< frame data end
169
    int data_size;                           ///< frame data allocated size
170
    const uint8_t *ptr;                      ///< current position in frame data
171
172
    int error;
173
174
    void (*entropy_decode_mono)(struct APEContext *ctx, int blockstodecode);
175
    void (*entropy_decode_stereo)(struct APEContext *ctx, int blockstodecode);
176
    void (*predictor_decode_mono)(struct APEContext *ctx, int count);
177
    void (*predictor_decode_stereo)(struct APEContext *ctx, int count);
178
} APEContext;
179
180
static void ape_apply_filters(APEContext *ctx, int32_t *decoded0,
181
                              int32_t *decoded1, int count);
182
183
static void entropy_decode_mono_0000(APEContext *ctx, int blockstodecode);
184
static void entropy_decode_stereo_0000(APEContext *ctx, int blockstodecode);
185
static void entropy_decode_mono_3860(APEContext *ctx, int blockstodecode);
186
static void entropy_decode_stereo_3860(APEContext *ctx, int blockstodecode);
187
static void entropy_decode_mono_3900(APEContext *ctx, int blockstodecode);
188
static void entropy_decode_stereo_3900(APEContext *ctx, int blockstodecode);
189
static void entropy_decode_stereo_3930(APEContext *ctx, int blockstodecode);
190
static void entropy_decode_mono_3990(APEContext *ctx, int blockstodecode);
191
static void entropy_decode_stereo_3990(APEContext *ctx, int blockstodecode);
192
193
static void predictor_decode_mono_3800(APEContext *ctx, int count);
194
static void predictor_decode_stereo_3800(APEContext *ctx, int count);
195
static void predictor_decode_mono_3930(APEContext *ctx, int count);
196
static void predictor_decode_stereo_3930(APEContext *ctx, int count);
197
static void predictor_decode_mono_3950(APEContext *ctx, int count);
198
static void predictor_decode_stereo_3950(APEContext *ctx, int count);
199
200
27
static av_cold int ape_decode_close(AVCodecContext *avctx)
201
{
202
27
    APEContext *s = avctx->priv_data;
203
    int i;
204
205
108
    for (i = 0; i < APE_FILTER_LEVELS; i++)
206
81
        av_freep(&s->filterbuf[i]);
207
208
27
    av_freep(&s->decoded_buffer);
209
27
    av_freep(&s->data);
210
27
    s->decoded_size = s->data_size = 0;
211
212
27
    return 0;
213
}
214
215
27
static av_cold int ape_decode_init(AVCodecContext *avctx)
216
{
217
27
    APEContext *s = avctx->priv_data;
218
    int i;
219
220
27
    if (avctx->extradata_size != 6) {
221
        av_log(avctx, AV_LOG_ERROR, "Incorrect extradata\n");
222
        return AVERROR(EINVAL);
223
    }
224
27
    if (avctx->channels > 2) {
225
        av_log(avctx, AV_LOG_ERROR, "Only mono and stereo is supported\n");
226
        return AVERROR(EINVAL);
227
    }
228
27
    s->bps = avctx->bits_per_coded_sample;
229

27
    switch (s->bps) {
230
    case 8:
231
        avctx->sample_fmt = AV_SAMPLE_FMT_U8P;
232
        break;
233
27
    case 16:
234
27
        avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
235
27
        break;
236
    case 24:
237
        avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
238
        break;
239
    default:
240
        avpriv_request_sample(avctx,
241
                              "%d bits per coded sample", s->bps);
242
        return AVERROR_PATCHWELCOME;
243
    }
244
27
    s->avctx             = avctx;
245
27
    s->channels          = avctx->channels;
246
27
    s->fileversion       = AV_RL16(avctx->extradata);
247
27
    s->compression_level = AV_RL16(avctx->extradata + 2);
248
27
    s->flags             = AV_RL16(avctx->extradata + 4);
249
250
27
    av_log(avctx, AV_LOG_VERBOSE, "Compression Level: %d - Flags: %d\n",
251
           s->compression_level, s->flags);
252

27
    if (s->compression_level % 1000 || s->compression_level > COMPRESSION_LEVEL_INSANE ||
253
27
        !s->compression_level ||
254

27
        (s->fileversion < 3930 && s->compression_level == COMPRESSION_LEVEL_INSANE)) {
255
        av_log(avctx, AV_LOG_ERROR, "Incorrect compression level %d\n",
256
               s->compression_level);
257
        return AVERROR_INVALIDDATA;
258
    }
259
27
    s->fset = s->compression_level / 1000 - 1;
260
66
    for (i = 0; i < APE_FILTER_LEVELS; i++) {
261
66
        if (!ape_filter_orders[s->fset][i])
262
27
            break;
263

39
        FF_ALLOC_OR_GOTO(avctx, s->filterbuf[i],
264
                         (ape_filter_orders[s->fset][i] * 3 + HISTORY_SIZE) * 4,
265
                         filter_alloc_fail);
266
    }
267
268
27
    if (s->fileversion < 3860) {
269
4
        s->entropy_decode_mono   = entropy_decode_mono_0000;
270
4
        s->entropy_decode_stereo = entropy_decode_stereo_0000;
271
23
    } else if (s->fileversion < 3900) {
272
8
        s->entropy_decode_mono   = entropy_decode_mono_3860;
273
8
        s->entropy_decode_stereo = entropy_decode_stereo_3860;
274
15
    } else if (s->fileversion < 3930) {
275
8
        s->entropy_decode_mono   = entropy_decode_mono_3900;
276
8
        s->entropy_decode_stereo = entropy_decode_stereo_3900;
277
7
    } else if (s->fileversion < 3990) {
278
4
        s->entropy_decode_mono   = entropy_decode_mono_3900;
279
4
        s->entropy_decode_stereo = entropy_decode_stereo_3930;
280
    } else {
281
3
        s->entropy_decode_mono   = entropy_decode_mono_3990;
282
3
        s->entropy_decode_stereo = entropy_decode_stereo_3990;
283
    }
284
285
27
    if (s->fileversion < 3930) {
286
20
        s->predictor_decode_mono   = predictor_decode_mono_3800;
287
20
        s->predictor_decode_stereo = predictor_decode_stereo_3800;
288
7
    } else if (s->fileversion < 3950) {
289
4
        s->predictor_decode_mono   = predictor_decode_mono_3930;
290
4
        s->predictor_decode_stereo = predictor_decode_stereo_3930;
291
    } else {
292
3
        s->predictor_decode_mono   = predictor_decode_mono_3950;
293
3
        s->predictor_decode_stereo = predictor_decode_stereo_3950;
294
    }
295
296
27
    ff_bswapdsp_init(&s->bdsp);
297
27
    ff_llauddsp_init(&s->adsp);
298
27
    avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
299
300
27
    return 0;
301
filter_alloc_fail:
302
    ape_decode_close(avctx);
303
    return AVERROR(ENOMEM);
304
}
305
306
/**
307
 * @name APE range decoding functions
308
 * @{
309
 */
310
311
#define CODE_BITS    32
312
#define TOP_VALUE    ((unsigned int)1 << (CODE_BITS-1))
313
#define SHIFT_BITS   (CODE_BITS - 9)
314
#define EXTRA_BITS   ((CODE_BITS-2) % 8 + 1)
315
#define BOTTOM_VALUE (TOP_VALUE >> 8)
316
317
/** Start the decoder */
318
26
static inline void range_start_decoding(APEContext *ctx)
319
{
320
26
    ctx->rc.buffer = bytestream_get_byte(&ctx->ptr);
321
26
    ctx->rc.low    = ctx->rc.buffer >> (8 - EXTRA_BITS);
322
26
    ctx->rc.range  = (uint32_t) 1 << EXTRA_BITS;
323
26
}
324
325
/** Perform normalization */
326
5289992
static inline void range_dec_normalize(APEContext *ctx)
327
{
328
8280608
    while (ctx->rc.range <= BOTTOM_VALUE) {
329
2990616
        ctx->rc.buffer <<= 8;
330
2990616
        if(ctx->ptr < ctx->data_end) {
331
2986366
            ctx->rc.buffer += *ctx->ptr;
332
2986366
            ctx->ptr++;
333
        } else {
334
4250
            ctx->error = 1;
335
        }
336
2990616
        ctx->rc.low    = (ctx->rc.low << 8)    | ((ctx->rc.buffer >> 1) & 0xFF);
337
2990616
        ctx->rc.range  <<= 8;
338
    }
339
5289992
}
340
341
/**
342
 * Calculate cumulative frequency for next symbol. Does NO update!
343
 * @param ctx decoder context
344
 * @param tot_f is the total frequency or (code_value)1<<shift
345
 * @return the cumulative frequency
346
 */
347
875520
static inline int range_decode_culfreq(APEContext *ctx, int tot_f)
348
{
349
875520
    range_dec_normalize(ctx);
350
875520
    ctx->rc.help = ctx->rc.range / tot_f;
351
875520
    return ctx->rc.low / ctx->rc.help;
352
}
353
354
/**
355
 * Decode value with given size in bits
356
 * @param ctx decoder context
357
 * @param shift number of bits to decode
358
 */
359
4414464
static inline int range_decode_culshift(APEContext *ctx, int shift)
360
{
361
4414464
    range_dec_normalize(ctx);
362
4414464
    ctx->rc.help = ctx->rc.range >> shift;
363
4414464
    return ctx->rc.low / ctx->rc.help;
364
}
365
366
367
/**
368
 * Update decoding state
369
 * @param ctx decoder context
370
 * @param sy_f the interval length (frequency of the symbol)
371
 * @param lt_f the lower end (frequency sum of < symbols)
372
 */
373
5289984
static inline void range_decode_update(APEContext *ctx, int sy_f, int lt_f)
374
{
375
5289984
    ctx->rc.low  -= ctx->rc.help * lt_f;
376
5289984
    ctx->rc.range = ctx->rc.help * sy_f;
377
5289984
}
378
379
/** Decode n bits (n <= 16) without modelling */
380
1769472
static inline int range_decode_bits(APEContext *ctx, int n)
381
{
382
1769472
    int sym = range_decode_culshift(ctx, n);
383
1769472
    range_decode_update(ctx, 1, sym);
384
1769472
    return sym;
385
}
386
387
388
#define MODEL_ELEMENTS 64
389
390
/**
391
 * Fixed probabilities for symbols in Monkey Audio version 3.97
392
 */
393
static const uint16_t counts_3970[22] = {
394
        0, 14824, 28224, 39348, 47855, 53994, 58171, 60926,
395
    62682, 63786, 64463, 64878, 65126, 65276, 65365, 65419,
396
    65450, 65469, 65480, 65487, 65491, 65493,
397
};
398
399
/**
400
 * Probability ranges for symbols in Monkey Audio version 3.97
401
 */
402
static const uint16_t counts_diff_3970[21] = {
403
    14824, 13400, 11124, 8507, 6139, 4177, 2755, 1756,
404
    1104, 677, 415, 248, 150, 89, 54, 31,
405
    19, 11, 7, 4, 2,
406
};
407
408
/**
409
 * Fixed probabilities for symbols in Monkey Audio version 3.98
410
 */
411
static const uint16_t counts_3980[22] = {
412
        0, 19578, 36160, 48417, 56323, 60899, 63265, 64435,
413
    64971, 65232, 65351, 65416, 65447, 65466, 65476, 65482,
414
    65485, 65488, 65490, 65491, 65492, 65493,
415
};
416
417
/**
418
 * Probability ranges for symbols in Monkey Audio version 3.98
419
 */
420
static const uint16_t counts_diff_3980[21] = {
421
    19578, 16582, 12257, 7906, 4576, 2366, 1170, 536,
422
    261, 119, 65, 31, 19, 10, 6, 3,
423
    3, 2, 1, 1, 1,
424
};
425
426
/**
427
 * Decode symbol
428
 * @param ctx decoder context
429
 * @param counts probability range start position
430
 * @param counts_diff probability range widths
431
 */
432
2644992
static inline int range_get_symbol(APEContext *ctx,
433
                                   const uint16_t counts[],
434
                                   const uint16_t counts_diff[])
435
{
436
    int symbol, cf;
437
438
2644992
    cf = range_decode_culshift(ctx, 16);
439
440
2644992
    if(cf > 65492){
441
183
        symbol= cf - 65535 + 63;
442
183
        range_decode_update(ctx, 1, cf);
443
183
        if(cf > 65535)
444
1
            ctx->error=1;
445
183
        return symbol;
446
    }
447
    /* figure out the symbol inefficiently; a binary search would be much better */
448
8331690
    for (symbol = 0; counts[symbol + 1] <= cf; symbol++);
449
450
2644809
    range_decode_update(ctx, counts_diff[symbol], counts[symbol]);
451
452
2644809
    return symbol;
453
}
454
/** @} */ // group rangecoder
455
456
2644992
static inline void update_rice(APERice *rice, unsigned int x)
457
{
458
2644992
    int lim = rice->k ? (1 << (rice->k + 4)) : 0;
459
2644992
    rice->ksum += ((x + 1) / 2) - ((rice->ksum + 16) >> 5);
460
461
2644992
    if (rice->ksum < lim)
462
32925
        rice->k--;
463

2612067
    else if (rice->ksum >= (1 << (rice->k + 5)) && rice->k < 24)
464
32829
        rice->k++;
465
2644992
}
466
467
460800
static inline int get_rice_ook(GetBitContext *gb, int k)
468
{
469
    unsigned int x;
470
471
460800
    x = get_unary(gb, 1, get_bits_left(gb));
472
473
460800
    if (k)
474
460800
        x = (x << k) | get_bits(gb, k);
475
476
460800
    return x;
477
}
478
479
921600
static inline int ape_decode_value_3860(APEContext *ctx, GetBitContext *gb,
480
                                        APERice *rice)
481
{
482
    unsigned int x, overflow;
483
484
921600
    overflow = get_unary(gb, 1, get_bits_left(gb));
485
486
921600
    if (ctx->fileversion > 3880) {
487
460801
        while (overflow >= 16) {
488
1
            overflow -= 16;
489
1
            rice->k  += 4;
490
        }
491
    }
492
493
921600
    if (!rice->k)
494
        x = overflow;
495
921600
    else if(rice->k <= MIN_CACHE_BITS) {
496
921600
        x = (overflow << rice->k) + get_bits(gb, rice->k);
497
    } else {
498
        av_log(ctx->avctx, AV_LOG_ERROR, "Too many bits: %"PRIu32"\n", rice->k);
499
        ctx->error = 1;
500
        return AVERROR_INVALIDDATA;
501
    }
502
921600
    rice->ksum += x - (rice->ksum + 8 >> 4);
503

921600
    if (rice->ksum < (rice->k ? 1 << (rice->k + 4) : 0))
504
23449
        rice->k--;
505

898151
    else if (rice->ksum >= (1 << (rice->k + 5)) && rice->k < 24)
506
23287
        rice->k++;
507
508
    /* Convert to signed */
509
921600
    return ((x >> 1) ^ ((x & 1) - 1)) + 1;
510
}
511
512
1769472
static inline int ape_decode_value_3900(APEContext *ctx, APERice *rice)
513
{
514
    unsigned int x, overflow;
515
    int tmpk;
516
517
1769472
    overflow = range_get_symbol(ctx, counts_3970, counts_diff_3970);
518
519
1769472
    if (overflow == (MODEL_ELEMENTS - 1)) {
520
        tmpk = range_decode_bits(ctx, 5);
521
        overflow = 0;
522
    } else
523
1769472
        tmpk = (rice->k < 1) ? 0 : rice->k - 1;
524
525

1769472
    if (tmpk <= 16 || ctx->fileversion < 3910) {
526
1769472
        if (tmpk > 23) {
527
            av_log(ctx->avctx, AV_LOG_ERROR, "Too many bits: %d\n", tmpk);
528
            return AVERROR_INVALIDDATA;
529
        }
530
1769472
        x = range_decode_bits(ctx, tmpk);
531
    } else if (tmpk <= 31) {
532
        x = range_decode_bits(ctx, 16);
533
        x |= (range_decode_bits(ctx, tmpk - 16) << 16);
534
    } else {
535
        av_log(ctx->avctx, AV_LOG_ERROR, "Too many bits: %d\n", tmpk);
536
        return AVERROR_INVALIDDATA;
537
    }
538
1769472
    x += overflow << tmpk;
539
540
1769472
    update_rice(rice, x);
541
542
    /* Convert to signed */
543
1769472
    return ((x >> 1) ^ ((x & 1) - 1)) + 1;
544
}
545
546
875520
static inline int ape_decode_value_3990(APEContext *ctx, APERice *rice)
547
{
548
    unsigned int x, overflow;
549
    int base, pivot;
550
551
875520
    pivot = rice->ksum >> 5;
552
875520
    if (pivot == 0)
553
3207
        pivot = 1;
554
555
875520
    overflow = range_get_symbol(ctx, counts_3980, counts_diff_3980);
556
557
875520
    if (overflow == (MODEL_ELEMENTS - 1)) {
558
        overflow  = (unsigned)range_decode_bits(ctx, 16) << 16;
559
        overflow |= range_decode_bits(ctx, 16);
560
    }
561
562
875520
    if (pivot < 0x10000) {
563
875520
        base = range_decode_culfreq(ctx, pivot);
564
875520
        range_decode_update(ctx, 1, base);
565
    } else {
566
        int base_hi = pivot, base_lo;
567
        int bbits = 0;
568
569
        while (base_hi & ~0xFFFF) {
570
            base_hi >>= 1;
571
            bbits++;
572
        }
573
        base_hi = range_decode_culfreq(ctx, base_hi + 1);
574
        range_decode_update(ctx, 1, base_hi);
575
        base_lo = range_decode_culfreq(ctx, 1 << bbits);
576
        range_decode_update(ctx, 1, base_lo);
577
578
        base = (base_hi << bbits) + base_lo;
579
    }
580
581
875520
    x = base + overflow * pivot;
582
583
875520
    update_rice(rice, x);
584
585
    /* Convert to signed */
586
875520
    return ((x >> 1) ^ ((x & 1) - 1)) + 1;
587
}
588
589
22
static void decode_array_0000(APEContext *ctx, GetBitContext *gb,
590
                              int32_t *out, APERice *rice, int blockstodecode)
591
{
592
    int i;
593
    unsigned ksummax, ksummin;
594
595
22
    rice->ksum = 0;
596
132
    for (i = 0; i < FFMIN(blockstodecode, 5); i++) {
597
110
        out[i] = get_rice_ook(&ctx->gb, 10);
598
110
        rice->ksum += out[i];
599
    }
600
22
    rice->k = av_log2(rice->ksum / 10) + 1;
601
22
    if (rice->k >= 24)
602
        return;
603
1320
    for (; i < FFMIN(blockstodecode, 64); i++) {
604
1298
        out[i] = get_rice_ook(&ctx->gb, rice->k);
605
1298
        rice->ksum += out[i];
606
1298
        rice->k = av_log2(rice->ksum / ((i + 1) * 2)) + 1;
607
1298
        if (rice->k >= 24)
608
            return;
609
    }
610
22
    ksummax = 1 << rice->k + 7;
611
22
    ksummin = rice->k ? (1 << rice->k + 6) : 0;
612
459414
    for (; i < blockstodecode; i++) {
613
459392
        if (get_bits_left(&ctx->gb) < 1) {
614
            ctx->error = 1;
615
            return ;
616
        }
617
459392
        out[i] = get_rice_ook(&ctx->gb, rice->k);
618
459392
        rice->ksum += out[i] - out[i - 64];
619
463189
        while (rice->ksum < ksummin) {
620
3797
            rice->k--;
621
3797
            ksummin = rice->k ? ksummin >> 1 : 0;
622
3797
            ksummax >>= 1;
623
        }
624
463179
        while (rice->ksum >= ksummax) {
625
3787
            rice->k++;
626
3787
            if (rice->k > 24)
627
                return;
628
3787
            ksummax <<= 1;
629
3787
            ksummin = ksummin ? ksummin << 1 : 128;
630
        }
631
    }
632
633
460822
    for (i = 0; i < blockstodecode; i++)
634
460800
        out[i] = ((out[i] >> 1) ^ ((out[i] & 1) - 1)) + 1;
635
}
636
637
static void entropy_decode_mono_0000(APEContext *ctx, int blockstodecode)
638
{
639
    decode_array_0000(ctx, &ctx->gb, ctx->decoded[0], &ctx->riceY,
640
                      blockstodecode);
641
}
642
643
11
static void entropy_decode_stereo_0000(APEContext *ctx, int blockstodecode)
644
{
645
11
    decode_array_0000(ctx, &ctx->gb, ctx->decoded[0], &ctx->riceY,
646
                      blockstodecode);
647
11
    decode_array_0000(ctx, &ctx->gb, ctx->decoded[1], &ctx->riceX,
648
                      blockstodecode);
649
11
}
650
651
static void entropy_decode_mono_3860(APEContext *ctx, int blockstodecode)
652
{
653
    int32_t *decoded0 = ctx->decoded[0];
654
655
    while (blockstodecode--)
656
        *decoded0++ = ape_decode_value_3860(ctx, &ctx->gb, &ctx->riceY);
657
}
658
659
22
static void entropy_decode_stereo_3860(APEContext *ctx, int blockstodecode)
660
{
661
22
    int32_t *decoded0 = ctx->decoded[0];
662
22
    int32_t *decoded1 = ctx->decoded[1];
663
22
    int blocks = blockstodecode;
664
665
460822
    while (blockstodecode--)
666
460800
        *decoded0++ = ape_decode_value_3860(ctx, &ctx->gb, &ctx->riceY);
667
460822
    while (blocks--)
668
460800
        *decoded1++ = ape_decode_value_3860(ctx, &ctx->gb, &ctx->riceX);
669
22
}
670
671
static void entropy_decode_mono_3900(APEContext *ctx, int blockstodecode)
672
{
673
    int32_t *decoded0 = ctx->decoded[0];
674
675
    while (blockstodecode--)
676
        *decoded0++ = ape_decode_value_3900(ctx, &ctx->riceY);
677
}
678
679
8
static void entropy_decode_stereo_3900(APEContext *ctx, int blockstodecode)
680
{
681
8
    int32_t *decoded0 = ctx->decoded[0];
682
8
    int32_t *decoded1 = ctx->decoded[1];
683
8
    int blocks = blockstodecode;
684
685
589832
    while (blockstodecode--)
686
589824
        *decoded0++ = ape_decode_value_3900(ctx, &ctx->riceY);
687
8
    range_dec_normalize(ctx);
688
    // because of some implementation peculiarities we need to backpedal here
689
8
    ctx->ptr -= 1;
690
8
    range_start_decoding(ctx);
691
589832
    while (blocks--)
692
589824
        *decoded1++ = ape_decode_value_3900(ctx, &ctx->riceX);
693
8
}
694
695
64
static void entropy_decode_stereo_3930(APEContext *ctx, int blockstodecode)
696
{
697
64
    int32_t *decoded0 = ctx->decoded[0];
698
64
    int32_t *decoded1 = ctx->decoded[1];
699
700
294976
    while (blockstodecode--) {
701
294912
        *decoded0++ = ape_decode_value_3900(ctx, &ctx->riceY);
702
294912
        *decoded1++ = ape_decode_value_3900(ctx, &ctx->riceX);
703
    }
704
64
}
705
706
static void entropy_decode_mono_3990(APEContext *ctx, int blockstodecode)
707
{
708
    int32_t *decoded0 = ctx->decoded[0];
709
710
    while (blockstodecode--)
711
        *decoded0++ = ape_decode_value_3990(ctx, &ctx->riceY);
712
}
713
714
95
static void entropy_decode_stereo_3990(APEContext *ctx, int blockstodecode)
715
{
716
95
    int32_t *decoded0 = ctx->decoded[0];
717
95
    int32_t *decoded1 = ctx->decoded[1];
718
719
437855
    while (blockstodecode--) {
720
437760
        *decoded0++ = ape_decode_value_3990(ctx, &ctx->riceY);
721
437760
        *decoded1++ = ape_decode_value_3990(ctx, &ctx->riceX);
722
    }
723
95
}
724
725
51
static int init_entropy_decoder(APEContext *ctx)
726
{
727
    /* Read the CRC */
728
51
    if (ctx->fileversion >= 3900) {
729
18
        if (ctx->data_end - ctx->ptr < 6)
730
            return AVERROR_INVALIDDATA;
731
18
        ctx->CRC = bytestream_get_be32(&ctx->ptr);
732
    } else {
733
33
        ctx->CRC = get_bits_long(&ctx->gb, 32);
734
    }
735
736
    /* Read the frame flags if they exist */
737
51
    ctx->frameflags = 0;
738

51
    if ((ctx->fileversion > 3820) && (ctx->CRC & 0x80000000)) {
739
        ctx->CRC &= ~0x80000000;
740
741
        if (ctx->data_end - ctx->ptr < 6)
742
            return AVERROR_INVALIDDATA;
743
        ctx->frameflags = bytestream_get_be32(&ctx->ptr);
744
    }
745
746
    /* Initialize the rice structs */
747
51
    ctx->riceX.k = 10;
748
51
    ctx->riceX.ksum = (1 << ctx->riceX.k) * 16;
749
51
    ctx->riceY.k = 10;
750
51
    ctx->riceY.ksum = (1 << ctx->riceY.k) * 16;
751
752
51
    if (ctx->fileversion >= 3900) {
753
        /* The first 8 bits of input are ignored. */
754
18
        ctx->ptr++;
755
756
18
        range_start_decoding(ctx);
757
    }
758
759
51
    return 0;
760
}
761
762
static const int32_t initial_coeffs_fast_3320[1] = {
763
    375,
764
};
765
766
static const int32_t initial_coeffs_a_3800[3] = {
767
    64, 115, 64,
768
};
769
770
static const int32_t initial_coeffs_b_3800[2] = {
771
    740, 0
772
};
773
774
static const int32_t initial_coeffs_3930[4] = {
775
    360, 317, -109, 98
776
};
777
778
51
static void init_predictor_decoder(APEContext *ctx)
779
{
780
51
    APEPredictor *p = &ctx->predictor;
781
782
    /* Zero the history buffers */
783
51
    memset(p->historybuffer, 0, PREDICTOR_SIZE * sizeof(*p->historybuffer));
784
51
    p->buf = p->historybuffer;
785
786
    /* Initialize and zero the coefficients */
787
51
    if (ctx->fileversion < 3930) {
788
41
        if (ctx->compression_level == COMPRESSION_LEVEL_FAST) {
789
            memcpy(p->coeffsA[0], initial_coeffs_fast_3320,
790
                   sizeof(initial_coeffs_fast_3320));
791
            memcpy(p->coeffsA[1], initial_coeffs_fast_3320,
792
                   sizeof(initial_coeffs_fast_3320));
793
        } else {
794
41
            memcpy(p->coeffsA[0], initial_coeffs_a_3800,
795
                   sizeof(initial_coeffs_a_3800));
796
41
            memcpy(p->coeffsA[1], initial_coeffs_a_3800,
797
                   sizeof(initial_coeffs_a_3800));
798
        }
799
    } else {
800
10
        memcpy(p->coeffsA[0], initial_coeffs_3930, sizeof(initial_coeffs_3930));
801
10
        memcpy(p->coeffsA[1], initial_coeffs_3930, sizeof(initial_coeffs_3930));
802
    }
803
51
    memset(p->coeffsB, 0, sizeof(p->coeffsB));
804
51
    if (ctx->fileversion < 3930) {
805
41
        memcpy(p->coeffsB[0], initial_coeffs_b_3800,
806
               sizeof(initial_coeffs_b_3800));
807
41
        memcpy(p->coeffsB[1], initial_coeffs_b_3800,
808
               sizeof(initial_coeffs_b_3800));
809
    }
810
811
51
    p->filterA[0] = p->filterA[1] = 0;
812
51
    p->filterB[0] = p->filterB[1] = 0;
813
51
    p->lastA[0]   = p->lastA[1]   = 0;
814
815
51
    p->sample_pos = 0;
816
51
}
817
818
/** Get inverse sign of integer (-1 for positive, 1 for negative and 0 for zero) */
819
15295453
static inline int APESIGN(int32_t x) {
820
15295453
    return (x < 0) - (x > 0);
821
}
822
823
static av_always_inline int filter_fast_3320(APEPredictor *p,
824
                                             const int decoded, const int filter,
825
                                             const int delayA)
826
{
827
    int32_t predictionA;
828
829
    p->buf[delayA] = p->lastA[filter];
830
    if (p->sample_pos < 3) {
831
        p->lastA[filter]   = decoded;
832
        p->filterA[filter] = decoded;
833
        return decoded;
834
    }
835
836
    predictionA = p->buf[delayA] * 2U - p->buf[delayA - 1];
837
    p->lastA[filter] = decoded + ((int32_t)(predictionA  * p->coeffsA[filter][0]) >> 9);
838
839
    if ((decoded ^ predictionA) > 0)
840
        p->coeffsA[filter][0]++;
841
    else
842
        p->coeffsA[filter][0]--;
843
844
    p->filterA[filter] += (unsigned)p->lastA[filter];
845
846
    return p->filterA[filter];
847
}
848
849
2562048
static av_always_inline int filter_3800(APEPredictor *p,
850
                                        const unsigned decoded, const int filter,
851
                                        const int delayA,  const int delayB,
852
                                        const int start,   const int shift)
853
{
854
    int32_t predictionA, predictionB, sign;
855
    int32_t d0, d1, d2, d3, d4;
856
857
2562048
    p->buf[delayA] = p->lastA[filter];
858
2562048
    p->buf[delayB] = p->filterB[filter];
859
2562048
    if (p->sample_pos < start) {
860
4856
        predictionA = decoded + p->filterA[filter];
861
4856
        p->lastA[filter]   = decoded;
862
4856
        p->filterB[filter] = decoded;
863
4856
        p->filterA[filter] = predictionA;
864
4856
        return predictionA;
865
    }
866
2557192
    d2 =  p->buf[delayA];
867
2557192
    d1 = (p->buf[delayA] - p->buf[delayA - 1]) * 2U;
868
2557192
    d0 =  p->buf[delayA] + ((p->buf[delayA - 2] - p->buf[delayA - 1]) * 8U);
869
2557192
    d3 =  p->buf[delayB] * 2U - p->buf[delayB - 1];
870
2557192
    d4 =  p->buf[delayB];
871
872
2557192
    predictionA = d0 * p->coeffsA[filter][0] +
873
2557192
                  d1 * p->coeffsA[filter][1] +
874
2557192
                  d2 * p->coeffsA[filter][2];
875
876
2557192
    sign = APESIGN(decoded);
877
2557192
    p->coeffsA[filter][0] += (((d0 >> 30) & 2) - 1) * sign;
878
2557192
    p->coeffsA[filter][1] += (((d1 >> 28) & 8) - 4) * sign;
879
2557192
    p->coeffsA[filter][2] += (((d2 >> 28) & 8) - 4) * sign;
880
881
2557192
    predictionB = d3 * p->coeffsB[filter][0] -
882
2557192
                  d4 * p->coeffsB[filter][1];
883
2557192
    p->lastA[filter] = decoded + (predictionA >> 11);
884
2557192
    sign = APESIGN(p->lastA[filter]);
885
2557192
    p->coeffsB[filter][0] += (((d3 >> 29) & 4) - 2) * sign;
886
2557192
    p->coeffsB[filter][1] -= (((d4 >> 30) & 2) - 1) * sign;
887
888
2557192
    p->filterB[filter] = p->lastA[filter] + (predictionB >> shift);
889
2557192
    p->filterA[filter] = p->filterB[filter] + (unsigned)((int)(p->filterA[filter] * 31U) >> 5);
890
891
2557192
    return p->filterA[filter];
892
}
893
894
20
static void long_filter_high_3800(int32_t *buffer, int order, int shift, int length)
895
{
896
    int i, j;
897
    int32_t dotprod, sign;
898
    int32_t coeffs[256], delay[256];
899
900
20
    if (order >= length)
901
        return;
902
903
20
    memset(coeffs, 0, order * sizeof(*coeffs));
904
4628
    for (i = 0; i < order; i++)
905
4608
        delay[i] = buffer[i];
906
1469972
    for (i = order; i < length; i++) {
907
1469952
        dotprod = 0;
908
1469952
        sign = APESIGN(buffer[i]);
909
340094464
        for (j = 0; j < order; j++) {
910
338624512
            dotprod += delay[j] * (unsigned)coeffs[j];
911
338624512
            coeffs[j] += ((delay[j] >> 31) | 1) * sign;
912
        }
913
1469952
        buffer[i] -= dotprod >> shift;
914
338624512
        for (j = 0; j < order - 1; j++)
915
337154560
            delay[j] = delay[j + 1];
916
1469952
        delay[order - 1] = buffer[i];
917
    }
918
}
919
920
16
static void long_filter_ehigh_3830(int32_t *buffer, int length)
921
{
922
    int i, j;
923
    int32_t dotprod, sign;
924
16
    int32_t delay[8] = { 0 };
925
16
    uint32_t coeffs[8] = { 0 };
926
927
1175568
    for (i = 0; i < length; i++) {
928
1175552
        dotprod = 0;
929
1175552
        sign = APESIGN(buffer[i]);
930
10579968
        for (j = 7; j >= 0; j--) {
931
9404416
            dotprod += delay[j] * coeffs[j];
932
9404416
            coeffs[j] += ((delay[j] >> 31) | 1) * sign;
933
        }
934
9404416
        for (j = 7; j > 0; j--)
935
8228864
            delay[j] = delay[j - 1];
936
1175552
        delay[0] = buffer[i];
937
1175552
        buffer[i] -= dotprod >> 9;
938
    }
939
16
}
940
941
41
static void predictor_decode_stereo_3800(APEContext *ctx, int count)
942
{
943
41
    APEPredictor *p = &ctx->predictor;
944
41
    int32_t *decoded0 = ctx->decoded[0];
945
41
    int32_t *decoded1 = ctx->decoded[1];
946
41
    int start = 4, shift = 10;
947
948
41
    if (ctx->compression_level == COMPRESSION_LEVEL_HIGH) {
949
        start = 16;
950
        long_filter_high_3800(decoded0, 16, 9, count);
951
        long_filter_high_3800(decoded1, 16, 9, count);
952
41
    } else if (ctx->compression_level == COMPRESSION_LEVEL_EXTRA_HIGH) {
953
10
        int order = 128, shift2 = 11;
954
955
10
        if (ctx->fileversion >= 3830) {
956
8
            order <<= 1;
957
8
            shift++;
958
8
            shift2++;
959
8
            long_filter_ehigh_3830(decoded0 + order, count - order);
960
8
            long_filter_ehigh_3830(decoded1 + order, count - order);
961
        }
962
10
        start = order;
963
10
        long_filter_high_3800(decoded0, order, shift2, count);
964
10
        long_filter_high_3800(decoded1, order, shift2, count);
965
    }
966
967
1281065
    while (count--) {
968
1281024
        int X = *decoded0, Y = *decoded1;
969
1281024
        if (ctx->compression_level == COMPRESSION_LEVEL_FAST) {
970
            *decoded0 = filter_fast_3320(p, Y, 0, YDELAYA);
971
            decoded0++;
972
            *decoded1 = filter_fast_3320(p, X, 1, XDELAYA);
973
            decoded1++;
974
        } else {
975
1281024
            *decoded0 = filter_3800(p, Y, 0, YDELAYA, YDELAYB,
976
                                    start, shift);
977
1281024
            decoded0++;
978
1281024
            *decoded1 = filter_3800(p, X, 1, XDELAYA, XDELAYB,
979
                                    start, shift);
980
1281024
            decoded1++;
981
        }
982
983
        /* Combined */
984
1281024
        p->buf++;
985
1281024
        p->sample_pos++;
986
987
        /* Have we filled the history buffer? */
988
1281024
        if (p->buf == p->historybuffer + HISTORY_SIZE) {
989
2502
            memmove(p->historybuffer, p->buf,
990
                    PREDICTOR_SIZE * sizeof(*p->historybuffer));
991
2502
            p->buf = p->historybuffer;
992
        }
993
    }
994
41
}
995
996
static void predictor_decode_mono_3800(APEContext *ctx, int count)
997
{
998
    APEPredictor *p = &ctx->predictor;
999
    int32_t *decoded0 = ctx->decoded[0];
1000
    int start = 4, shift = 10;
1001
1002
    if (ctx->compression_level == COMPRESSION_LEVEL_HIGH) {
1003
        start = 16;
1004
        long_filter_high_3800(decoded0, 16, 9, count);
1005
    } else if (ctx->compression_level == COMPRESSION_LEVEL_EXTRA_HIGH) {
1006
        int order = 128, shift2 = 11;
1007
1008
        if (ctx->fileversion >= 3830) {
1009
            order <<= 1;
1010
            shift++;
1011
            shift2++;
1012
            long_filter_ehigh_3830(decoded0 + order, count - order);
1013
        }
1014
        start = order;
1015
        long_filter_high_3800(decoded0, order, shift2, count);
1016
    }
1017
1018
    while (count--) {
1019
        if (ctx->compression_level == COMPRESSION_LEVEL_FAST) {
1020
            *decoded0 = filter_fast_3320(p, *decoded0, 0, YDELAYA);
1021
            decoded0++;
1022
        } else {
1023
            *decoded0 = filter_3800(p, *decoded0, 0, YDELAYA, YDELAYB,
1024
                                    start, shift);
1025
            decoded0++;
1026
        }
1027
1028
        /* Combined */
1029
        p->buf++;
1030
        p->sample_pos++;
1031
1032
        /* Have we filled the history buffer? */
1033
        if (p->buf == p->historybuffer + HISTORY_SIZE) {
1034
            memmove(p->historybuffer, p->buf,
1035
                    PREDICTOR_SIZE * sizeof(*p->historybuffer));
1036
            p->buf = p->historybuffer;
1037
        }
1038
    }
1039
}
1040
1041
589824
static av_always_inline int predictor_update_3930(APEPredictor *p,
1042
                                                  const int decoded, const int filter,
1043
                                                  const int delayA)
1044
{
1045
    int32_t predictionA, sign;
1046
    int32_t d0, d1, d2, d3;
1047
1048
589824
    p->buf[delayA]     = p->lastA[filter];
1049
589824
    d0 = p->buf[delayA    ];
1050
589824
    d1 = p->buf[delayA    ] - p->buf[delayA - 1];
1051
589824
    d2 = p->buf[delayA - 1] - p->buf[delayA - 2];
1052
589824
    d3 = p->buf[delayA - 2] - p->buf[delayA - 3];
1053
1054
589824
    predictionA = d0 * p->coeffsA[filter][0] +
1055
589824
                  d1 * p->coeffsA[filter][1] +
1056
589824
                  d2 * p->coeffsA[filter][2] +
1057
589824
                  d3 * p->coeffsA[filter][3];
1058
1059
589824
    p->lastA[filter] = decoded + (predictionA >> 9);
1060
589824
    p->filterA[filter] = p->lastA[filter] + ((int)(p->filterA[filter] * 31U) >> 5);
1061
1062
589824
    sign = APESIGN(decoded);
1063
589824
    p->coeffsA[filter][0] += ((d0 < 0) * 2 - 1) * sign;
1064
589824
    p->coeffsA[filter][1] += ((d1 < 0) * 2 - 1) * sign;
1065
589824
    p->coeffsA[filter][2] += ((d2 < 0) * 2 - 1) * sign;
1066
589824
    p->coeffsA[filter][3] += ((d3 < 0) * 2 - 1) * sign;
1067
1068
589824
    return p->filterA[filter];
1069
}
1070
1071
64
static void predictor_decode_stereo_3930(APEContext *ctx, int count)
1072
{
1073
64
    APEPredictor *p = &ctx->predictor;
1074
64
    int32_t *decoded0 = ctx->decoded[0];
1075
64
    int32_t *decoded1 = ctx->decoded[1];
1076
1077
64
    ape_apply_filters(ctx, ctx->decoded[0], ctx->decoded[1], count);
1078
1079
294976
    while (count--) {
1080
        /* Predictor Y */
1081
294912
        int Y = *decoded1, X = *decoded0;
1082
294912
        *decoded0 = predictor_update_3930(p, Y, 0, YDELAYA);
1083
294912
        decoded0++;
1084
294912
        *decoded1 = predictor_update_3930(p, X, 1, XDELAYA);
1085
294912
        decoded1++;
1086
1087
        /* Combined */
1088
294912
        p->buf++;
1089
1090
        /* Have we filled the history buffer? */
1091
294912
        if (p->buf == p->historybuffer + HISTORY_SIZE) {
1092
576
            memmove(p->historybuffer, p->buf,
1093
                    PREDICTOR_SIZE * sizeof(*p->historybuffer));
1094
576
            p->buf = p->historybuffer;
1095
        }
1096
    }
1097
64
}
1098
1099
static void predictor_decode_mono_3930(APEContext *ctx, int count)
1100
{
1101
    APEPredictor *p = &ctx->predictor;
1102
    int32_t *decoded0 = ctx->decoded[0];
1103
1104
    ape_apply_filters(ctx, ctx->decoded[0], NULL, count);
1105
1106
    while (count--) {
1107
        *decoded0 = predictor_update_3930(p, *decoded0, 0, YDELAYA);
1108
        decoded0++;
1109
1110
        p->buf++;
1111
1112
        /* Have we filled the history buffer? */
1113
        if (p->buf == p->historybuffer + HISTORY_SIZE) {
1114
            memmove(p->historybuffer, p->buf,
1115
                    PREDICTOR_SIZE * sizeof(*p->historybuffer));
1116
            p->buf = p->historybuffer;
1117
        }
1118
    }
1119
}
1120
1121
866304
static av_always_inline int predictor_update_filter(APEPredictor *p,
1122
                                                    const int decoded, const int filter,
1123
                                                    const int delayA,  const int delayB,
1124
                                                    const int adaptA,  const int adaptB)
1125
{
1126
    int32_t predictionA, predictionB, sign;
1127
1128
866304
    p->buf[delayA]     = p->lastA[filter];
1129
866304
    p->buf[adaptA]     = APESIGN(p->buf[delayA]);
1130
866304
    p->buf[delayA - 1] = p->buf[delayA] - (unsigned)p->buf[delayA - 1];
1131
866304
    p->buf[adaptA - 1] = APESIGN(p->buf[delayA - 1]);
1132
1133
866304
    predictionA = p->buf[delayA    ] * p->coeffsA[filter][0] +
1134
866304
                  p->buf[delayA - 1] * p->coeffsA[filter][1] +
1135
866304
                  p->buf[delayA - 2] * p->coeffsA[filter][2] +
1136
866304
                  p->buf[delayA - 3] * p->coeffsA[filter][3];
1137
1138
    /*  Apply a scaled first-order filter compression */
1139
866304
    p->buf[delayB]     = p->filterA[filter ^ 1] - ((int)(p->filterB[filter] * 31U) >> 5);
1140
866304
    p->buf[adaptB]     = APESIGN(p->buf[delayB]);
1141
866304
    p->buf[delayB - 1] = p->buf[delayB] - (unsigned)p->buf[delayB - 1];
1142
866304
    p->buf[adaptB - 1] = APESIGN(p->buf[delayB - 1]);
1143
866304
    p->filterB[filter] = p->filterA[filter ^ 1];
1144
1145
866304
    predictionB = p->buf[delayB    ] * p->coeffsB[filter][0] +
1146
866304
                  p->buf[delayB - 1] * p->coeffsB[filter][1] +
1147
866304
                  p->buf[delayB - 2] * p->coeffsB[filter][2] +
1148
866304
                  p->buf[delayB - 3] * p->coeffsB[filter][3] +
1149
866304
                  p->buf[delayB - 4] * p->coeffsB[filter][4];
1150
1151
866304
    p->lastA[filter] = decoded + ((int)((unsigned)predictionA + (predictionB >> 1)) >> 10);
1152
866304
    p->filterA[filter] = p->lastA[filter] + ((int)(p->filterA[filter] * 31U) >> 5);
1153
1154
866304
    sign = APESIGN(decoded);
1155
866304
    p->coeffsA[filter][0] += p->buf[adaptA    ] * sign;
1156
866304
    p->coeffsA[filter][1] += p->buf[adaptA - 1] * sign;
1157
866304
    p->coeffsA[filter][2] += p->buf[adaptA - 2] * sign;
1158
866304
    p->coeffsA[filter][3] += p->buf[adaptA - 3] * sign;
1159
866304
    p->coeffsB[filter][0] += p->buf[adaptB    ] * sign;
1160
866304
    p->coeffsB[filter][1] += p->buf[adaptB - 1] * sign;
1161
866304
    p->coeffsB[filter][2] += p->buf[adaptB - 2] * sign;
1162
866304
    p->coeffsB[filter][3] += p->buf[adaptB - 3] * sign;
1163
866304
    p->coeffsB[filter][4] += p->buf[adaptB - 4] * sign;
1164
1165
866304
    return p->filterA[filter];
1166
}
1167
1168
94
static void predictor_decode_stereo_3950(APEContext *ctx, int count)
1169
{
1170
94
    APEPredictor *p = &ctx->predictor;
1171
94
    int32_t *decoded0 = ctx->decoded[0];
1172
94
    int32_t *decoded1 = ctx->decoded[1];
1173
1174
94
    ape_apply_filters(ctx, ctx->decoded[0], ctx->decoded[1], count);
1175
1176
433246
    while (count--) {
1177
        /* Predictor Y */
1178
433152
        *decoded0 = predictor_update_filter(p, *decoded0, 0, YDELAYA, YDELAYB,
1179
                                            YADAPTCOEFFSA, YADAPTCOEFFSB);
1180
433152
        decoded0++;
1181
433152
        *decoded1 = predictor_update_filter(p, *decoded1, 1, XDELAYA, XDELAYB,
1182
                                            XADAPTCOEFFSA, XADAPTCOEFFSB);
1183
433152
        decoded1++;
1184
1185
        /* Combined */
1186
433152
        p->buf++;
1187
1188
        /* Have we filled the history buffer? */
1189
433152
        if (p->buf == p->historybuffer + HISTORY_SIZE) {
1190
846
            memmove(p->historybuffer, p->buf,
1191
                    PREDICTOR_SIZE * sizeof(*p->historybuffer));
1192
846
            p->buf = p->historybuffer;
1193
        }
1194
    }
1195
94
}
1196
1197
static void predictor_decode_mono_3950(APEContext *ctx, int count)
1198
{
1199
    APEPredictor *p = &ctx->predictor;
1200
    int32_t *decoded0 = ctx->decoded[0];
1201
    int32_t predictionA, currentA, A, sign;
1202
1203
    ape_apply_filters(ctx, ctx->decoded[0], NULL, count);
1204
1205
    currentA = p->lastA[0];
1206
1207
    while (count--) {
1208
        A = *decoded0;
1209
1210
        p->buf[YDELAYA] = currentA;
1211
        p->buf[YDELAYA - 1] = p->buf[YDELAYA] - p->buf[YDELAYA - 1];
1212
1213
        predictionA = p->buf[YDELAYA    ] * p->coeffsA[0][0] +
1214
                      p->buf[YDELAYA - 1] * p->coeffsA[0][1] +
1215
                      p->buf[YDELAYA - 2] * p->coeffsA[0][2] +
1216
                      p->buf[YDELAYA - 3] * p->coeffsA[0][3];
1217
1218
        currentA = A + (predictionA >> 10);
1219
1220
        p->buf[YADAPTCOEFFSA]     = APESIGN(p->buf[YDELAYA    ]);
1221
        p->buf[YADAPTCOEFFSA - 1] = APESIGN(p->buf[YDELAYA - 1]);
1222
1223
        sign = APESIGN(A);
1224
        p->coeffsA[0][0] += p->buf[YADAPTCOEFFSA    ] * sign;
1225
        p->coeffsA[0][1] += p->buf[YADAPTCOEFFSA - 1] * sign;
1226
        p->coeffsA[0][2] += p->buf[YADAPTCOEFFSA - 2] * sign;
1227
        p->coeffsA[0][3] += p->buf[YADAPTCOEFFSA - 3] * sign;
1228
1229
        p->buf++;
1230
1231
        /* Have we filled the history buffer? */
1232
        if (p->buf == p->historybuffer + HISTORY_SIZE) {
1233
            memmove(p->historybuffer, p->buf,
1234
                    PREDICTOR_SIZE * sizeof(*p->historybuffer));
1235
            p->buf = p->historybuffer;
1236
        }
1237
1238
        p->filterA[0] = currentA + (unsigned)((int)(p->filterA[0] * 31U) >> 5);
1239
        *(decoded0++) = p->filterA[0];
1240
    }
1241
1242
    p->lastA[0] = currentA;
1243
}
1244
1245
126
static void do_init_filter(APEFilter *f, int16_t *buf, int order)
1246
{
1247
126
    f->coeffs = buf;
1248
126
    f->historybuffer = buf + order;
1249
126
    f->delay       = f->historybuffer + order * 2;
1250
126
    f->adaptcoeffs = f->historybuffer + order;
1251
1252
126
    memset(f->historybuffer, 0, (order * 2) * sizeof(*f->historybuffer));
1253
126
    memset(f->coeffs, 0, order * sizeof(*f->coeffs));
1254
126
    f->avg = 0;
1255
126
}
1256
1257
63
static void init_filter(APEContext *ctx, APEFilter *f, int16_t *buf, int order)
1258
{
1259
63
    do_init_filter(&f[0], buf, order);
1260
63
    do_init_filter(&f[1], buf + order * 3 + HISTORY_SIZE, order);
1261
63
}
1262
1263
380
static void do_apply_filter(APEContext *ctx, int version, APEFilter *f,
1264
                            int32_t *data, int count, int order, int fracbits)
1265
{
1266
    int res;
1267
    int absres;
1268
1269
1751420
    while (count--) {
1270
        /* round fixedpoint scalar product */
1271
1751040
        res = ctx->adsp.scalarproduct_and_madd_int16(f->coeffs,
1272
1751040
                                                     f->delay - order,
1273
1751040
                                                     f->adaptcoeffs - order,
1274
                                                     order, APESIGN(*data));
1275
1751040
        res = (int)(res + (1U << (fracbits - 1))) >> fracbits;
1276
1751040
        res += (unsigned)*data;
1277
1751040
        *data++ = res;
1278
1279
        /* Update the output history */
1280
1751040
        *f->delay++ = av_clip_int16(res);
1281
1282
1751040
        if (version < 3980) {
1283
            /* Version ??? to < 3.98 files (untested) */
1284
884736
            f->adaptcoeffs[0]  = (res == 0) ? 0 : ((res >> 28) & 8) - 4;
1285
884736
            f->adaptcoeffs[-4] >>= 1;
1286
884736
            f->adaptcoeffs[-8] >>= 1;
1287
        } else {
1288
            /* Version 3.98 and later files */
1289
1290
            /* Update the adaption coefficients */
1291
866304
            absres = res < 0 ? -(unsigned)res : res;
1292
866304
            if (absres)
1293
863181
                *f->adaptcoeffs = APESIGN(res) *
1294
863181
                                  (8 << ((absres > f->avg * 3) + (absres > f->avg * 4 / 3)));
1295
                /* equivalent to the following code
1296
                    if (absres <= f->avg * 4 / 3)
1297
                        *f->adaptcoeffs = APESIGN(res) * 8;
1298
                    else if (absres <= f->avg * 3)
1299
                        *f->adaptcoeffs = APESIGN(res) * 16;
1300
                    else
1301
                        *f->adaptcoeffs = APESIGN(res) * 32;
1302
                */
1303
            else
1304
3123
                *f->adaptcoeffs = 0;
1305
1306
866304
            f->avg += (int)(absres - (unsigned)f->avg) / 16;
1307
1308
866304
            f->adaptcoeffs[-1] >>= 1;
1309
866304
            f->adaptcoeffs[-2] >>= 1;
1310
866304
            f->adaptcoeffs[-8] >>= 1;
1311
        }
1312
1313
1751040
        f->adaptcoeffs++;
1314
1315
        /* Have we filled the history buffer? */
1316
1751040
        if (f->delay == f->historybuffer + HISTORY_SIZE + (order * 2)) {
1317
3420
            memmove(f->historybuffer, f->delay - (order * 2),
1318
3420
                    (order * 2) * sizeof(*f->historybuffer));
1319
3420
            f->delay = f->historybuffer + order * 2;
1320
3420
            f->adaptcoeffs = f->historybuffer + order;
1321
        }
1322
    }
1323
380
}
1324
1325
190
static void apply_filter(APEContext *ctx, APEFilter *f,
1326
                         int32_t *data0, int32_t *data1,
1327
                         int count, int order, int fracbits)
1328
{
1329
190
    do_apply_filter(ctx, ctx->fileversion, &f[0], data0, count, order, fracbits);
1330
190
    if (data1)
1331
190
        do_apply_filter(ctx, ctx->fileversion, &f[1], data1, count, order, fracbits);
1332
190
}
1333
1334
158
static void ape_apply_filters(APEContext *ctx, int32_t *decoded0,
1335
                              int32_t *decoded1, int count)
1336
{
1337
    int i;
1338
1339
348
    for (i = 0; i < APE_FILTER_LEVELS; i++) {
1340
348
        if (!ape_filter_orders[ctx->fset][i])
1341
158
            break;
1342
190
        apply_filter(ctx, ctx->filters[i], decoded0, decoded1, count,
1343
190
                     ape_filter_orders[ctx->fset][i],
1344
190
                     ape_filter_fracbits[ctx->fset][i]);
1345
    }
1346
158
}
1347
1348
51
static int init_frame_decoder(APEContext *ctx)
1349
{
1350
    int i, ret;
1351
51
    if ((ret = init_entropy_decoder(ctx)) < 0)
1352
        return ret;
1353
51
    init_predictor_decoder(ctx);
1354
1355
114
    for (i = 0; i < APE_FILTER_LEVELS; i++) {
1356
114
        if (!ape_filter_orders[ctx->fset][i])
1357
51
            break;
1358
63
        init_filter(ctx, ctx->filters[i], ctx->filterbuf[i],
1359
63
                    ape_filter_orders[ctx->fset][i]);
1360
    }
1361
51
    return 0;
1362
}
1363
1364
static void ape_unpack_mono(APEContext *ctx, int count)
1365
{
1366
    if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {
1367
        /* We are pure silence, so we're done. */
1368
        av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence mono\n");
1369
        return;
1370
    }
1371
1372
    ctx->entropy_decode_mono(ctx, count);
1373
    if (ctx->error)
1374
        return;
1375
1376
    /* Now apply the predictor decoding */
1377
    ctx->predictor_decode_mono(ctx, count);
1378
1379
    /* Pseudo-stereo - just copy left channel to right channel */
1380
    if (ctx->channels == 2) {
1381
        memcpy(ctx->decoded[1], ctx->decoded[0], count * sizeof(*ctx->decoded[1]));
1382
    }
1383
}
1384
1385
200
static void ape_unpack_stereo(APEContext *ctx, int count)
1386
{
1387
    unsigned left, right;
1388
200
    int32_t *decoded0 = ctx->decoded[0];
1389
200
    int32_t *decoded1 = ctx->decoded[1];
1390
1391
200
    if ((ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) == APE_FRAMECODE_STEREO_SILENCE) {
1392
        /* We are pure silence, so we're done. */
1393
        av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence stereo\n");
1394
        return;
1395
    }
1396
1397
200
    ctx->entropy_decode_stereo(ctx, count);
1398
200
    if (ctx->error)
1399
1
        return;
1400
1401
    /* Now apply the predictor decoding */
1402
199
    ctx->predictor_decode_stereo(ctx, count);
1403
1404
    /* Decorrelate and scale to output depth */
1405
2009287
    while (count--) {
1406
2009088
        left = *decoded1 - (unsigned)(*decoded0 / 2);
1407
2009088
        right = left + *decoded0;
1408
1409
2009088
        *(decoded0++) = left;
1410
2009088
        *(decoded1++) = right;
1411
    }
1412
}
1413
1414
213
static int ape_decode_frame(AVCodecContext *avctx, void *data,
1415
                            int *got_frame_ptr, AVPacket *avpkt)
1416
{
1417
213
    AVFrame *frame     = data;
1418
213
    const uint8_t *buf = avpkt->data;
1419
213
    APEContext *s = avctx->priv_data;
1420
    uint8_t *sample8;
1421
    int16_t *sample16;
1422
    int32_t *sample24;
1423
    int i, ch, ret;
1424
    int blockstodecode;
1425
    uint64_t decoded_buffer_size;
1426
1427
    /* this should never be negative, but bad things will happen if it is, so
1428
       check it just to make sure. */
1429
213
    av_assert0(s->samples >= 0);
1430
1431
213
    if(!s->samples){
1432
        uint32_t nblocks, offset;
1433
        int buf_size;
1434
1435
64
        if (!avpkt->size) {
1436
13
            *got_frame_ptr = 0;
1437
13
            return 0;
1438
        }
1439
51
        if (avpkt->size < 8) {
1440
            av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
1441
            return AVERROR_INVALIDDATA;
1442
        }
1443
51
        buf_size = avpkt->size & ~3;
1444
51
        if (buf_size != avpkt->size) {
1445
            av_log(avctx, AV_LOG_WARNING, "packet size is not a multiple of 4. "
1446
                   "extra bytes at the end will be skipped.\n");
1447
        }
1448
51
        if (s->fileversion < 3950) // previous versions overread two bytes
1449
45
            buf_size += 2;
1450
51
        av_fast_padded_malloc(&s->data, &s->data_size, buf_size);
1451
51
        if (!s->data)
1452
            return AVERROR(ENOMEM);
1453
51
        s->bdsp.bswap_buf((uint32_t *) s->data, (const uint32_t *) buf,
1454
                          buf_size >> 2);
1455
51
        memset(s->data + (buf_size & ~3), 0, buf_size & 3);
1456
51
        s->ptr = s->data;
1457
51
        s->data_end = s->data + buf_size;
1458
1459
51
        nblocks = bytestream_get_be32(&s->ptr);
1460
51
        offset  = bytestream_get_be32(&s->ptr);
1461
51
        if (s->fileversion >= 3900) {
1462
18
            if (offset > 3) {
1463
                av_log(avctx, AV_LOG_ERROR, "Incorrect offset passed\n");
1464
                av_freep(&s->data);
1465
                s->data_size = 0;
1466
                return AVERROR_INVALIDDATA;
1467
            }
1468
18
            if (s->data_end - s->ptr < offset) {
1469
                av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
1470
                return AVERROR_INVALIDDATA;
1471
            }
1472
18
            s->ptr += offset;
1473
        } else {
1474
33
            if ((ret = init_get_bits8(&s->gb, s->ptr, s->data_end - s->ptr)) < 0)
1475
                return ret;
1476
33
            if (s->fileversion > 3800)
1477
22
                skip_bits_long(&s->gb, offset * 8);
1478
            else
1479
11
                skip_bits_long(&s->gb, offset);
1480
        }
1481
1482

51
        if (!nblocks || nblocks > INT_MAX / 2 / sizeof(*s->decoded_buffer) - 8) {
1483
            av_log(avctx, AV_LOG_ERROR, "Invalid sample count: %"PRIu32".\n",
1484
                   nblocks);
1485
            return AVERROR_INVALIDDATA;
1486
        }
1487
1488
        /* Initialize the frame decoder */
1489
51
        if (init_frame_decoder(s) < 0) {
1490
            av_log(avctx, AV_LOG_ERROR, "Error reading frame header\n");
1491
            return AVERROR_INVALIDDATA;
1492
        }
1493
51
        s->samples = nblocks;
1494
    }
1495
1496
200
    if (!s->data) {
1497
        *got_frame_ptr = 0;
1498
        return avpkt->size;
1499
    }
1500
1501
200
    blockstodecode = FFMIN(s->blocks_per_loop, s->samples);
1502
    // for old files coefficients were not interleaved,
1503
    // so we need to decode all of them at once
1504
200
    if (s->fileversion < 3930)
1505
41
        blockstodecode = s->samples;
1506
1507
    /* reallocate decoded sample buffer if needed */
1508
200
    decoded_buffer_size = 2LL * FFALIGN(blockstodecode, 8) * sizeof(*s->decoded_buffer);
1509
200
    av_assert0(decoded_buffer_size <= INT_MAX);
1510
1511
    /* get output buffer */
1512
200
    frame->nb_samples = blockstodecode;
1513
200
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1514
        s->samples=0;
1515
        return ret;
1516
    }
1517
1518
200
    av_fast_malloc(&s->decoded_buffer, &s->decoded_size, decoded_buffer_size);
1519
200
    if (!s->decoded_buffer)
1520
        return AVERROR(ENOMEM);
1521
200
    memset(s->decoded_buffer, 0, decoded_buffer_size);
1522
200
    s->decoded[0] = s->decoded_buffer;
1523
200
    s->decoded[1] = s->decoded_buffer + FFALIGN(blockstodecode, 8);
1524
1525
200
    s->error=0;
1526
1527

200
    if ((s->channels == 1) || (s->frameflags & APE_FRAMECODE_PSEUDO_STEREO))
1528
        ape_unpack_mono(s, blockstodecode);
1529
    else
1530
200
        ape_unpack_stereo(s, blockstodecode);
1531
200
    emms_c();
1532
1533
200
    if (s->error) {
1534
1
        s->samples=0;
1535
1
        av_log(avctx, AV_LOG_ERROR, "Error decoding frame\n");
1536
1
        return AVERROR_INVALIDDATA;
1537
    }
1538
1539

199
    switch (s->bps) {
1540
    case 8:
1541
        for (ch = 0; ch < s->channels; ch++) {
1542
            sample8 = (uint8_t *)frame->data[ch];
1543
            for (i = 0; i < blockstodecode; i++)
1544
                *sample8++ = (s->decoded[ch][i] + 0x80) & 0xff;
1545
        }
1546
        break;
1547
199
    case 16:
1548
597
        for (ch = 0; ch < s->channels; ch++) {
1549
398
            sample16 = (int16_t *)frame->data[ch];
1550
4018574
            for (i = 0; i < blockstodecode; i++)
1551
4018176
                *sample16++ = s->decoded[ch][i];
1552
        }
1553
199
        break;
1554
    case 24:
1555
        for (ch = 0; ch < s->channels; ch++) {
1556
            sample24 = (int32_t *)frame->data[ch];
1557
            for (i = 0; i < blockstodecode; i++)
1558
                *sample24++ = s->decoded[ch][i] << 8;
1559
        }
1560
        break;
1561
    }
1562
1563
199
    s->samples -= blockstodecode;
1564
1565
199
    *got_frame_ptr = 1;
1566
1567
199
    return !s->samples ? avpkt->size : 0;
1568
}
1569
1570
static void ape_flush(AVCodecContext *avctx)
1571
{
1572
    APEContext *s = avctx->priv_data;
1573
    s->samples= 0;
1574
}
1575
1576
#define OFFSET(x) offsetof(APEContext, x)
1577
#define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1578
static const AVOption options[] = {
1579
    { "max_samples", "maximum number of samples decoded per call",             OFFSET(blocks_per_loop), AV_OPT_TYPE_INT,   { .i64 = 4608 },    1,       INT_MAX, PAR, "max_samples" },
1580
    { "all",         "no maximum. decode all samples for each packet at once", 0,                       AV_OPT_TYPE_CONST, { .i64 = INT_MAX }, INT_MIN, INT_MAX, PAR, "max_samples" },
1581
    { NULL},
1582
};
1583
1584
static const AVClass ape_decoder_class = {
1585
    .class_name = "APE decoder",
1586
    .item_name  = av_default_item_name,
1587
    .option     = options,
1588
    .version    = LIBAVUTIL_VERSION_INT,
1589
};
1590
1591
AVCodec ff_ape_decoder = {
1592
    .name           = "ape",
1593
    .long_name      = NULL_IF_CONFIG_SMALL("Monkey's Audio"),
1594
    .type           = AVMEDIA_TYPE_AUDIO,
1595
    .id             = AV_CODEC_ID_APE,
1596
    .priv_data_size = sizeof(APEContext),
1597
    .init           = ape_decode_init,
1598
    .close          = ape_decode_close,
1599
    .decode         = ape_decode_frame,
1600
    .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DELAY |
1601
                      AV_CODEC_CAP_DR1,
1602
    .flush          = ape_flush,
1603
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
1604
                                                      AV_SAMPLE_FMT_S16P,
1605
                                                      AV_SAMPLE_FMT_S32P,
1606
                                                      AV_SAMPLE_FMT_NONE },
1607
    .priv_class     = &ape_decoder_class,
1608
};