GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/apedec.c Lines: 580 797 72.8 %
Date: 2020-11-28 20:53:16 Branches: 206 336 61.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/crc.h"
28
#include "libavutil/opt.h"
29
#include "lossless_audiodsp.h"
30
#include "avcodec.h"
31
#include "bswapdsp.h"
32
#include "bytestream.h"
33
#include "internal.h"
34
#include "get_bits.h"
35
#include "unary.h"
36
37
/**
38
 * @file
39
 * Monkey's Audio lossless audio decoder
40
 */
41
42
#define MAX_CHANNELS        2
43
#define MAX_BYTESPERSAMPLE  3
44
45
#define APE_FRAMECODE_MONO_SILENCE    1
46
#define APE_FRAMECODE_STEREO_SILENCE  3
47
#define APE_FRAMECODE_PSEUDO_STEREO   4
48
49
#define HISTORY_SIZE 512
50
#define PREDICTOR_ORDER 8
51
/** Total size of all predictor histories */
52
#define PREDICTOR_SIZE 50
53
54
#define YDELAYA (18 + PREDICTOR_ORDER*4)
55
#define YDELAYB (18 + PREDICTOR_ORDER*3)
56
#define XDELAYA (18 + PREDICTOR_ORDER*2)
57
#define XDELAYB (18 + PREDICTOR_ORDER)
58
59
#define YADAPTCOEFFSA 18
60
#define XADAPTCOEFFSA 14
61
#define YADAPTCOEFFSB 10
62
#define XADAPTCOEFFSB 5
63
64
/**
65
 * Possible compression levels
66
 * @{
67
 */
68
enum APECompressionLevel {
69
    COMPRESSION_LEVEL_FAST       = 1000,
70
    COMPRESSION_LEVEL_NORMAL     = 2000,
71
    COMPRESSION_LEVEL_HIGH       = 3000,
72
    COMPRESSION_LEVEL_EXTRA_HIGH = 4000,
73
    COMPRESSION_LEVEL_INSANE     = 5000
74
};
75
/** @} */
76
77
#define APE_FILTER_LEVELS 3
78
79
/** Filter orders depending on compression level */
80
static const uint16_t ape_filter_orders[5][APE_FILTER_LEVELS] = {
81
    {  0,   0,    0 },
82
    { 16,   0,    0 },
83
    { 64,   0,    0 },
84
    { 32, 256,    0 },
85
    { 16, 256, 1280 }
86
};
87
88
/** Filter fraction bits depending on compression level */
89
static const uint8_t ape_filter_fracbits[5][APE_FILTER_LEVELS] = {
90
    {  0,  0,  0 },
91
    { 11,  0,  0 },
92
    { 11,  0,  0 },
93
    { 10, 13,  0 },
94
    { 11, 13, 15 }
95
};
96
97
98
/** Filters applied to the decoded data */
99
typedef struct APEFilter {
100
    int16_t *coeffs;        ///< actual coefficients used in filtering
101
    int16_t *adaptcoeffs;   ///< adaptive filter coefficients used for correcting of actual filter coefficients
102
    int16_t *historybuffer; ///< filter memory
103
    int16_t *delay;         ///< filtered values
104
105
    int avg;
106
} APEFilter;
107
108
typedef struct APERice {
109
    uint32_t k;
110
    uint32_t ksum;
111
} APERice;
112
113
typedef struct APERangecoder {
114
    uint32_t low;           ///< low end of interval
115
    uint32_t range;         ///< length of interval
116
    uint32_t help;          ///< bytes_to_follow resp. intermediate value
117
    unsigned int buffer;    ///< buffer for input/output
118
} APERangecoder;
119
120
/** Filter histories */
121
typedef struct APEPredictor {
122
    int32_t *buf;
123
124
    int32_t lastA[2];
125
126
    int32_t filterA[2];
127
    int32_t filterB[2];
128
129
    uint32_t coeffsA[2][4];  ///< adaption coefficients
130
    uint32_t coeffsB[2][5];  ///< adaption coefficients
131
    int32_t historybuffer[HISTORY_SIZE + PREDICTOR_SIZE];
132
133
    unsigned int sample_pos;
134
} APEPredictor;
135
136
typedef struct APEPredictor64 {
137
    int64_t *buf;
138
139
    int64_t lastA[2];
140
141
    int64_t filterA[2];
142
    int64_t filterB[2];
143
144
    uint64_t coeffsA[2][4];  ///< adaption coefficients
145
    uint64_t coeffsB[2][5];  ///< adaption coefficients
146
    int64_t historybuffer[HISTORY_SIZE + PREDICTOR_SIZE];
147
148
    unsigned int sample_pos;
149
} APEPredictor64;
150
151
/** Decoder context */
152
typedef struct APEContext {
153
    AVClass *class;                          ///< class for AVOptions
154
    AVCodecContext *avctx;
155
    BswapDSPContext bdsp;
156
    LLAudDSPContext adsp;
157
    int channels;
158
    int samples;                             ///< samples left to decode in current frame
159
    int bps;
160
161
    int fileversion;                         ///< codec version, very important in decoding process
162
    int compression_level;                   ///< compression levels
163
    int fset;                                ///< which filter set to use (calculated from compression level)
164
    int flags;                               ///< global decoder flags
165
166
    uint32_t CRC;                            ///< signalled frame CRC
167
    uint32_t CRC_state;                      ///< accumulated CRC
168
    int frameflags;                          ///< frame flags
169
    APEPredictor predictor;                  ///< predictor used for final reconstruction
170
    APEPredictor64 predictor64;              ///< 64bit predictor used for final reconstruction
171
172
    int32_t *decoded_buffer;
173
    int decoded_size;
174
    int32_t *decoded[MAX_CHANNELS];          ///< decoded data for each channel
175
    int blocks_per_loop;                     ///< maximum number of samples to decode for each call
176
177
    int16_t* filterbuf[APE_FILTER_LEVELS];   ///< filter memory
178
179
    APERangecoder rc;                        ///< rangecoder used to decode actual values
180
    APERice riceX;                           ///< rice code parameters for the second channel
181
    APERice riceY;                           ///< rice code parameters for the first channel
182
    APEFilter filters[APE_FILTER_LEVELS][2]; ///< filters used for reconstruction
183
    GetBitContext gb;
184
185
    uint8_t *data;                           ///< current frame data
186
    uint8_t *data_end;                       ///< frame data end
187
    int data_size;                           ///< frame data allocated size
188
    const uint8_t *ptr;                      ///< current position in frame data
189
190
    int error;
191
192
    void (*entropy_decode_mono)(struct APEContext *ctx, int blockstodecode);
193
    void (*entropy_decode_stereo)(struct APEContext *ctx, int blockstodecode);
194
    void (*predictor_decode_mono)(struct APEContext *ctx, int count);
195
    void (*predictor_decode_stereo)(struct APEContext *ctx, int count);
196
} APEContext;
197
198
static void ape_apply_filters(APEContext *ctx, int32_t *decoded0,
199
                              int32_t *decoded1, int count);
200
201
static void entropy_decode_mono_0000(APEContext *ctx, int blockstodecode);
202
static void entropy_decode_stereo_0000(APEContext *ctx, int blockstodecode);
203
static void entropy_decode_mono_3860(APEContext *ctx, int blockstodecode);
204
static void entropy_decode_stereo_3860(APEContext *ctx, int blockstodecode);
205
static void entropy_decode_mono_3900(APEContext *ctx, int blockstodecode);
206
static void entropy_decode_stereo_3900(APEContext *ctx, int blockstodecode);
207
static void entropy_decode_stereo_3930(APEContext *ctx, int blockstodecode);
208
static void entropy_decode_mono_3990(APEContext *ctx, int blockstodecode);
209
static void entropy_decode_stereo_3990(APEContext *ctx, int blockstodecode);
210
211
static void predictor_decode_mono_3800(APEContext *ctx, int count);
212
static void predictor_decode_stereo_3800(APEContext *ctx, int count);
213
static void predictor_decode_mono_3930(APEContext *ctx, int count);
214
static void predictor_decode_stereo_3930(APEContext *ctx, int count);
215
static void predictor_decode_mono_3950(APEContext *ctx, int count);
216
static void predictor_decode_stereo_3950(APEContext *ctx, int count);
217
218
27
static av_cold int ape_decode_close(AVCodecContext *avctx)
219
{
220
27
    APEContext *s = avctx->priv_data;
221
    int i;
222
223
108
    for (i = 0; i < APE_FILTER_LEVELS; i++)
224
81
        av_freep(&s->filterbuf[i]);
225
226
27
    av_freep(&s->decoded_buffer);
227
27
    av_freep(&s->data);
228
27
    s->decoded_size = s->data_size = 0;
229
230
27
    return 0;
231
}
232
233
27
static av_cold int ape_decode_init(AVCodecContext *avctx)
234
{
235
27
    APEContext *s = avctx->priv_data;
236
    int i;
237
238
27
    if (avctx->extradata_size != 6) {
239
        av_log(avctx, AV_LOG_ERROR, "Incorrect extradata\n");
240
        return AVERROR(EINVAL);
241
    }
242
27
    if (avctx->channels > 2) {
243
        av_log(avctx, AV_LOG_ERROR, "Only mono and stereo is supported\n");
244
        return AVERROR(EINVAL);
245
    }
246
27
    s->bps = avctx->bits_per_coded_sample;
247

27
    switch (s->bps) {
248
    case 8:
249
        avctx->sample_fmt = AV_SAMPLE_FMT_U8P;
250
        break;
251
27
    case 16:
252
27
        avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
253
27
        break;
254
    case 24:
255
        avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
256
        break;
257
    default:
258
        avpriv_request_sample(avctx,
259
                              "%d bits per coded sample", s->bps);
260
        return AVERROR_PATCHWELCOME;
261
    }
262
27
    s->avctx             = avctx;
263
27
    s->channels          = avctx->channels;
264
27
    s->fileversion       = AV_RL16(avctx->extradata);
265
27
    s->compression_level = AV_RL16(avctx->extradata + 2);
266
27
    s->flags             = AV_RL16(avctx->extradata + 4);
267
268
27
    av_log(avctx, AV_LOG_VERBOSE, "Compression Level: %d - Flags: %d\n",
269
           s->compression_level, s->flags);
270

27
    if (s->compression_level % 1000 || s->compression_level > COMPRESSION_LEVEL_INSANE ||
271
27
        !s->compression_level ||
272

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

2612067
    else if (rice->ksum >= (1 << (rice->k + 5)) && rice->k < 24)
478
32829
        rice->k++;
479
2644992
}
480
481
460800
static inline int get_rice_ook(GetBitContext *gb, int k)
482
{
483
    unsigned int x;
484
485
460800
    x = get_unary(gb, 1, get_bits_left(gb));
486
487
460800
    if (k)
488
460800
        x = (x << k) | get_bits(gb, k);
489
490
460800
    return x;
491
}
492
493
921600
static inline int ape_decode_value_3860(APEContext *ctx, GetBitContext *gb,
494
                                        APERice *rice)
495
{
496
    unsigned int x, overflow;
497
498
921600
    overflow = get_unary(gb, 1, get_bits_left(gb));
499
500
921600
    if (ctx->fileversion > 3880) {
501
460801
        while (overflow >= 16) {
502
1
            overflow -= 16;
503
1
            rice->k  += 4;
504
        }
505
    }
506
507
921600
    if (!rice->k)
508
        x = overflow;
509
921600
    else if(rice->k <= MIN_CACHE_BITS) {
510
921600
        x = (overflow << rice->k) + get_bits(gb, rice->k);
511
    } else {
512
        av_log(ctx->avctx, AV_LOG_ERROR, "Too many bits: %"PRIu32"\n", rice->k);
513
        ctx->error = 1;
514
        return AVERROR_INVALIDDATA;
515
    }
516
921600
    rice->ksum += x - (rice->ksum + 8 >> 4);
517

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

898151
    else if (rice->ksum >= (1 << (rice->k + 5)) && rice->k < 24)
520
23287
        rice->k++;
521
522
    /* Convert to signed */
523
921600
    return ((x >> 1) ^ ((x & 1) - 1)) + 1;
524
}
525
526
1769472
static inline int ape_decode_value_3900(APEContext *ctx, APERice *rice)
527
{
528
    unsigned int x, overflow;
529
    int tmpk;
530
531
1769472
    overflow = range_get_symbol(ctx, counts_3970, counts_diff_3970);
532
533
1769472
    if (overflow == (MODEL_ELEMENTS - 1)) {
534
        tmpk = range_decode_bits(ctx, 5);
535
        overflow = 0;
536
    } else
537
1769472
        tmpk = (rice->k < 1) ? 0 : rice->k - 1;
538
539

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

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

51
        if (!nblocks || nblocks > INT_MAX / 2 / sizeof(*s->decoded_buffer) - 8) {
1528
            av_log(avctx, AV_LOG_ERROR, "Invalid sample count: %"PRIu32".\n",
1529
                   nblocks);
1530
            return AVERROR_INVALIDDATA;
1531
        }
1532
1533
        /* Initialize the frame decoder */
1534
51
        if (init_frame_decoder(s) < 0) {
1535
            av_log(avctx, AV_LOG_ERROR, "Error reading frame header\n");
1536
            return AVERROR_INVALIDDATA;
1537
        }
1538
51
        s->samples = nblocks;
1539
    }
1540
1541
200
    if (!s->data) {
1542
        *got_frame_ptr = 0;
1543
        return avpkt->size;
1544
    }
1545
1546
200
    blockstodecode = FFMIN(s->blocks_per_loop, s->samples);
1547
    // for old files coefficients were not interleaved,
1548
    // so we need to decode all of them at once
1549
200
    if (s->fileversion < 3930)
1550
41
        blockstodecode = s->samples;
1551
1552
    /* reallocate decoded sample buffer if needed */
1553
200
    decoded_buffer_size = 2LL * FFALIGN(blockstodecode, 8) * sizeof(*s->decoded_buffer);
1554
200
    av_assert0(decoded_buffer_size <= INT_MAX);
1555
1556
    /* get output buffer */
1557
200
    frame->nb_samples = blockstodecode;
1558
200
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
1559
        s->samples=0;
1560
        return ret;
1561
    }
1562
1563
200
    av_fast_malloc(&s->decoded_buffer, &s->decoded_size, decoded_buffer_size);
1564
200
    if (!s->decoded_buffer)
1565
        return AVERROR(ENOMEM);
1566
200
    memset(s->decoded_buffer, 0, decoded_buffer_size);
1567
200
    s->decoded[0] = s->decoded_buffer;
1568
200
    s->decoded[1] = s->decoded_buffer + FFALIGN(blockstodecode, 8);
1569
1570
200
    s->error=0;
1571
1572

200
    if ((s->channels == 1) || (s->frameflags & APE_FRAMECODE_PSEUDO_STEREO))
1573
        ape_unpack_mono(s, blockstodecode);
1574
    else
1575
200
        ape_unpack_stereo(s, blockstodecode);
1576
200
    emms_c();
1577
1578
200
    if (s->error) {
1579
1
        s->samples=0;
1580
1
        av_log(avctx, AV_LOG_ERROR, "Error decoding frame\n");
1581
1
        return AVERROR_INVALIDDATA;
1582
    }
1583
1584

199
    switch (s->bps) {
1585
    case 8:
1586
        for (ch = 0; ch < s->channels; ch++) {
1587
            sample8 = (uint8_t *)frame->data[ch];
1588
            for (i = 0; i < blockstodecode; i++)
1589
                *sample8++ = (s->decoded[ch][i] + 0x80) & 0xff;
1590
        }
1591
        break;
1592
199
    case 16:
1593
597
        for (ch = 0; ch < s->channels; ch++) {
1594
398
            sample16 = (int16_t *)frame->data[ch];
1595
4018574
            for (i = 0; i < blockstodecode; i++)
1596
4018176
                *sample16++ = s->decoded[ch][i];
1597
        }
1598
199
        break;
1599
    case 24:
1600
        for (ch = 0; ch < s->channels; ch++) {
1601
            sample24 = (int32_t *)frame->data[ch];
1602
            for (i = 0; i < blockstodecode; i++)
1603
                *sample24++ = s->decoded[ch][i] * 256U;
1604
        }
1605
        break;
1606
    }
1607
1608
199
    s->samples -= blockstodecode;
1609
1610
199
    if (avctx->err_recognition & AV_EF_CRCCHECK &&
1611
        s->fileversion >= 3900 && s->bps < 24) {
1612
        uint32_t crc = s->CRC_state;
1613
        const AVCRC *crc_tab = av_crc_get_table(AV_CRC_32_IEEE_LE);
1614
        for (i = 0; i < blockstodecode; i++) {
1615
            for (ch = 0; ch < s->channels; ch++) {
1616
                uint8_t *smp = frame->data[ch] + (i*(s->bps >> 3));
1617
                crc = av_crc(crc_tab, crc, smp, s->bps >> 3);
1618
            }
1619
        }
1620
1621
        if (!s->samples && (~crc >> 1) ^ s->CRC) {
1622
            av_log(avctx, AV_LOG_ERROR, "CRC mismatch! Previously decoded "
1623
                   "frames may have been affected as well.\n");
1624
            if (avctx->err_recognition & AV_EF_EXPLODE)
1625
                return AVERROR_INVALIDDATA;
1626
        }
1627
1628
        s->CRC_state = crc;
1629
    }
1630
1631
199
    *got_frame_ptr = 1;
1632
1633
199
    return !s->samples ? avpkt->size : 0;
1634
}
1635
1636
static void ape_flush(AVCodecContext *avctx)
1637
{
1638
    APEContext *s = avctx->priv_data;
1639
    s->samples= 0;
1640
}
1641
1642
#define OFFSET(x) offsetof(APEContext, x)
1643
#define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1644
static const AVOption options[] = {
1645
    { "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" },
1646
    { "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" },
1647
    { NULL},
1648
};
1649
1650
static const AVClass ape_decoder_class = {
1651
    .class_name = "APE decoder",
1652
    .item_name  = av_default_item_name,
1653
    .option     = options,
1654
    .version    = LIBAVUTIL_VERSION_INT,
1655
};
1656
1657
AVCodec ff_ape_decoder = {
1658
    .name           = "ape",
1659
    .long_name      = NULL_IF_CONFIG_SMALL("Monkey's Audio"),
1660
    .type           = AVMEDIA_TYPE_AUDIO,
1661
    .id             = AV_CODEC_ID_APE,
1662
    .priv_data_size = sizeof(APEContext),
1663
    .init           = ape_decode_init,
1664
    .close          = ape_decode_close,
1665
    .decode         = ape_decode_frame,
1666
    .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DELAY |
1667
                      AV_CODEC_CAP_DR1,
1668
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
1669
    .flush          = ape_flush,
1670
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
1671
                                                      AV_SAMPLE_FMT_S16P,
1672
                                                      AV_SAMPLE_FMT_S32P,
1673
                                                      AV_SAMPLE_FMT_NONE },
1674
    .priv_class     = &ape_decoder_class,
1675
};