GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/apedec.c Lines: 581 798 72.8 %
Date: 2021-04-20 04:37:23 Branches: 208 338 61.5 %

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
    avctx->bits_per_raw_sample =
247
27
    s->bps = avctx->bits_per_coded_sample;
248

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

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

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

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

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

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

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

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

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

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

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