Detect and prevent reading over the end of counts_*. We pass the error
[ffmpeg.git] / 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 uint16_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 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 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 uint32_t counts_3970[65] = {
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, 65494, 65495,
323     65496, 65497, 65498, 65499, 65500, 65501, 65502, 65503,
324     65504, 65505, 65506, 65507, 65508, 65509, 65510, 65511,
325     65512, 65513, 65514, 65515, 65516, 65517, 65518, 65519,
326     65520, 65521, 65522, 65523, 65524, 65525, 65526, 65527,
327     65528, 65529, 65530, 65531, 65532, 65533, 65534, 65535,
328     65536
329 };
330
331 /**
332  * Probability ranges for symbols in Monkey Audio version 3.97
333  */
334 static const uint16_t counts_diff_3970[64] = {
335     14824, 13400, 11124, 8507, 6139, 4177, 2755, 1756,
336     1104, 677, 415, 248, 150, 89, 54, 31,
337     19, 11, 7, 4, 2, 1, 1, 1,
338     1, 1, 1, 1, 1, 1, 1, 1,
339     1, 1, 1, 1, 1, 1, 1, 1,
340     1, 1, 1, 1, 1, 1, 1, 1,
341     1, 1, 1, 1, 1, 1, 1, 1,
342     1, 1, 1, 1, 1, 1, 1, 1
343 };
344
345 /**
346  * Fixed probabilities for symbols in Monkey Audio version 3.98
347  */
348 static const uint32_t counts_3980[65] = {
349         0, 19578, 36160, 48417, 56323, 60899, 63265, 64435,
350     64971, 65232, 65351, 65416, 65447, 65466, 65476, 65482,
351     65485, 65488, 65490, 65491, 65492, 65493, 65494, 65495,
352     65496, 65497, 65498, 65499, 65500, 65501, 65502, 65503,
353     65504, 65505, 65506, 65507, 65508, 65509, 65510, 65511,
354     65512, 65513, 65514, 65515, 65516, 65517, 65518, 65519,
355     65520, 65521, 65522, 65523, 65524, 65525, 65526, 65527,
356     65528, 65529, 65530, 65531, 65532, 65533, 65534, 65535,
357     65536
358 };
359
360 /**
361  * Probability ranges for symbols in Monkey Audio version 3.98
362  */
363 static const uint16_t counts_diff_3980[64] = {
364     19578, 16582, 12257, 7906, 4576, 2366, 1170, 536,
365     261, 119, 65, 31, 19, 10, 6, 3,
366     3, 2, 1, 1, 1, 1, 1, 1,
367     1, 1, 1, 1, 1, 1, 1, 1,
368     1, 1, 1, 1, 1, 1, 1, 1,
369     1, 1, 1, 1, 1, 1, 1, 1,
370     1, 1, 1, 1, 1, 1, 1, 1,
371     1, 1, 1, 1, 1, 1, 1, 1
372 };
373
374 /**
375  * Decode symbol
376  * @param counts probability range start position
377  * @param count_diffs probability range widths
378  */
379 static inline int range_get_symbol(APEContext * ctx,
380                                    const uint32_t counts[],
381                                    const uint16_t counts_diff[])
382 {
383     int symbol, cf;
384
385     cf = range_decode_culshift(ctx, 16);
386
387     if(cf > 65492){
388         symbol= cf - 65535 + 63;
389         range_decode_update(ctx, 1, cf);
390         if(cf > 65535)
391             ctx->error=1;
392         return symbol;
393     }
394     /* figure out the symbol inefficiently; a binary search would be much better */
395     for (symbol = 0; counts[symbol + 1] <= cf; symbol++);
396
397     range_decode_update(ctx, counts_diff[symbol], counts[symbol]);
398
399     return symbol;
400 }
401 /** @} */ // group rangecoder
402
403 static inline void update_rice(APERice *rice, int x)
404 {
405     rice->ksum += ((x + 1) / 2) - ((rice->ksum + 16) >> 5);
406
407     if (rice->k == 0)
408         rice->k = 1;
409     else if (rice->ksum < (1 << (rice->k + 4)))
410         rice->k--;
411     else if (rice->ksum >= (1 << (rice->k + 5)))
412         rice->k++;
413 }
414
415 static inline int ape_decode_value(APEContext * ctx, APERice *rice)
416 {
417     int x, overflow;
418
419     if (ctx->fileversion < 3980) {
420         int tmpk;
421
422         overflow = range_get_symbol(ctx, counts_3970, counts_diff_3970);
423
424         if (overflow == (MODEL_ELEMENTS - 1)) {
425             tmpk = range_decode_bits(ctx, 5);
426             overflow = 0;
427         } else
428             tmpk = (rice->k < 1) ? 0 : rice->k - 1;
429
430         if (tmpk <= 16)
431             x = range_decode_bits(ctx, tmpk);
432         else {
433             x = range_decode_bits(ctx, 16);
434             x |= (range_decode_bits(ctx, tmpk - 16) << 16);
435         }
436         x += overflow << tmpk;
437     } else {
438         int base, pivot;
439
440         pivot = rice->ksum >> 5;
441         if (pivot == 0)
442             pivot = 1;
443
444         overflow = range_get_symbol(ctx, counts_3980, counts_diff_3980);
445
446         if (overflow == (MODEL_ELEMENTS - 1)) {
447             overflow  = range_decode_bits(ctx, 16) << 16;
448             overflow |= range_decode_bits(ctx, 16);
449         }
450
451         base = range_decode_culfreq(ctx, pivot);
452         range_decode_update(ctx, 1, base);
453
454         x = base + overflow * pivot;
455     }
456
457     update_rice(rice, x);
458
459     /* Convert to signed */
460     if (x & 1)
461         return (x >> 1) + 1;
462     else
463         return -(x >> 1);
464 }
465
466 static void entropy_decode(APEContext * ctx, int blockstodecode, int stereo)
467 {
468     int32_t *decoded0 = ctx->decoded0;
469     int32_t *decoded1 = ctx->decoded1;
470
471     ctx->blocksdecoded = blockstodecode;
472
473     if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {
474         /* We are pure silence, just memset the output buffer. */
475         memset(decoded0, 0, blockstodecode * sizeof(int32_t));
476         memset(decoded1, 0, blockstodecode * sizeof(int32_t));
477     } else {
478         while (blockstodecode--) {
479             *decoded0++ = ape_decode_value(ctx, &ctx->riceY);
480             if (stereo)
481                 *decoded1++ = ape_decode_value(ctx, &ctx->riceX);
482         }
483     }
484
485     if (ctx->blocksdecoded == ctx->currentframeblocks)
486         range_dec_normalize(ctx);   /* normalize to use up all bytes */
487 }
488
489 static void init_entropy_decoder(APEContext * ctx)
490 {
491     /* Read the CRC */
492     ctx->CRC = bytestream_get_be32(&ctx->ptr);
493
494     /* Read the frame flags if they exist */
495     ctx->frameflags = 0;
496     if ((ctx->fileversion > 3820) && (ctx->CRC & 0x80000000)) {
497         ctx->CRC &= ~0x80000000;
498
499         ctx->frameflags = bytestream_get_be32(&ctx->ptr);
500     }
501
502     /* Keep a count of the blocks decoded in this frame */
503     ctx->blocksdecoded = 0;
504
505     /* Initialize the rice structs */
506     ctx->riceX.k = 10;
507     ctx->riceX.ksum = (1 << ctx->riceX.k) * 16;
508     ctx->riceY.k = 10;
509     ctx->riceY.ksum = (1 << ctx->riceY.k) * 16;
510
511     /* The first 8 bits of input are ignored. */
512     ctx->ptr++;
513
514     range_start_decoding(ctx);
515 }
516
517 static const int32_t initial_coeffs[4] = {
518     360, 317, -109, 98
519 };
520
521 static void init_predictor_decoder(APEContext * ctx)
522 {
523     APEPredictor *p = &ctx->predictor;
524
525     /* Zero the history buffers */
526     memset(p->historybuffer, 0, PREDICTOR_SIZE * sizeof(int32_t));
527     p->buf = p->historybuffer;
528
529     /* Initialize and zero the coefficients */
530     memcpy(p->coeffsA[0], initial_coeffs, sizeof(initial_coeffs));
531     memcpy(p->coeffsA[1], initial_coeffs, sizeof(initial_coeffs));
532     memset(p->coeffsB, 0, sizeof(p->coeffsB));
533
534     p->filterA[0] = p->filterA[1] = 0;
535     p->filterB[0] = p->filterB[1] = 0;
536     p->lastA[0]   = p->lastA[1]   = 0;
537 }
538
539 /** Get inverse sign of integer (-1 for positive, 1 for negative and 0 for zero) */
540 static inline int APESIGN(int32_t x) {
541     return (x < 0) - (x > 0);
542 }
543
544 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)
545 {
546     int32_t predictionA, predictionB;
547
548     p->buf[delayA]     = p->lastA[filter];
549     p->buf[adaptA]     = APESIGN(p->buf[delayA]);
550     p->buf[delayA - 1] = p->buf[delayA] - p->buf[delayA - 1];
551     p->buf[adaptA - 1] = APESIGN(p->buf[delayA - 1]);
552
553     predictionA = p->buf[delayA    ] * p->coeffsA[filter][0] +
554                   p->buf[delayA - 1] * p->coeffsA[filter][1] +
555                   p->buf[delayA - 2] * p->coeffsA[filter][2] +
556                   p->buf[delayA - 3] * p->coeffsA[filter][3];
557
558     /*  Apply a scaled first-order filter compression */
559     p->buf[delayB]     = p->filterA[filter ^ 1] - ((p->filterB[filter] * 31) >> 5);
560     p->buf[adaptB]     = APESIGN(p->buf[delayB]);
561     p->buf[delayB - 1] = p->buf[delayB] - p->buf[delayB - 1];
562     p->buf[adaptB - 1] = APESIGN(p->buf[delayB - 1]);
563     p->filterB[filter] = p->filterA[filter ^ 1];
564
565     predictionB = p->buf[delayB    ] * p->coeffsB[filter][0] +
566                   p->buf[delayB - 1] * p->coeffsB[filter][1] +
567                   p->buf[delayB - 2] * p->coeffsB[filter][2] +
568                   p->buf[delayB - 3] * p->coeffsB[filter][3] +
569                   p->buf[delayB - 4] * p->coeffsB[filter][4];
570
571     p->lastA[filter] = decoded + ((predictionA + (predictionB >> 1)) >> 10);
572     p->filterA[filter] = p->lastA[filter] + ((p->filterA[filter] * 31) >> 5);
573
574     if (!decoded) // no need updating filter coefficients
575         return p->filterA[filter];
576
577     if (decoded > 0) {
578         p->coeffsA[filter][0] -= p->buf[adaptA    ];
579         p->coeffsA[filter][1] -= p->buf[adaptA - 1];
580         p->coeffsA[filter][2] -= p->buf[adaptA - 2];
581         p->coeffsA[filter][3] -= p->buf[adaptA - 3];
582
583         p->coeffsB[filter][0] -= p->buf[adaptB    ];
584         p->coeffsB[filter][1] -= p->buf[adaptB - 1];
585         p->coeffsB[filter][2] -= p->buf[adaptB - 2];
586         p->coeffsB[filter][3] -= p->buf[adaptB - 3];
587         p->coeffsB[filter][4] -= p->buf[adaptB - 4];
588     } else {
589         p->coeffsA[filter][0] += p->buf[adaptA    ];
590         p->coeffsA[filter][1] += p->buf[adaptA - 1];
591         p->coeffsA[filter][2] += p->buf[adaptA - 2];
592         p->coeffsA[filter][3] += p->buf[adaptA - 3];
593
594         p->coeffsB[filter][0] += p->buf[adaptB    ];
595         p->coeffsB[filter][1] += p->buf[adaptB - 1];
596         p->coeffsB[filter][2] += p->buf[adaptB - 2];
597         p->coeffsB[filter][3] += p->buf[adaptB - 3];
598         p->coeffsB[filter][4] += p->buf[adaptB - 4];
599     }
600     return p->filterA[filter];
601 }
602
603 static void predictor_decode_stereo(APEContext * ctx, int count)
604 {
605     int32_t predictionA, predictionB;
606     APEPredictor *p = &ctx->predictor;
607     int32_t *decoded0 = ctx->decoded0;
608     int32_t *decoded1 = ctx->decoded1;
609
610     while (count--) {
611         /* Predictor Y */
612         predictionA = predictor_update_filter(p, *decoded0, 0, YDELAYA, YDELAYB, YADAPTCOEFFSA, YADAPTCOEFFSB);
613         predictionB = predictor_update_filter(p, *decoded1, 1, XDELAYA, XDELAYB, XADAPTCOEFFSA, XADAPTCOEFFSB);
614         *(decoded0++) = predictionA;
615         *(decoded1++) = predictionB;
616
617         /* Combined */
618         p->buf++;
619
620         /* Have we filled the history buffer? */
621         if (p->buf == p->historybuffer + HISTORY_SIZE) {
622             memmove(p->historybuffer, p->buf, PREDICTOR_SIZE * sizeof(int32_t));
623             p->buf = p->historybuffer;
624         }
625     }
626 }
627
628 static void predictor_decode_mono(APEContext * ctx, int count)
629 {
630     APEPredictor *p = &ctx->predictor;
631     int32_t *decoded0 = ctx->decoded0;
632     int32_t predictionA, currentA, A;
633
634     currentA = p->lastA[0];
635
636     while (count--) {
637         A = *decoded0;
638
639         p->buf[YDELAYA] = currentA;
640         p->buf[YDELAYA - 1] = p->buf[YDELAYA] - p->buf[YDELAYA - 1];
641
642         predictionA = p->buf[YDELAYA    ] * p->coeffsA[0][0] +
643                       p->buf[YDELAYA - 1] * p->coeffsA[0][1] +
644                       p->buf[YDELAYA - 2] * p->coeffsA[0][2] +
645                       p->buf[YDELAYA - 3] * p->coeffsA[0][3];
646
647         currentA = A + (predictionA >> 10);
648
649         p->buf[YADAPTCOEFFSA]     = APESIGN(p->buf[YDELAYA    ]);
650         p->buf[YADAPTCOEFFSA - 1] = APESIGN(p->buf[YDELAYA - 1]);
651
652         if (A > 0) {
653             p->coeffsA[0][0] -= p->buf[YADAPTCOEFFSA    ];
654             p->coeffsA[0][1] -= p->buf[YADAPTCOEFFSA - 1];
655             p->coeffsA[0][2] -= p->buf[YADAPTCOEFFSA - 2];
656             p->coeffsA[0][3] -= p->buf[YADAPTCOEFFSA - 3];
657         } else if (A < 0) {
658             p->coeffsA[0][0] += p->buf[YADAPTCOEFFSA    ];
659             p->coeffsA[0][1] += p->buf[YADAPTCOEFFSA - 1];
660             p->coeffsA[0][2] += p->buf[YADAPTCOEFFSA - 2];
661             p->coeffsA[0][3] += p->buf[YADAPTCOEFFSA - 3];
662         }
663
664         p->buf++;
665
666         /* Have we filled the history buffer? */
667         if (p->buf == p->historybuffer + HISTORY_SIZE) {
668             memmove(p->historybuffer, p->buf, PREDICTOR_SIZE * sizeof(int32_t));
669             p->buf = p->historybuffer;
670         }
671
672         p->filterA[0] = currentA + ((p->filterA[0] * 31) >> 5);
673         *(decoded0++) = p->filterA[0];
674     }
675
676     p->lastA[0] = currentA;
677 }
678
679 static void do_init_filter(APEFilter *f, int16_t * buf, int order)
680 {
681     f->coeffs = buf;
682     f->historybuffer = buf + order;
683     f->delay       = f->historybuffer + order * 2;
684     f->adaptcoeffs = f->historybuffer + order;
685
686     memset(f->historybuffer, 0, (order * 2) * sizeof(int16_t));
687     memset(f->coeffs, 0, order * sizeof(int16_t));
688     f->avg = 0;
689 }
690
691 static void init_filter(APEContext * ctx, APEFilter *f, int16_t * buf, int order)
692 {
693     do_init_filter(&f[0], buf, order);
694     do_init_filter(&f[1], buf + order * 3 + HISTORY_SIZE, order);
695 }
696
697 static inline void do_apply_filter(int version, APEFilter *f, int32_t *data, int count, int order, int fracbits)
698 {
699     int res;
700     int absres;
701
702     while (count--) {
703         /* round fixedpoint scalar product */
704         res = (scalarproduct(f->delay - order, f->coeffs, order) + (1 << (fracbits - 1))) >> fracbits;
705
706         if (*data < 0)
707             vector_add(f->coeffs, f->adaptcoeffs - order, order);
708         else if (*data > 0)
709             vector_sub(f->coeffs, f->adaptcoeffs - order, order);
710
711         res += *data;
712
713         *data++ = res;
714
715         /* Update the output history */
716         *f->delay++ = av_clip_int16(res);
717
718         if (version < 3980) {
719             /* Version ??? to < 3.98 files (untested) */
720             f->adaptcoeffs[0]  = (res == 0) ? 0 : ((res >> 28) & 8) - 4;
721             f->adaptcoeffs[-4] >>= 1;
722             f->adaptcoeffs[-8] >>= 1;
723         } else {
724             /* Version 3.98 and later files */
725
726             /* Update the adaption coefficients */
727             absres = (res < 0 ? -res : res);
728
729             if (absres > (f->avg * 3))
730                 *f->adaptcoeffs = ((res >> 25) & 64) - 32;
731             else if (absres > (f->avg * 4) / 3)
732                 *f->adaptcoeffs = ((res >> 26) & 32) - 16;
733             else if (absres > 0)
734                 *f->adaptcoeffs = ((res >> 27) & 16) - 8;
735             else
736                 *f->adaptcoeffs = 0;
737
738             f->avg += (absres - f->avg) / 16;
739
740             f->adaptcoeffs[-1] >>= 1;
741             f->adaptcoeffs[-2] >>= 1;
742             f->adaptcoeffs[-8] >>= 1;
743         }
744
745         f->adaptcoeffs++;
746
747         /* Have we filled the history buffer? */
748         if (f->delay == f->historybuffer + HISTORY_SIZE + (order * 2)) {
749             memmove(f->historybuffer, f->delay - (order * 2),
750                     (order * 2) * sizeof(int16_t));
751             f->delay = f->historybuffer + order * 2;
752             f->adaptcoeffs = f->historybuffer + order;
753         }
754     }
755 }
756
757 static void apply_filter(APEContext * ctx, APEFilter *f,
758                          int32_t * data0, int32_t * data1,
759                          int count, int order, int fracbits)
760 {
761     do_apply_filter(ctx->fileversion, &f[0], data0, count, order, fracbits);
762     if (data1)
763         do_apply_filter(ctx->fileversion, &f[1], data1, count, order, fracbits);
764 }
765
766 static void ape_apply_filters(APEContext * ctx, int32_t * decoded0,
767                               int32_t * decoded1, int count)
768 {
769     int i;
770
771     for (i = 0; i < APE_FILTER_LEVELS; i++) {
772         if (!ape_filter_orders[ctx->fset][i])
773             break;
774         apply_filter(ctx, ctx->filters[i], decoded0, decoded1, count, ape_filter_orders[ctx->fset][i], ape_filter_fracbits[ctx->fset][i]);
775     }
776 }
777
778 static void init_frame_decoder(APEContext * ctx)
779 {
780     int i;
781     init_entropy_decoder(ctx);
782     init_predictor_decoder(ctx);
783
784     for (i = 0; i < APE_FILTER_LEVELS; i++) {
785         if (!ape_filter_orders[ctx->fset][i])
786             break;
787         init_filter(ctx, ctx->filters[i], ctx->filterbuf[i], ape_filter_orders[ctx->fset][i]);
788     }
789 }
790
791 static void ape_unpack_mono(APEContext * ctx, int count)
792 {
793     int32_t left;
794     int32_t *decoded0 = ctx->decoded0;
795     int32_t *decoded1 = ctx->decoded1;
796
797     if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {
798         entropy_decode(ctx, count, 0);
799         /* We are pure silence, so we're done. */
800         av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence mono\n");
801         return;
802     }
803
804     entropy_decode(ctx, count, 0);
805     ape_apply_filters(ctx, decoded0, NULL, count);
806
807     /* Now apply the predictor decoding */
808     predictor_decode_mono(ctx, count);
809
810     /* Pseudo-stereo - just copy left channel to right channel */
811     if (ctx->channels == 2) {
812         while (count--) {
813             left = *decoded0;
814             *(decoded1++) = *(decoded0++) = left;
815         }
816     }
817 }
818
819 static void ape_unpack_stereo(APEContext * ctx, int count)
820 {
821     int32_t left, right;
822     int32_t *decoded0 = ctx->decoded0;
823     int32_t *decoded1 = ctx->decoded1;
824
825     if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {
826         /* We are pure silence, so we're done. */
827         av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence stereo\n");
828         return;
829     }
830
831     entropy_decode(ctx, count, 1);
832     ape_apply_filters(ctx, decoded0, decoded1, count);
833
834     /* Now apply the predictor decoding */
835     predictor_decode_stereo(ctx, count);
836
837     /* Decorrelate and scale to output depth */
838     while (count--) {
839         left = *decoded1 - (*decoded0 / 2);
840         right = left + *decoded0;
841
842         *(decoded0++) = left;
843         *(decoded1++) = right;
844     }
845 }
846
847 static int ape_decode_frame(AVCodecContext * avctx,
848                             void *data, int *data_size,
849                             const uint8_t * buf, int buf_size)
850 {
851     APEContext *s = avctx->priv_data;
852     int16_t *samples = data;
853     int nblocks;
854     int i, n;
855     int blockstodecode;
856     int bytes_used;
857
858     if (buf_size == 0 && !s->samples) {
859         *data_size = 0;
860         return 0;
861     }
862
863     /* should not happen but who knows */
864     if (BLOCKS_PER_LOOP * 2 * avctx->channels > *data_size) {
865         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);
866         return -1;
867     }
868
869     if(!s->samples){
870         s->data = av_realloc(s->data, (buf_size + 3) & ~3);
871         s->dsp.bswap_buf((uint32_t*)s->data, (const uint32_t*)buf, buf_size >> 2);
872         s->ptr = s->last_ptr = s->data;
873         s->data_end = s->data + buf_size;
874
875         nblocks = s->samples = bytestream_get_be32(&s->ptr);
876         n =  bytestream_get_be32(&s->ptr);
877         if(n < 0 || n > 3){
878             av_log(avctx, AV_LOG_ERROR, "Incorrect offset passed\n");
879             s->data = NULL;
880             return -1;
881         }
882         s->ptr += n;
883
884         s->currentframeblocks = nblocks;
885         buf += 4;
886         if (s->samples <= 0) {
887             *data_size = 0;
888             return buf_size;
889         }
890
891         memset(s->decoded0,  0, sizeof(s->decoded0));
892         memset(s->decoded1,  0, sizeof(s->decoded1));
893
894         /* Initialize the frame decoder */
895         init_frame_decoder(s);
896     }
897
898     if (!s->data) {
899         *data_size = 0;
900         return buf_size;
901     }
902
903     nblocks = s->samples;
904     blockstodecode = FFMIN(BLOCKS_PER_LOOP, nblocks);
905
906     s->error=0;
907
908     if ((s->channels == 1) || (s->frameflags & APE_FRAMECODE_PSEUDO_STEREO))
909         ape_unpack_mono(s, blockstodecode);
910     else
911         ape_unpack_stereo(s, blockstodecode);
912
913     if(s->error || s->ptr > s->data_end){
914         s->samples=0;
915         av_log(avctx, AV_LOG_ERROR, "Error decoding frame\n");
916         return -1;
917     }
918
919     for (i = 0; i < blockstodecode; i++) {
920         *samples++ = s->decoded0[i];
921         if(s->channels == 2)
922             *samples++ = s->decoded1[i];
923     }
924
925     s->samples -= blockstodecode;
926
927     *data_size = blockstodecode * 2 * s->channels;
928     bytes_used = s->samples ? s->ptr - s->last_ptr : buf_size;
929     s->last_ptr = s->ptr;
930     return bytes_used;
931 }
932
933 AVCodec ape_decoder = {
934     "ape",
935     CODEC_TYPE_AUDIO,
936     CODEC_ID_APE,
937     sizeof(APEContext),
938     ape_decode_init,
939     NULL,
940     ape_decode_close,
941     ape_decode_frame,
942 };