← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/apedec.c

  • Committer: Bazaar Package Importer
  • Author(s): Lionel Le Folgoc
  • Date: 2008-12-26 00:10:06 UTC
  • mto: This revision was merged to the branch mainline in revision 8.
  • Revision ID: james.westby@ubuntu.com-20081226001006-wd8cuqn8d81smkdp
Tags: upstream-1.1.7
Import upstream version 1.1.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/apedec.c
 
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
#define ALT_BITSTREAM_READER_LE
 
24
#include "avcodec.h"
 
25
#include "dsputil.h"
 
26
#include "bitstream.h"
 
27
#include "bytestream.h"
 
28
 
 
29
/**
 
30
 * @file apedec.c
 
31
 * Monkey's Audio lossless audio decoder
 
32
 */
 
33
 
 
34
#define BLOCKS_PER_LOOP     4608
 
35
#define MAX_CHANNELS        2
 
36
#define MAX_BYTESPERSAMPLE  3
 
37
 
 
38
#define APE_FRAMECODE_MONO_SILENCE    1
 
39
#define APE_FRAMECODE_STEREO_SILENCE  3
 
40
#define APE_FRAMECODE_PSEUDO_STEREO   4
 
41
 
 
42
#define HISTORY_SIZE 512
 
43
#define PREDICTOR_ORDER 8
 
44
/** Total size of all predictor histories */
 
45
#define PREDICTOR_SIZE 50
 
46
 
 
47
#define YDELAYA (18 + PREDICTOR_ORDER*4)
 
48
#define YDELAYB (18 + PREDICTOR_ORDER*3)
 
49
#define XDELAYA (18 + PREDICTOR_ORDER*2)
 
50
#define XDELAYB (18 + PREDICTOR_ORDER)
 
51
 
 
52
#define YADAPTCOEFFSA 18
 
53
#define XADAPTCOEFFSA 14
 
54
#define YADAPTCOEFFSB 10
 
55
#define XADAPTCOEFFSB 5
 
56
 
 
57
/**
 
58
 * Possible compression levels
 
59
 * @{
 
60
 */
 
61
enum APECompressionLevel {
 
62
    COMPRESSION_LEVEL_FAST       = 1000,
 
63
    COMPRESSION_LEVEL_NORMAL     = 2000,
 
64
    COMPRESSION_LEVEL_HIGH       = 3000,
 
65
    COMPRESSION_LEVEL_EXTRA_HIGH = 4000,
 
66
    COMPRESSION_LEVEL_INSANE     = 5000
 
67
};
 
68
/** @} */
 
69
 
 
70
#define APE_FILTER_LEVELS 3
 
71
 
 
72
/** Filter orders depending on compression level */
 
73
static const uint16_t ape_filter_orders[5][APE_FILTER_LEVELS] = {
 
74
    {  0,   0,    0 },
 
75
    { 16,   0,    0 },
 
76
    { 64,   0,    0 },
 
77
    { 32, 256,    0 },
 
78
    { 16, 256, 1280 }
 
79
};
 
80
 
 
81
/** Filter fraction bits depending on compression level */
 
82
static const uint8_t ape_filter_fracbits[5][APE_FILTER_LEVELS] = {
 
83
    {  0,  0,  0 },
 
84
    { 11,  0,  0 },
 
85
    { 11,  0,  0 },
 
86
    { 10, 13,  0 },
 
87
    { 11, 13, 15 }
 
88
};
 
89
 
 
90
 
 
91
/** Filters applied to the decoded data */
 
92
typedef struct APEFilter {
 
93
    int16_t *coeffs;        ///< actual coefficients used in filtering
 
94
    int16_t *adaptcoeffs;   ///< adaptive filter coefficients used for correcting of actual filter coefficients
 
95
    int16_t *historybuffer; ///< filter memory
 
96
    int16_t *delay;         ///< filtered values
 
97
 
 
98
    int avg;
 
99
} APEFilter;
 
100
 
 
101
typedef struct APERice {
 
102
    uint32_t k;
 
103
    uint32_t ksum;
 
104
} APERice;
 
105
 
 
106
typedef struct APERangecoder {
 
107
    uint32_t low;           ///< low end of interval
 
108
    uint32_t range;         ///< length of interval
 
109
    uint32_t help;          ///< bytes_to_follow resp. intermediate value
 
110
    unsigned int buffer;    ///< buffer for input/output
 
111
} APERangecoder;
 
112
 
 
113
/** Filter histories */
 
114
typedef struct APEPredictor {
 
115
    int32_t *buf;
 
116
 
 
117
    int32_t lastA[2];
 
118
 
 
119
    int32_t filterA[2];
 
120
    int32_t filterB[2];
 
121
 
 
122
    int32_t coeffsA[2][4];  ///< adaption coefficients
 
123
    int32_t coeffsB[2][5];  ///< adaption coefficients
 
124
    int32_t historybuffer[HISTORY_SIZE + PREDICTOR_SIZE];
 
125
} APEPredictor;
 
126
 
 
127
/** Decoder context */
 
128
typedef struct APEContext {
 
129
    AVCodecContext *avctx;
 
130
    DSPContext dsp;
 
131
    int channels;
 
132
    int samples;                             ///< samples left to decode in current frame
 
133
 
 
134
    int fileversion;                         ///< codec version, very important in decoding process
 
135
    int compression_level;                   ///< compression levels
 
136
    int fset;                                ///< which filter set to use (calculated from compression level)
 
137
    int flags;                               ///< global decoder flags
 
138
 
 
139
    uint32_t CRC;                            ///< frame CRC
 
140
    int frameflags;                          ///< frame flags
 
141
    int currentframeblocks;                  ///< samples (per channel) in current frame
 
142
    int blocksdecoded;                       ///< count of decoded samples in current frame
 
143
    APEPredictor predictor;                  ///< predictor used for final reconstruction
 
144
 
 
145
    int32_t decoded0[BLOCKS_PER_LOOP];       ///< decoded data for the first channel
 
146
    int32_t decoded1[BLOCKS_PER_LOOP];       ///< decoded data for the second channel
 
147
 
 
148
    int16_t* filterbuf[APE_FILTER_LEVELS];   ///< filter memory
 
149
 
 
150
    APERangecoder rc;                        ///< rangecoder used to decode actual values
 
151
    APERice riceX;                           ///< rice code parameters for the second channel
 
152
    APERice riceY;                           ///< rice code parameters for the first channel
 
153
    APEFilter filters[APE_FILTER_LEVELS][2]; ///< filters used for reconstruction
 
154
 
 
155
    uint8_t *data;                           ///< current frame data
 
156
    uint8_t *data_end;                       ///< frame data end
 
157
    const uint8_t *ptr;                      ///< current position in frame data
 
158
    const uint8_t *last_ptr;                 ///< position where last 4608-sample block ended
 
159
 
 
160
    int error;
 
161
} APEContext;
 
162
 
 
163
// TODO: dsputilize
 
164
static inline void vector_add(int16_t * v1, int16_t * v2, int order)
 
165
{
 
166
    while (order--)
 
167
       *v1++ += *v2++;
 
168
}
 
169
 
 
170
// TODO: dsputilize
 
171
static inline void vector_sub(int16_t * v1, int16_t * v2, int order)
 
172
{
 
173
    while (order--)
 
174
        *v1++ -= *v2++;
 
175
}
 
176
 
 
177
// TODO: dsputilize
 
178
static inline int32_t scalarproduct(int16_t * v1, int16_t * v2, int order)
 
179
{
 
180
    int res = 0;
 
181
 
 
182
    while (order--)
 
183
        res += *v1++ * *v2++;
 
184
 
 
185
    return res;
 
186
}
 
187
 
 
188
static av_cold int ape_decode_init(AVCodecContext * avctx)
 
189
{
 
190
    APEContext *s = avctx->priv_data;
 
191
    int i;
 
192
 
 
193
    if (avctx->extradata_size != 6) {
 
194
        av_log(avctx, AV_LOG_ERROR, "Incorrect extradata\n");
 
195
        return -1;
 
196
    }
 
197
    if (avctx->bits_per_sample != 16) {
 
198
        av_log(avctx, AV_LOG_ERROR, "Only 16-bit samples are supported\n");
 
199
        return -1;
 
200
    }
 
201
    if (avctx->channels > 2) {
 
202
        av_log(avctx, AV_LOG_ERROR, "Only mono and stereo is supported\n");
 
203
        return -1;
 
204
    }
 
205
    s->avctx             = avctx;
 
206
    s->channels          = avctx->channels;
 
207
    s->fileversion       = AV_RL16(avctx->extradata);
 
208
    s->compression_level = AV_RL16(avctx->extradata + 2);
 
209
    s->flags             = AV_RL16(avctx->extradata + 4);
 
210
 
 
211
    av_log(avctx, AV_LOG_DEBUG, "Compression Level: %d - Flags: %d\n", s->compression_level, s->flags);
 
212
    if (s->compression_level % 1000 || s->compression_level > COMPRESSION_LEVEL_INSANE) {
 
213
        av_log(avctx, AV_LOG_ERROR, "Incorrect compression level %d\n", s->compression_level);
 
214
        return -1;
 
215
    }
 
216
    s->fset = s->compression_level / 1000 - 1;
 
217
    for (i = 0; i < APE_FILTER_LEVELS; i++) {
 
218
        if (!ape_filter_orders[s->fset][i])
 
219
            break;
 
220
        s->filterbuf[i] = av_malloc((ape_filter_orders[s->fset][i] * 3 + HISTORY_SIZE) * 4);
 
221
    }
 
222
 
 
223
    dsputil_init(&s->dsp, avctx);
 
224
    return 0;
 
225
}
 
226
 
 
227
static av_cold int ape_decode_close(AVCodecContext * avctx)
 
228
{
 
229
    APEContext *s = avctx->priv_data;
 
230
    int i;
 
231
 
 
232
    for (i = 0; i < APE_FILTER_LEVELS; i++)
 
233
        av_freep(&s->filterbuf[i]);
 
234
 
 
235
    return 0;
 
236
}
 
237
 
 
238
/**
 
239
 * @defgroup rangecoder APE range decoder
 
240
 * @{
 
241
 */
 
242
 
 
243
#define CODE_BITS    32
 
244
#define TOP_VALUE    ((unsigned int)1 << (CODE_BITS-1))
 
245
#define SHIFT_BITS   (CODE_BITS - 9)
 
246
#define EXTRA_BITS   ((CODE_BITS-2) % 8 + 1)
 
247
#define BOTTOM_VALUE (TOP_VALUE >> 8)
 
248
 
 
249
/** Start the decoder */
 
250
static inline void range_start_decoding(APEContext * ctx)
 
251
{
 
252
    ctx->rc.buffer = bytestream_get_byte(&ctx->ptr);
 
253
    ctx->rc.low    = ctx->rc.buffer >> (8 - EXTRA_BITS);
 
254
    ctx->rc.range  = (uint32_t) 1 << EXTRA_BITS;
 
255
}
 
256
 
 
257
/** Perform normalization */
 
258
static inline void range_dec_normalize(APEContext * ctx)
 
259
{
 
260
    while (ctx->rc.range <= BOTTOM_VALUE) {
 
261
        ctx->rc.buffer <<= 8;
 
262
        if(ctx->ptr < ctx->data_end)
 
263
            ctx->rc.buffer += *ctx->ptr;
 
264
        ctx->ptr++;
 
265
        ctx->rc.low    = (ctx->rc.low << 8)    | ((ctx->rc.buffer >> 1) & 0xFF);
 
266
        ctx->rc.range  <<= 8;
 
267
    }
 
268
}
 
269
 
 
270
/**
 
271
 * Calculate culmulative frequency for next symbol. Does NO update!
 
272
 * @param tot_f is the total frequency or (code_value)1<<shift
 
273
 * @return the culmulative frequency
 
274
 */
 
275
static inline int range_decode_culfreq(APEContext * ctx, int tot_f)
 
276
{
 
277
    range_dec_normalize(ctx);
 
278
    ctx->rc.help = ctx->rc.range / tot_f;
 
279
    return ctx->rc.low / ctx->rc.help;
 
280
}
 
281
 
 
282
/**
 
283
 * Decode value with given size in bits
 
284
 * @param shift number of bits to decode
 
285
 */
 
286
static inline int range_decode_culshift(APEContext * ctx, int shift)
 
287
{
 
288
    range_dec_normalize(ctx);
 
289
    ctx->rc.help = ctx->rc.range >> shift;
 
290
    return ctx->rc.low / ctx->rc.help;
 
291
}
 
292
 
 
293
 
 
294
/**
 
295
 * Update decoding state
 
296
 * @param sy_f the interval length (frequency of the symbol)
 
297
 * @param lt_f the lower end (frequency sum of < symbols)
 
298
 */
 
299
static inline void range_decode_update(APEContext * ctx, int sy_f, int lt_f)
 
300
{
 
301
    ctx->rc.low  -= ctx->rc.help * lt_f;
 
302
    ctx->rc.range = ctx->rc.help * sy_f;
 
303
}
 
304
 
 
305
/** Decode n bits (n <= 16) without modelling */
 
306
static inline int range_decode_bits(APEContext * ctx, int n)
 
307
{
 
308
    int sym = range_decode_culshift(ctx, n);
 
309
    range_decode_update(ctx, 1, sym);
 
310
    return sym;
 
311
}
 
312
 
 
313
 
 
314
#define MODEL_ELEMENTS 64
 
315
 
 
316
/**
 
317
 * Fixed probabilities for symbols in Monkey Audio version 3.97
 
318
 */
 
319
static const uint16_t counts_3970[22] = {
 
320
        0, 14824, 28224, 39348, 47855, 53994, 58171, 60926,
 
321
    62682, 63786, 64463, 64878, 65126, 65276, 65365, 65419,
 
322
    65450, 65469, 65480, 65487, 65491, 65493,
 
323
};
 
324
 
 
325
/**
 
326
 * Probability ranges for symbols in Monkey Audio version 3.97
 
327
 */
 
328
static const uint16_t counts_diff_3970[21] = {
 
329
    14824, 13400, 11124, 8507, 6139, 4177, 2755, 1756,
 
330
    1104, 677, 415, 248, 150, 89, 54, 31,
 
331
    19, 11, 7, 4, 2,
 
332
};
 
333
 
 
334
/**
 
335
 * Fixed probabilities for symbols in Monkey Audio version 3.98
 
336
 */
 
337
static const uint16_t counts_3980[22] = {
 
338
        0, 19578, 36160, 48417, 56323, 60899, 63265, 64435,
 
339
    64971, 65232, 65351, 65416, 65447, 65466, 65476, 65482,
 
340
    65485, 65488, 65490, 65491, 65492, 65493,
 
341
};
 
342
 
 
343
/**
 
344
 * Probability ranges for symbols in Monkey Audio version 3.98
 
345
 */
 
346
static const uint16_t counts_diff_3980[21] = {
 
347
    19578, 16582, 12257, 7906, 4576, 2366, 1170, 536,
 
348
    261, 119, 65, 31, 19, 10, 6, 3,
 
349
    3, 2, 1, 1, 1,
 
350
};
 
351
 
 
352
/**
 
353
 * Decode symbol
 
354
 * @param counts probability range start position
 
355
 * @param count_diffs probability range widths
 
356
 */
 
357
static inline int range_get_symbol(APEContext * ctx,
 
358
                                   const uint16_t counts[],
 
359
                                   const uint16_t counts_diff[])
 
360
{
 
361
    int symbol, cf;
 
362
 
 
363
    cf = range_decode_culshift(ctx, 16);
 
364
 
 
365
    if(cf > 65492){
 
366
        symbol= cf - 65535 + 63;
 
367
        range_decode_update(ctx, 1, cf);
 
368
        if(cf > 65535)
 
369
            ctx->error=1;
 
370
        return symbol;
 
371
    }
 
372
    /* figure out the symbol inefficiently; a binary search would be much better */
 
373
    for (symbol = 0; counts[symbol + 1] <= cf; symbol++);
 
374
 
 
375
    range_decode_update(ctx, counts_diff[symbol], counts[symbol]);
 
376
 
 
377
    return symbol;
 
378
}
 
379
/** @} */ // group rangecoder
 
380
 
 
381
static inline void update_rice(APERice *rice, int x)
 
382
{
 
383
    rice->ksum += ((x + 1) / 2) - ((rice->ksum + 16) >> 5);
 
384
 
 
385
    if (rice->k == 0)
 
386
        rice->k = 1;
 
387
    else if (rice->ksum < (1 << (rice->k + 4)))
 
388
        rice->k--;
 
389
    else if (rice->ksum >= (1 << (rice->k + 5)))
 
390
        rice->k++;
 
391
}
 
392
 
 
393
static inline int ape_decode_value(APEContext * ctx, APERice *rice)
 
394
{
 
395
    int x, overflow;
 
396
 
 
397
    if (ctx->fileversion < 3980) {
 
398
        int tmpk;
 
399
 
 
400
        overflow = range_get_symbol(ctx, counts_3970, counts_diff_3970);
 
401
 
 
402
        if (overflow == (MODEL_ELEMENTS - 1)) {
 
403
            tmpk = range_decode_bits(ctx, 5);
 
404
            overflow = 0;
 
405
        } else
 
406
            tmpk = (rice->k < 1) ? 0 : rice->k - 1;
 
407
 
 
408
        if (tmpk <= 16)
 
409
            x = range_decode_bits(ctx, tmpk);
 
410
        else {
 
411
            x = range_decode_bits(ctx, 16);
 
412
            x |= (range_decode_bits(ctx, tmpk - 16) << 16);
 
413
        }
 
414
        x += overflow << tmpk;
 
415
    } else {
 
416
        int base, pivot;
 
417
 
 
418
        pivot = rice->ksum >> 5;
 
419
        if (pivot == 0)
 
420
            pivot = 1;
 
421
 
 
422
        overflow = range_get_symbol(ctx, counts_3980, counts_diff_3980);
 
423
 
 
424
        if (overflow == (MODEL_ELEMENTS - 1)) {
 
425
            overflow  = range_decode_bits(ctx, 16) << 16;
 
426
            overflow |= range_decode_bits(ctx, 16);
 
427
        }
 
428
 
 
429
        base = range_decode_culfreq(ctx, pivot);
 
430
        range_decode_update(ctx, 1, base);
 
431
 
 
432
        x = base + overflow * pivot;
 
433
    }
 
434
 
 
435
    update_rice(rice, x);
 
436
 
 
437
    /* Convert to signed */
 
438
    if (x & 1)
 
439
        return (x >> 1) + 1;
 
440
    else
 
441
        return -(x >> 1);
 
442
}
 
443
 
 
444
static void entropy_decode(APEContext * ctx, int blockstodecode, int stereo)
 
445
{
 
446
    int32_t *decoded0 = ctx->decoded0;
 
447
    int32_t *decoded1 = ctx->decoded1;
 
448
 
 
449
    ctx->blocksdecoded = blockstodecode;
 
450
 
 
451
    if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {
 
452
        /* We are pure silence, just memset the output buffer. */
 
453
        memset(decoded0, 0, blockstodecode * sizeof(int32_t));
 
454
        memset(decoded1, 0, blockstodecode * sizeof(int32_t));
 
455
    } else {
 
456
        while (blockstodecode--) {
 
457
            *decoded0++ = ape_decode_value(ctx, &ctx->riceY);
 
458
            if (stereo)
 
459
                *decoded1++ = ape_decode_value(ctx, &ctx->riceX);
 
460
        }
 
461
    }
 
462
 
 
463
    if (ctx->blocksdecoded == ctx->currentframeblocks)
 
464
        range_dec_normalize(ctx);   /* normalize to use up all bytes */
 
465
}
 
466
 
 
467
static void init_entropy_decoder(APEContext * ctx)
 
468
{
 
469
    /* Read the CRC */
 
470
    ctx->CRC = bytestream_get_be32(&ctx->ptr);
 
471
 
 
472
    /* Read the frame flags if they exist */
 
473
    ctx->frameflags = 0;
 
474
    if ((ctx->fileversion > 3820) && (ctx->CRC & 0x80000000)) {
 
475
        ctx->CRC &= ~0x80000000;
 
476
 
 
477
        ctx->frameflags = bytestream_get_be32(&ctx->ptr);
 
478
    }
 
479
 
 
480
    /* Keep a count of the blocks decoded in this frame */
 
481
    ctx->blocksdecoded = 0;
 
482
 
 
483
    /* Initialize the rice structs */
 
484
    ctx->riceX.k = 10;
 
485
    ctx->riceX.ksum = (1 << ctx->riceX.k) * 16;
 
486
    ctx->riceY.k = 10;
 
487
    ctx->riceY.ksum = (1 << ctx->riceY.k) * 16;
 
488
 
 
489
    /* The first 8 bits of input are ignored. */
 
490
    ctx->ptr++;
 
491
 
 
492
    range_start_decoding(ctx);
 
493
}
 
494
 
 
495
static const int32_t initial_coeffs[4] = {
 
496
    360, 317, -109, 98
 
497
};
 
498
 
 
499
static void init_predictor_decoder(APEContext * ctx)
 
500
{
 
501
    APEPredictor *p = &ctx->predictor;
 
502
 
 
503
    /* Zero the history buffers */
 
504
    memset(p->historybuffer, 0, PREDICTOR_SIZE * sizeof(int32_t));
 
505
    p->buf = p->historybuffer;
 
506
 
 
507
    /* Initialize and zero the coefficients */
 
508
    memcpy(p->coeffsA[0], initial_coeffs, sizeof(initial_coeffs));
 
509
    memcpy(p->coeffsA[1], initial_coeffs, sizeof(initial_coeffs));
 
510
    memset(p->coeffsB, 0, sizeof(p->coeffsB));
 
511
 
 
512
    p->filterA[0] = p->filterA[1] = 0;
 
513
    p->filterB[0] = p->filterB[1] = 0;
 
514
    p->lastA[0]   = p->lastA[1]   = 0;
 
515
}
 
516
 
 
517
/** Get inverse sign of integer (-1 for positive, 1 for negative and 0 for zero) */
 
518
static inline int APESIGN(int32_t x) {
 
519
    return (x < 0) - (x > 0);
 
520
}
 
521
 
 
522
static int predictor_update_filter(APEPredictor *p, const int decoded, const int filter, const int delayA, const int delayB, const int adaptA, const int adaptB)
 
523
{
 
524
    int32_t predictionA, predictionB;
 
525
 
 
526
    p->buf[delayA]     = p->lastA[filter];
 
527
    p->buf[adaptA]     = APESIGN(p->buf[delayA]);
 
528
    p->buf[delayA - 1] = p->buf[delayA] - p->buf[delayA - 1];
 
529
    p->buf[adaptA - 1] = APESIGN(p->buf[delayA - 1]);
 
530
 
 
531
    predictionA = p->buf[delayA    ] * p->coeffsA[filter][0] +
 
532
                  p->buf[delayA - 1] * p->coeffsA[filter][1] +
 
533
                  p->buf[delayA - 2] * p->coeffsA[filter][2] +
 
534
                  p->buf[delayA - 3] * p->coeffsA[filter][3];
 
535
 
 
536
    /*  Apply a scaled first-order filter compression */
 
537
    p->buf[delayB]     = p->filterA[filter ^ 1] - ((p->filterB[filter] * 31) >> 5);
 
538
    p->buf[adaptB]     = APESIGN(p->buf[delayB]);
 
539
    p->buf[delayB - 1] = p->buf[delayB] - p->buf[delayB - 1];
 
540
    p->buf[adaptB - 1] = APESIGN(p->buf[delayB - 1]);
 
541
    p->filterB[filter] = p->filterA[filter ^ 1];
 
542
 
 
543
    predictionB = p->buf[delayB    ] * p->coeffsB[filter][0] +
 
544
                  p->buf[delayB - 1] * p->coeffsB[filter][1] +
 
545
                  p->buf[delayB - 2] * p->coeffsB[filter][2] +
 
546
                  p->buf[delayB - 3] * p->coeffsB[filter][3] +
 
547
                  p->buf[delayB - 4] * p->coeffsB[filter][4];
 
548
 
 
549
    p->lastA[filter] = decoded + ((predictionA + (predictionB >> 1)) >> 10);
 
550
    p->filterA[filter] = p->lastA[filter] + ((p->filterA[filter] * 31) >> 5);
 
551
 
 
552
    if (!decoded) // no need updating filter coefficients
 
553
        return p->filterA[filter];
 
554
 
 
555
    if (decoded > 0) {
 
556
        p->coeffsA[filter][0] -= p->buf[adaptA    ];
 
557
        p->coeffsA[filter][1] -= p->buf[adaptA - 1];
 
558
        p->coeffsA[filter][2] -= p->buf[adaptA - 2];
 
559
        p->coeffsA[filter][3] -= p->buf[adaptA - 3];
 
560
 
 
561
        p->coeffsB[filter][0] -= p->buf[adaptB    ];
 
562
        p->coeffsB[filter][1] -= p->buf[adaptB - 1];
 
563
        p->coeffsB[filter][2] -= p->buf[adaptB - 2];
 
564
        p->coeffsB[filter][3] -= p->buf[adaptB - 3];
 
565
        p->coeffsB[filter][4] -= p->buf[adaptB - 4];
 
566
    } else {
 
567
        p->coeffsA[filter][0] += p->buf[adaptA    ];
 
568
        p->coeffsA[filter][1] += p->buf[adaptA - 1];
 
569
        p->coeffsA[filter][2] += p->buf[adaptA - 2];
 
570
        p->coeffsA[filter][3] += p->buf[adaptA - 3];
 
571
 
 
572
        p->coeffsB[filter][0] += p->buf[adaptB    ];
 
573
        p->coeffsB[filter][1] += p->buf[adaptB - 1];
 
574
        p->coeffsB[filter][2] += p->buf[adaptB - 2];
 
575
        p->coeffsB[filter][3] += p->buf[adaptB - 3];
 
576
        p->coeffsB[filter][4] += p->buf[adaptB - 4];
 
577
    }
 
578
    return p->filterA[filter];
 
579
}
 
580
 
 
581
static void predictor_decode_stereo(APEContext * ctx, int count)
 
582
{
 
583
    int32_t predictionA, predictionB;
 
584
    APEPredictor *p = &ctx->predictor;
 
585
    int32_t *decoded0 = ctx->decoded0;
 
586
    int32_t *decoded1 = ctx->decoded1;
 
587
 
 
588
    while (count--) {
 
589
        /* Predictor Y */
 
590
        predictionA = predictor_update_filter(p, *decoded0, 0, YDELAYA, YDELAYB, YADAPTCOEFFSA, YADAPTCOEFFSB);
 
591
        predictionB = predictor_update_filter(p, *decoded1, 1, XDELAYA, XDELAYB, XADAPTCOEFFSA, XADAPTCOEFFSB);
 
592
        *(decoded0++) = predictionA;
 
593
        *(decoded1++) = predictionB;
 
594
 
 
595
        /* Combined */
 
596
        p->buf++;
 
597
 
 
598
        /* Have we filled the history buffer? */
 
599
        if (p->buf == p->historybuffer + HISTORY_SIZE) {
 
600
            memmove(p->historybuffer, p->buf, PREDICTOR_SIZE * sizeof(int32_t));
 
601
            p->buf = p->historybuffer;
 
602
        }
 
603
    }
 
604
}
 
605
 
 
606
static void predictor_decode_mono(APEContext * ctx, int count)
 
607
{
 
608
    APEPredictor *p = &ctx->predictor;
 
609
    int32_t *decoded0 = ctx->decoded0;
 
610
    int32_t predictionA, currentA, A;
 
611
 
 
612
    currentA = p->lastA[0];
 
613
 
 
614
    while (count--) {
 
615
        A = *decoded0;
 
616
 
 
617
        p->buf[YDELAYA] = currentA;
 
618
        p->buf[YDELAYA - 1] = p->buf[YDELAYA] - p->buf[YDELAYA - 1];
 
619
 
 
620
        predictionA = p->buf[YDELAYA    ] * p->coeffsA[0][0] +
 
621
                      p->buf[YDELAYA - 1] * p->coeffsA[0][1] +
 
622
                      p->buf[YDELAYA - 2] * p->coeffsA[0][2] +
 
623
                      p->buf[YDELAYA - 3] * p->coeffsA[0][3];
 
624
 
 
625
        currentA = A + (predictionA >> 10);
 
626
 
 
627
        p->buf[YADAPTCOEFFSA]     = APESIGN(p->buf[YDELAYA    ]);
 
628
        p->buf[YADAPTCOEFFSA - 1] = APESIGN(p->buf[YDELAYA - 1]);
 
629
 
 
630
        if (A > 0) {
 
631
            p->coeffsA[0][0] -= p->buf[YADAPTCOEFFSA    ];
 
632
            p->coeffsA[0][1] -= p->buf[YADAPTCOEFFSA - 1];
 
633
            p->coeffsA[0][2] -= p->buf[YADAPTCOEFFSA - 2];
 
634
            p->coeffsA[0][3] -= p->buf[YADAPTCOEFFSA - 3];
 
635
        } else if (A < 0) {
 
636
            p->coeffsA[0][0] += p->buf[YADAPTCOEFFSA    ];
 
637
            p->coeffsA[0][1] += p->buf[YADAPTCOEFFSA - 1];
 
638
            p->coeffsA[0][2] += p->buf[YADAPTCOEFFSA - 2];
 
639
            p->coeffsA[0][3] += p->buf[YADAPTCOEFFSA - 3];
 
640
        }
 
641
 
 
642
        p->buf++;
 
643
 
 
644
        /* Have we filled the history buffer? */
 
645
        if (p->buf == p->historybuffer + HISTORY_SIZE) {
 
646
            memmove(p->historybuffer, p->buf, PREDICTOR_SIZE * sizeof(int32_t));
 
647
            p->buf = p->historybuffer;
 
648
        }
 
649
 
 
650
        p->filterA[0] = currentA + ((p->filterA[0] * 31) >> 5);
 
651
        *(decoded0++) = p->filterA[0];
 
652
    }
 
653
 
 
654
    p->lastA[0] = currentA;
 
655
}
 
656
 
 
657
static void do_init_filter(APEFilter *f, int16_t * buf, int order)
 
658
{
 
659
    f->coeffs = buf;
 
660
    f->historybuffer = buf + order;
 
661
    f->delay       = f->historybuffer + order * 2;
 
662
    f->adaptcoeffs = f->historybuffer + order;
 
663
 
 
664
    memset(f->historybuffer, 0, (order * 2) * sizeof(int16_t));
 
665
    memset(f->coeffs, 0, order * sizeof(int16_t));
 
666
    f->avg = 0;
 
667
}
 
668
 
 
669
static void init_filter(APEContext * ctx, APEFilter *f, int16_t * buf, int order)
 
670
{
 
671
    do_init_filter(&f[0], buf, order);
 
672
    do_init_filter(&f[1], buf + order * 3 + HISTORY_SIZE, order);
 
673
}
 
674
 
 
675
static inline void do_apply_filter(int version, APEFilter *f, int32_t *data, int count, int order, int fracbits)
 
676
{
 
677
    int res;
 
678
    int absres;
 
679
 
 
680
    while (count--) {
 
681
        /* round fixedpoint scalar product */
 
682
        res = (scalarproduct(f->delay - order, f->coeffs, order) + (1 << (fracbits - 1))) >> fracbits;
 
683
 
 
684
        if (*data < 0)
 
685
            vector_add(f->coeffs, f->adaptcoeffs - order, order);
 
686
        else if (*data > 0)
 
687
            vector_sub(f->coeffs, f->adaptcoeffs - order, order);
 
688
 
 
689
        res += *data;
 
690
 
 
691
        *data++ = res;
 
692
 
 
693
        /* Update the output history */
 
694
        *f->delay++ = av_clip_int16(res);
 
695
 
 
696
        if (version < 3980) {
 
697
            /* Version ??? to < 3.98 files (untested) */
 
698
            f->adaptcoeffs[0]  = (res == 0) ? 0 : ((res >> 28) & 8) - 4;
 
699
            f->adaptcoeffs[-4] >>= 1;
 
700
            f->adaptcoeffs[-8] >>= 1;
 
701
        } else {
 
702
            /* Version 3.98 and later files */
 
703
 
 
704
            /* Update the adaption coefficients */
 
705
            absres = (res < 0 ? -res : res);
 
706
 
 
707
            if (absres > (f->avg * 3))
 
708
                *f->adaptcoeffs = ((res >> 25) & 64) - 32;
 
709
            else if (absres > (f->avg * 4) / 3)
 
710
                *f->adaptcoeffs = ((res >> 26) & 32) - 16;
 
711
            else if (absres > 0)
 
712
                *f->adaptcoeffs = ((res >> 27) & 16) - 8;
 
713
            else
 
714
                *f->adaptcoeffs = 0;
 
715
 
 
716
            f->avg += (absres - f->avg) / 16;
 
717
 
 
718
            f->adaptcoeffs[-1] >>= 1;
 
719
            f->adaptcoeffs[-2] >>= 1;
 
720
            f->adaptcoeffs[-8] >>= 1;
 
721
        }
 
722
 
 
723
        f->adaptcoeffs++;
 
724
 
 
725
        /* Have we filled the history buffer? */
 
726
        if (f->delay == f->historybuffer + HISTORY_SIZE + (order * 2)) {
 
727
            memmove(f->historybuffer, f->delay - (order * 2),
 
728
                    (order * 2) * sizeof(int16_t));
 
729
            f->delay = f->historybuffer + order * 2;
 
730
            f->adaptcoeffs = f->historybuffer + order;
 
731
        }
 
732
    }
 
733
}
 
734
 
 
735
static void apply_filter(APEContext * ctx, APEFilter *f,
 
736
                         int32_t * data0, int32_t * data1,
 
737
                         int count, int order, int fracbits)
 
738
{
 
739
    do_apply_filter(ctx->fileversion, &f[0], data0, count, order, fracbits);
 
740
    if (data1)
 
741
        do_apply_filter(ctx->fileversion, &f[1], data1, count, order, fracbits);
 
742
}
 
743
 
 
744
static void ape_apply_filters(APEContext * ctx, int32_t * decoded0,
 
745
                              int32_t * decoded1, int count)
 
746
{
 
747
    int i;
 
748
 
 
749
    for (i = 0; i < APE_FILTER_LEVELS; i++) {
 
750
        if (!ape_filter_orders[ctx->fset][i])
 
751
            break;
 
752
        apply_filter(ctx, ctx->filters[i], decoded0, decoded1, count, ape_filter_orders[ctx->fset][i], ape_filter_fracbits[ctx->fset][i]);
 
753
    }
 
754
}
 
755
 
 
756
static void init_frame_decoder(APEContext * ctx)
 
757
{
 
758
    int i;
 
759
    init_entropy_decoder(ctx);
 
760
    init_predictor_decoder(ctx);
 
761
 
 
762
    for (i = 0; i < APE_FILTER_LEVELS; i++) {
 
763
        if (!ape_filter_orders[ctx->fset][i])
 
764
            break;
 
765
        init_filter(ctx, ctx->filters[i], ctx->filterbuf[i], ape_filter_orders[ctx->fset][i]);
 
766
    }
 
767
}
 
768
 
 
769
static void ape_unpack_mono(APEContext * ctx, int count)
 
770
{
 
771
    int32_t left;
 
772
    int32_t *decoded0 = ctx->decoded0;
 
773
    int32_t *decoded1 = ctx->decoded1;
 
774
 
 
775
    if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {
 
776
        entropy_decode(ctx, count, 0);
 
777
        /* We are pure silence, so we're done. */
 
778
        av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence mono\n");
 
779
        return;
 
780
    }
 
781
 
 
782
    entropy_decode(ctx, count, 0);
 
783
    ape_apply_filters(ctx, decoded0, NULL, count);
 
784
 
 
785
    /* Now apply the predictor decoding */
 
786
    predictor_decode_mono(ctx, count);
 
787
 
 
788
    /* Pseudo-stereo - just copy left channel to right channel */
 
789
    if (ctx->channels == 2) {
 
790
        while (count--) {
 
791
            left = *decoded0;
 
792
            *(decoded1++) = *(decoded0++) = left;
 
793
        }
 
794
    }
 
795
}
 
796
 
 
797
static void ape_unpack_stereo(APEContext * ctx, int count)
 
798
{
 
799
    int32_t left, right;
 
800
    int32_t *decoded0 = ctx->decoded0;
 
801
    int32_t *decoded1 = ctx->decoded1;
 
802
 
 
803
    if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {
 
804
        /* We are pure silence, so we're done. */
 
805
        av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence stereo\n");
 
806
        return;
 
807
    }
 
808
 
 
809
    entropy_decode(ctx, count, 1);
 
810
    ape_apply_filters(ctx, decoded0, decoded1, count);
 
811
 
 
812
    /* Now apply the predictor decoding */
 
813
    predictor_decode_stereo(ctx, count);
 
814
 
 
815
    /* Decorrelate and scale to output depth */
 
816
    while (count--) {
 
817
        left = *decoded1 - (*decoded0 / 2);
 
818
        right = left + *decoded0;
 
819
 
 
820
        *(decoded0++) = left;
 
821
        *(decoded1++) = right;
 
822
    }
 
823
}
 
824
 
 
825
static int ape_decode_frame(AVCodecContext * avctx,
 
826
                            void *data, int *data_size,
 
827
                            const uint8_t * buf, int buf_size)
 
828
{
 
829
    APEContext *s = avctx->priv_data;
 
830
    int16_t *samples = data;
 
831
    int nblocks;
 
832
    int i, n;
 
833
    int blockstodecode;
 
834
    int bytes_used;
 
835
 
 
836
    if (buf_size == 0 && !s->samples) {
 
837
        *data_size = 0;
 
838
        return 0;
 
839
    }
 
840
 
 
841
    /* should not happen but who knows */
 
842
    if (BLOCKS_PER_LOOP * 2 * avctx->channels > *data_size) {
 
843
        av_log (avctx, AV_LOG_ERROR, "Packet size is too big to be handled in lavc! (max is %d where you have %d)\n", *data_size, s->samples * 2 * avctx->channels);
 
844
        return -1;
 
845
    }
 
846
 
 
847
    if(!s->samples){
 
848
        s->data = av_realloc(s->data, (buf_size + 3) & ~3);
 
849
        s->dsp.bswap_buf((uint32_t*)s->data, (const uint32_t*)buf, buf_size >> 2);
 
850
        s->ptr = s->last_ptr = s->data;
 
851
        s->data_end = s->data + buf_size;
 
852
 
 
853
        nblocks = s->samples = bytestream_get_be32(&s->ptr);
 
854
        n =  bytestream_get_be32(&s->ptr);
 
855
        if(n < 0 || n > 3){
 
856
            av_log(avctx, AV_LOG_ERROR, "Incorrect offset passed\n");
 
857
            s->data = NULL;
 
858
            return -1;
 
859
        }
 
860
        s->ptr += n;
 
861
 
 
862
        s->currentframeblocks = nblocks;
 
863
        buf += 4;
 
864
        if (s->samples <= 0) {
 
865
            *data_size = 0;
 
866
            return buf_size;
 
867
        }
 
868
 
 
869
        memset(s->decoded0,  0, sizeof(s->decoded0));
 
870
        memset(s->decoded1,  0, sizeof(s->decoded1));
 
871
 
 
872
        /* Initialize the frame decoder */
 
873
        init_frame_decoder(s);
 
874
    }
 
875
 
 
876
    if (!s->data) {
 
877
        *data_size = 0;
 
878
        return buf_size;
 
879
    }
 
880
 
 
881
    nblocks = s->samples;
 
882
    blockstodecode = FFMIN(BLOCKS_PER_LOOP, nblocks);
 
883
 
 
884
    s->error=0;
 
885
 
 
886
    if ((s->channels == 1) || (s->frameflags & APE_FRAMECODE_PSEUDO_STEREO))
 
887
        ape_unpack_mono(s, blockstodecode);
 
888
    else
 
889
        ape_unpack_stereo(s, blockstodecode);
 
890
 
 
891
    if(s->error || s->ptr > s->data_end){
 
892
        s->samples=0;
 
893
        av_log(avctx, AV_LOG_ERROR, "Error decoding frame\n");
 
894
        return -1;
 
895
    }
 
896
 
 
897
    for (i = 0; i < blockstodecode; i++) {
 
898
        *samples++ = s->decoded0[i];
 
899
        if(s->channels == 2)
 
900
            *samples++ = s->decoded1[i];
 
901
    }
 
902
 
 
903
    s->samples -= blockstodecode;
 
904
 
 
905
    *data_size = blockstodecode * 2 * s->channels;
 
906
    bytes_used = s->samples ? s->ptr - s->last_ptr : buf_size;
 
907
    s->last_ptr = s->ptr;
 
908
    return bytes_used;
 
909
}
 
910
 
 
911
AVCodec ape_decoder = {
 
912
    "ape",
 
913
    CODEC_TYPE_AUDIO,
 
914
    CODEC_ID_APE,
 
915
    sizeof(APEContext),
 
916
    ape_decode_init,
 
917
    NULL,
 
918
    ape_decode_close,
 
919
    ape_decode_frame,
 
920
    .long_name = "Monkey's Audio",
 
921
};