FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
apedec.c
Go to the documentation of this file.
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"
27 #include "libavutil/opt.h"
28 #include "lossless_audiodsp.h"
29 #include "avcodec.h"
30 #include "bswapdsp.h"
31 #include "bytestream.h"
32 #include "internal.h"
33 #include "get_bits.h"
34 #include "unary.h"
35 
36 /**
37  * @file
38  * Monkey's Audio lossless audio decoder
39  */
40 
41 #define MAX_CHANNELS 2
42 #define MAX_BYTESPERSAMPLE 3
43 
44 #define APE_FRAMECODE_MONO_SILENCE 1
45 #define APE_FRAMECODE_STEREO_SILENCE 3
46 #define APE_FRAMECODE_PSEUDO_STEREO 4
47 
48 #define HISTORY_SIZE 512
49 #define PREDICTOR_ORDER 8
50 /** Total size of all predictor histories */
51 #define PREDICTOR_SIZE 50
52 
53 #define YDELAYA (18 + PREDICTOR_ORDER*4)
54 #define YDELAYB (18 + PREDICTOR_ORDER*3)
55 #define XDELAYA (18 + PREDICTOR_ORDER*2)
56 #define XDELAYB (18 + PREDICTOR_ORDER)
57 
58 #define YADAPTCOEFFSA 18
59 #define XADAPTCOEFFSA 14
60 #define YADAPTCOEFFSB 10
61 #define XADAPTCOEFFSB 5
62 
63 /**
64  * Possible compression levels
65  * @{
66  */
73 };
74 /** @} */
75 
76 #define APE_FILTER_LEVELS 3
77 
78 /** Filter orders depending on compression level */
79 static const uint16_t ape_filter_orders[5][APE_FILTER_LEVELS] = {
80  { 0, 0, 0 },
81  { 16, 0, 0 },
82  { 64, 0, 0 },
83  { 32, 256, 0 },
84  { 16, 256, 1280 }
85 };
86 
87 /** Filter fraction bits depending on compression level */
89  { 0, 0, 0 },
90  { 11, 0, 0 },
91  { 11, 0, 0 },
92  { 10, 13, 0 },
93  { 11, 13, 15 }
94 };
95 
96 
97 /** Filters applied to the decoded data */
98 typedef struct APEFilter {
99  int16_t *coeffs; ///< actual coefficients used in filtering
100  int16_t *adaptcoeffs; ///< adaptive filter coefficients used for correcting of actual filter coefficients
101  int16_t *historybuffer; ///< filter memory
102  int16_t *delay; ///< filtered values
103 
104  int avg;
105 } APEFilter;
106 
107 typedef struct APERice {
108  uint32_t k;
109  uint32_t ksum;
110 } APERice;
111 
112 typedef struct APERangecoder {
113  uint32_t low; ///< low end of interval
114  uint32_t range; ///< length of interval
115  uint32_t help; ///< bytes_to_follow resp. intermediate value
116  unsigned int buffer; ///< buffer for input/output
117 } APERangecoder;
118 
119 /** Filter histories */
120 typedef struct APEPredictor {
122 
124 
127 
128  int32_t coeffsA[2][4]; ///< adaption coefficients
129  int32_t coeffsB[2][5]; ///< adaption coefficients
131 
132  unsigned int sample_pos;
133 } APEPredictor;
134 
135 /** Decoder context */
136 typedef struct APEContext {
137  AVClass *class; ///< class for AVOptions
141  int channels;
142  int samples; ///< samples left to decode in current frame
143  int bps;
144 
145  int fileversion; ///< codec version, very important in decoding process
146  int compression_level; ///< compression levels
147  int fset; ///< which filter set to use (calculated from compression level)
148  int flags; ///< global decoder flags
149 
150  uint32_t CRC; ///< frame CRC
151  int frameflags; ///< frame flags
152  APEPredictor predictor; ///< predictor used for final reconstruction
153 
156  int32_t *decoded[MAX_CHANNELS]; ///< decoded data for each channel
157  int blocks_per_loop; ///< maximum number of samples to decode for each call
158 
159  int16_t* filterbuf[APE_FILTER_LEVELS]; ///< filter memory
160 
161  APERangecoder rc; ///< rangecoder used to decode actual values
162  APERice riceX; ///< rice code parameters for the second channel
163  APERice riceY; ///< rice code parameters for the first channel
164  APEFilter filters[APE_FILTER_LEVELS][2]; ///< filters used for reconstruction
166 
167  uint8_t *data; ///< current frame data
168  uint8_t *data_end; ///< frame data end
169  int data_size; ///< frame data allocated size
170  const uint8_t *ptr; ///< current position in frame data
171 
172  int error;
173 
174  void (*entropy_decode_mono)(struct APEContext *ctx, int blockstodecode);
175  void (*entropy_decode_stereo)(struct APEContext *ctx, int blockstodecode);
178 } APEContext;
179 
180 static void ape_apply_filters(APEContext *ctx, int32_t *decoded0,
181  int32_t *decoded1, int count);
182 
183 static void entropy_decode_mono_0000(APEContext *ctx, int blockstodecode);
184 static void entropy_decode_stereo_0000(APEContext *ctx, int blockstodecode);
185 static void entropy_decode_mono_3860(APEContext *ctx, int blockstodecode);
186 static void entropy_decode_stereo_3860(APEContext *ctx, int blockstodecode);
187 static void entropy_decode_mono_3900(APEContext *ctx, int blockstodecode);
188 static void entropy_decode_stereo_3900(APEContext *ctx, int blockstodecode);
189 static void entropy_decode_stereo_3930(APEContext *ctx, int blockstodecode);
190 static void entropy_decode_mono_3990(APEContext *ctx, int blockstodecode);
191 static void entropy_decode_stereo_3990(APEContext *ctx, int blockstodecode);
192 
193 static void predictor_decode_mono_3800(APEContext *ctx, int count);
194 static void predictor_decode_stereo_3800(APEContext *ctx, int count);
195 static void predictor_decode_mono_3930(APEContext *ctx, int count);
196 static void predictor_decode_stereo_3930(APEContext *ctx, int count);
197 static void predictor_decode_mono_3950(APEContext *ctx, int count);
198 static void predictor_decode_stereo_3950(APEContext *ctx, int count);
199 
201 {
202  APEContext *s = avctx->priv_data;
203  int i;
204 
205  for (i = 0; i < APE_FILTER_LEVELS; i++)
206  av_freep(&s->filterbuf[i]);
207 
209  av_freep(&s->data);
210  s->decoded_size = s->data_size = 0;
211 
212  return 0;
213 }
214 
216 {
217  APEContext *s = avctx->priv_data;
218  int i;
219 
220  if (avctx->extradata_size != 6) {
221  av_log(avctx, AV_LOG_ERROR, "Incorrect extradata\n");
222  return AVERROR(EINVAL);
223  }
224  if (avctx->channels > 2) {
225  av_log(avctx, AV_LOG_ERROR, "Only mono and stereo is supported\n");
226  return AVERROR(EINVAL);
227  }
228  s->bps = avctx->bits_per_coded_sample;
229  switch (s->bps) {
230  case 8:
231  avctx->sample_fmt = AV_SAMPLE_FMT_U8P;
232  break;
233  case 16:
235  break;
236  case 24:
238  break;
239  default:
240  avpriv_request_sample(avctx,
241  "%d bits per coded sample", s->bps);
242  return AVERROR_PATCHWELCOME;
243  }
244  s->avctx = avctx;
245  s->channels = avctx->channels;
246  s->fileversion = AV_RL16(avctx->extradata);
247  s->compression_level = AV_RL16(avctx->extradata + 2);
248  s->flags = AV_RL16(avctx->extradata + 4);
249 
250  av_log(avctx, AV_LOG_DEBUG, "Compression Level: %d - Flags: %d\n",
251  s->compression_level, s->flags);
253  !s->compression_level ||
255  av_log(avctx, AV_LOG_ERROR, "Incorrect compression level %d\n",
256  s->compression_level);
257  return AVERROR_INVALIDDATA;
258  }
259  s->fset = s->compression_level / 1000 - 1;
260  for (i = 0; i < APE_FILTER_LEVELS; i++) {
261  if (!ape_filter_orders[s->fset][i])
262  break;
263  FF_ALLOC_OR_GOTO(avctx, s->filterbuf[i],
264  (ape_filter_orders[s->fset][i] * 3 + HISTORY_SIZE) * 4,
265  filter_alloc_fail);
266  }
267 
268  if (s->fileversion < 3860) {
271  } else if (s->fileversion < 3900) {
274  } else if (s->fileversion < 3930) {
277  } else if (s->fileversion < 3990) {
280  } else {
283  }
284 
285  if (s->fileversion < 3930) {
288  } else if (s->fileversion < 3950) {
291  } else {
294  }
295 
296  ff_bswapdsp_init(&s->bdsp);
297  ff_llauddsp_init(&s->adsp);
299 
300  return 0;
301 filter_alloc_fail:
302  ape_decode_close(avctx);
303  return AVERROR(ENOMEM);
304 }
305 
306 /**
307  * @name APE range decoding functions
308  * @{
309  */
310 
311 #define CODE_BITS 32
312 #define TOP_VALUE ((unsigned int)1 << (CODE_BITS-1))
313 #define SHIFT_BITS (CODE_BITS - 9)
314 #define EXTRA_BITS ((CODE_BITS-2) % 8 + 1)
315 #define BOTTOM_VALUE (TOP_VALUE >> 8)
316 
317 /** Start the decoder */
318 static inline void range_start_decoding(APEContext *ctx)
319 {
320  ctx->rc.buffer = bytestream_get_byte(&ctx->ptr);
321  ctx->rc.low = ctx->rc.buffer >> (8 - EXTRA_BITS);
322  ctx->rc.range = (uint32_t) 1 << EXTRA_BITS;
323 }
324 
325 /** Perform normalization */
326 static inline void range_dec_normalize(APEContext *ctx)
327 {
328  while (ctx->rc.range <= BOTTOM_VALUE) {
329  ctx->rc.buffer <<= 8;
330  if(ctx->ptr < ctx->data_end) {
331  ctx->rc.buffer += *ctx->ptr;
332  ctx->ptr++;
333  } else {
334  ctx->error = 1;
335  }
336  ctx->rc.low = (ctx->rc.low << 8) | ((ctx->rc.buffer >> 1) & 0xFF);
337  ctx->rc.range <<= 8;
338  }
339 }
340 
341 /**
342  * Calculate culmulative frequency for next symbol. Does NO update!
343  * @param ctx decoder context
344  * @param tot_f is the total frequency or (code_value)1<<shift
345  * @return the culmulative frequency
346  */
347 static inline int range_decode_culfreq(APEContext *ctx, int tot_f)
348 {
349  range_dec_normalize(ctx);
350  ctx->rc.help = ctx->rc.range / tot_f;
351  return ctx->rc.low / ctx->rc.help;
352 }
353 
354 /**
355  * Decode value with given size in bits
356  * @param ctx decoder context
357  * @param shift number of bits to decode
358  */
359 static inline int range_decode_culshift(APEContext *ctx, int shift)
360 {
361  range_dec_normalize(ctx);
362  ctx->rc.help = ctx->rc.range >> shift;
363  return ctx->rc.low / ctx->rc.help;
364 }
365 
366 
367 /**
368  * Update decoding state
369  * @param ctx decoder context
370  * @param sy_f the interval length (frequency of the symbol)
371  * @param lt_f the lower end (frequency sum of < symbols)
372  */
373 static inline void range_decode_update(APEContext *ctx, int sy_f, int lt_f)
374 {
375  ctx->rc.low -= ctx->rc.help * lt_f;
376  ctx->rc.range = ctx->rc.help * sy_f;
377 }
378 
379 /** Decode n bits (n <= 16) without modelling */
380 static inline int range_decode_bits(APEContext *ctx, int n)
381 {
382  int sym = range_decode_culshift(ctx, n);
383  range_decode_update(ctx, 1, sym);
384  return sym;
385 }
386 
387 
388 #define MODEL_ELEMENTS 64
389 
390 /**
391  * Fixed probabilities for symbols in Monkey Audio version 3.97
392  */
393 static const uint16_t counts_3970[22] = {
394  0, 14824, 28224, 39348, 47855, 53994, 58171, 60926,
395  62682, 63786, 64463, 64878, 65126, 65276, 65365, 65419,
396  65450, 65469, 65480, 65487, 65491, 65493,
397 };
398 
399 /**
400  * Probability ranges for symbols in Monkey Audio version 3.97
401  */
402 static const uint16_t counts_diff_3970[21] = {
403  14824, 13400, 11124, 8507, 6139, 4177, 2755, 1756,
404  1104, 677, 415, 248, 150, 89, 54, 31,
405  19, 11, 7, 4, 2,
406 };
407 
408 /**
409  * Fixed probabilities for symbols in Monkey Audio version 3.98
410  */
411 static const uint16_t counts_3980[22] = {
412  0, 19578, 36160, 48417, 56323, 60899, 63265, 64435,
413  64971, 65232, 65351, 65416, 65447, 65466, 65476, 65482,
414  65485, 65488, 65490, 65491, 65492, 65493,
415 };
416 
417 /**
418  * Probability ranges for symbols in Monkey Audio version 3.98
419  */
420 static const uint16_t counts_diff_3980[21] = {
421  19578, 16582, 12257, 7906, 4576, 2366, 1170, 536,
422  261, 119, 65, 31, 19, 10, 6, 3,
423  3, 2, 1, 1, 1,
424 };
425 
426 /**
427  * Decode symbol
428  * @param ctx decoder context
429  * @param counts probability range start position
430  * @param counts_diff probability range widths
431  */
432 static inline int range_get_symbol(APEContext *ctx,
433  const uint16_t counts[],
434  const uint16_t counts_diff[])
435 {
436  int symbol, cf;
437 
438  cf = range_decode_culshift(ctx, 16);
439 
440  if(cf > 65492){
441  symbol= cf - 65535 + 63;
442  range_decode_update(ctx, 1, cf);
443  if(cf > 65535)
444  ctx->error=1;
445  return symbol;
446  }
447  /* figure out the symbol inefficiently; a binary search would be much better */
448  for (symbol = 0; counts[symbol + 1] <= cf; symbol++);
449 
450  range_decode_update(ctx, counts_diff[symbol], counts[symbol]);
451 
452  return symbol;
453 }
454 /** @} */ // group rangecoder
455 
456 static inline void update_rice(APERice *rice, unsigned int x)
457 {
458  int lim = rice->k ? (1 << (rice->k + 4)) : 0;
459  rice->ksum += ((x + 1) / 2) - ((rice->ksum + 16) >> 5);
460 
461  if (rice->ksum < lim)
462  rice->k--;
463  else if (rice->ksum >= (1 << (rice->k + 5)))
464  rice->k++;
465 }
466 
467 static inline int get_rice_ook(GetBitContext *gb, int k)
468 {
469  unsigned int x;
470 
471  x = get_unary(gb, 1, get_bits_left(gb));
472 
473  if (k)
474  x = (x << k) | get_bits(gb, k);
475 
476  return x;
477 }
478 
480  APERice *rice)
481 {
482  unsigned int x, overflow;
483 
484  overflow = get_unary(gb, 1, get_bits_left(gb));
485 
486  if (ctx->fileversion > 3880) {
487  while (overflow >= 16) {
488  overflow -= 16;
489  rice->k += 4;
490  }
491  }
492 
493  if (!rice->k)
494  x = overflow;
495  else if(rice->k <= MIN_CACHE_BITS) {
496  x = (overflow << rice->k) + get_bits(gb, rice->k);
497  } else {
498  av_log(ctx->avctx, AV_LOG_ERROR, "Too many bits: %d\n", rice->k);
499  return AVERROR_INVALIDDATA;
500  }
501  rice->ksum += x - (rice->ksum + 8 >> 4);
502  if (rice->ksum < (rice->k ? 1 << (rice->k + 4) : 0))
503  rice->k--;
504  else if (rice->ksum >= (1 << (rice->k + 5)) && rice->k < 24)
505  rice->k++;
506 
507  /* Convert to signed */
508  if (x & 1)
509  return (x >> 1) + 1;
510  else
511  return -(x >> 1);
512 }
513 
514 static inline int ape_decode_value_3900(APEContext *ctx, APERice *rice)
515 {
516  unsigned int x, overflow;
517  int tmpk;
518 
520 
521  if (overflow == (MODEL_ELEMENTS - 1)) {
522  tmpk = range_decode_bits(ctx, 5);
523  overflow = 0;
524  } else
525  tmpk = (rice->k < 1) ? 0 : rice->k - 1;
526 
527  if (tmpk <= 16 || ctx->fileversion < 3910) {
528  if (tmpk > 23) {
529  av_log(ctx->avctx, AV_LOG_ERROR, "Too many bits: %d\n", tmpk);
530  return AVERROR_INVALIDDATA;
531  }
532  x = range_decode_bits(ctx, tmpk);
533  } else if (tmpk <= 31) {
534  x = range_decode_bits(ctx, 16);
535  x |= (range_decode_bits(ctx, tmpk - 16) << 16);
536  } else {
537  av_log(ctx->avctx, AV_LOG_ERROR, "Too many bits: %d\n", tmpk);
538  return AVERROR_INVALIDDATA;
539  }
540  x += overflow << tmpk;
541 
542  update_rice(rice, x);
543 
544  /* Convert to signed */
545  if (x & 1)
546  return (x >> 1) + 1;
547  else
548  return -(x >> 1);
549 }
550 
551 static inline int ape_decode_value_3990(APEContext *ctx, APERice *rice)
552 {
553  unsigned int x, overflow;
554  int base, pivot;
555 
556  pivot = rice->ksum >> 5;
557  if (pivot == 0)
558  pivot = 1;
559 
561 
562  if (overflow == (MODEL_ELEMENTS - 1)) {
563  overflow = range_decode_bits(ctx, 16) << 16;
564  overflow |= range_decode_bits(ctx, 16);
565  }
566 
567  if (pivot < 0x10000) {
568  base = range_decode_culfreq(ctx, pivot);
569  range_decode_update(ctx, 1, base);
570  } else {
571  int base_hi = pivot, base_lo;
572  int bbits = 0;
573 
574  while (base_hi & ~0xFFFF) {
575  base_hi >>= 1;
576  bbits++;
577  }
578  base_hi = range_decode_culfreq(ctx, base_hi + 1);
579  range_decode_update(ctx, 1, base_hi);
580  base_lo = range_decode_culfreq(ctx, 1 << bbits);
581  range_decode_update(ctx, 1, base_lo);
582 
583  base = (base_hi << bbits) + base_lo;
584  }
585 
586  x = base + overflow * pivot;
587 
588  update_rice(rice, x);
589 
590  /* Convert to signed */
591  if (x & 1)
592  return (x >> 1) + 1;
593  else
594  return -(x >> 1);
595 }
596 
598  int32_t *out, APERice *rice, int blockstodecode)
599 {
600  int i;
601  int ksummax, ksummin;
602 
603  rice->ksum = 0;
604  for (i = 0; i < 5; i++) {
605  out[i] = get_rice_ook(&ctx->gb, 10);
606  rice->ksum += out[i];
607  }
608  rice->k = av_log2(rice->ksum / 10) + 1;
609  if (rice->k >= 24)
610  return;
611  for (; i < 64; i++) {
612  out[i] = get_rice_ook(&ctx->gb, rice->k);
613  rice->ksum += out[i];
614  rice->k = av_log2(rice->ksum / ((i + 1) * 2)) + 1;
615  if (rice->k >= 24)
616  return;
617  }
618  ksummax = 1 << rice->k + 7;
619  ksummin = rice->k ? (1 << rice->k + 6) : 0;
620  for (; i < blockstodecode; i++) {
621  out[i] = get_rice_ook(&ctx->gb, rice->k);
622  rice->ksum += out[i] - out[i - 64];
623  while (rice->ksum < ksummin) {
624  rice->k--;
625  ksummin = rice->k ? ksummin >> 1 : 0;
626  ksummax >>= 1;
627  }
628  while (rice->ksum >= ksummax) {
629  rice->k++;
630  if (rice->k > 24)
631  return;
632  ksummax <<= 1;
633  ksummin = ksummin ? ksummin << 1 : 128;
634  }
635  }
636 
637  for (i = 0; i < blockstodecode; i++) {
638  if (out[i] & 1)
639  out[i] = (out[i] >> 1) + 1;
640  else
641  out[i] = -(out[i] >> 1);
642  }
643 }
644 
645 static void entropy_decode_mono_0000(APEContext *ctx, int blockstodecode)
646 {
647  decode_array_0000(ctx, &ctx->gb, ctx->decoded[0], &ctx->riceY,
648  blockstodecode);
649 }
650 
651 static void entropy_decode_stereo_0000(APEContext *ctx, int blockstodecode)
652 {
653  decode_array_0000(ctx, &ctx->gb, ctx->decoded[0], &ctx->riceY,
654  blockstodecode);
655  decode_array_0000(ctx, &ctx->gb, ctx->decoded[1], &ctx->riceX,
656  blockstodecode);
657 }
658 
659 static void entropy_decode_mono_3860(APEContext *ctx, int blockstodecode)
660 {
661  int32_t *decoded0 = ctx->decoded[0];
662 
663  while (blockstodecode--)
664  *decoded0++ = ape_decode_value_3860(ctx, &ctx->gb, &ctx->riceY);
665 }
666 
667 static void entropy_decode_stereo_3860(APEContext *ctx, int blockstodecode)
668 {
669  int32_t *decoded0 = ctx->decoded[0];
670  int32_t *decoded1 = ctx->decoded[1];
671  int blocks = blockstodecode;
672 
673  while (blockstodecode--)
674  *decoded0++ = ape_decode_value_3860(ctx, &ctx->gb, &ctx->riceY);
675  while (blocks--)
676  *decoded1++ = ape_decode_value_3860(ctx, &ctx->gb, &ctx->riceX);
677 }
678 
679 static void entropy_decode_mono_3900(APEContext *ctx, int blockstodecode)
680 {
681  int32_t *decoded0 = ctx->decoded[0];
682 
683  while (blockstodecode--)
684  *decoded0++ = ape_decode_value_3900(ctx, &ctx->riceY);
685 }
686 
687 static void entropy_decode_stereo_3900(APEContext *ctx, int blockstodecode)
688 {
689  int32_t *decoded0 = ctx->decoded[0];
690  int32_t *decoded1 = ctx->decoded[1];
691  int blocks = blockstodecode;
692 
693  while (blockstodecode--)
694  *decoded0++ = ape_decode_value_3900(ctx, &ctx->riceY);
695  range_dec_normalize(ctx);
696  // because of some implementation peculiarities we need to backpedal here
697  ctx->ptr -= 1;
699  while (blocks--)
700  *decoded1++ = ape_decode_value_3900(ctx, &ctx->riceX);
701 }
702 
703 static void entropy_decode_stereo_3930(APEContext *ctx, int blockstodecode)
704 {
705  int32_t *decoded0 = ctx->decoded[0];
706  int32_t *decoded1 = ctx->decoded[1];
707 
708  while (blockstodecode--) {
709  *decoded0++ = ape_decode_value_3900(ctx, &ctx->riceY);
710  *decoded1++ = ape_decode_value_3900(ctx, &ctx->riceX);
711  }
712 }
713 
714 static void entropy_decode_mono_3990(APEContext *ctx, int blockstodecode)
715 {
716  int32_t *decoded0 = ctx->decoded[0];
717 
718  while (blockstodecode--)
719  *decoded0++ = ape_decode_value_3990(ctx, &ctx->riceY);
720 }
721 
722 static void entropy_decode_stereo_3990(APEContext *ctx, int blockstodecode)
723 {
724  int32_t *decoded0 = ctx->decoded[0];
725  int32_t *decoded1 = ctx->decoded[1];
726 
727  while (blockstodecode--) {
728  *decoded0++ = ape_decode_value_3990(ctx, &ctx->riceY);
729  *decoded1++ = ape_decode_value_3990(ctx, &ctx->riceX);
730  }
731 }
732 
734 {
735  /* Read the CRC */
736  if (ctx->fileversion >= 3900) {
737  if (ctx->data_end - ctx->ptr < 6)
738  return AVERROR_INVALIDDATA;
739  ctx->CRC = bytestream_get_be32(&ctx->ptr);
740  } else {
741  ctx->CRC = get_bits_long(&ctx->gb, 32);
742  }
743 
744  /* Read the frame flags if they exist */
745  ctx->frameflags = 0;
746  if ((ctx->fileversion > 3820) && (ctx->CRC & 0x80000000)) {
747  ctx->CRC &= ~0x80000000;
748 
749  if (ctx->data_end - ctx->ptr < 6)
750  return AVERROR_INVALIDDATA;
751  ctx->frameflags = bytestream_get_be32(&ctx->ptr);
752  }
753 
754  /* Initialize the rice structs */
755  ctx->riceX.k = 10;
756  ctx->riceX.ksum = (1 << ctx->riceX.k) * 16;
757  ctx->riceY.k = 10;
758  ctx->riceY.ksum = (1 << ctx->riceY.k) * 16;
759 
760  if (ctx->fileversion >= 3900) {
761  /* The first 8 bits of input are ignored. */
762  ctx->ptr++;
763 
765  }
766 
767  return 0;
768 }
769 
771  375,
772 };
773 
774 static const int32_t initial_coeffs_a_3800[3] = {
775  64, 115, 64,
776 };
777 
778 static const int32_t initial_coeffs_b_3800[2] = {
779  740, 0
780 };
781 
782 static const int32_t initial_coeffs_3930[4] = {
783  360, 317, -109, 98
784 };
785 
787 {
788  APEPredictor *p = &ctx->predictor;
789 
790  /* Zero the history buffers */
791  memset(p->historybuffer, 0, PREDICTOR_SIZE * sizeof(*p->historybuffer));
792  p->buf = p->historybuffer;
793 
794  /* Initialize and zero the coefficients */
795  if (ctx->fileversion < 3930) {
797  memcpy(p->coeffsA[0], initial_coeffs_fast_3320,
798  sizeof(initial_coeffs_fast_3320));
799  memcpy(p->coeffsA[1], initial_coeffs_fast_3320,
800  sizeof(initial_coeffs_fast_3320));
801  } else {
802  memcpy(p->coeffsA[0], initial_coeffs_a_3800,
803  sizeof(initial_coeffs_a_3800));
804  memcpy(p->coeffsA[1], initial_coeffs_a_3800,
805  sizeof(initial_coeffs_a_3800));
806  }
807  } else {
808  memcpy(p->coeffsA[0], initial_coeffs_3930, sizeof(initial_coeffs_3930));
809  memcpy(p->coeffsA[1], initial_coeffs_3930, sizeof(initial_coeffs_3930));
810  }
811  memset(p->coeffsB, 0, sizeof(p->coeffsB));
812  if (ctx->fileversion < 3930) {
813  memcpy(p->coeffsB[0], initial_coeffs_b_3800,
814  sizeof(initial_coeffs_b_3800));
815  memcpy(p->coeffsB[1], initial_coeffs_b_3800,
816  sizeof(initial_coeffs_b_3800));
817  }
818 
819  p->filterA[0] = p->filterA[1] = 0;
820  p->filterB[0] = p->filterB[1] = 0;
821  p->lastA[0] = p->lastA[1] = 0;
822 
823  p->sample_pos = 0;
824 }
825 
826 /** Get inverse sign of integer (-1 for positive, 1 for negative and 0 for zero) */
827 static inline int APESIGN(int32_t x) {
828  return (x < 0) - (x > 0);
829 }
830 
832  const int decoded, const int filter,
833  const int delayA)
834 {
835  int32_t predictionA;
836 
837  p->buf[delayA] = p->lastA[filter];
838  if (p->sample_pos < 3) {
839  p->lastA[filter] = decoded;
840  p->filterA[filter] = decoded;
841  return decoded;
842  }
843 
844  predictionA = p->buf[delayA] * 2 - p->buf[delayA - 1];
845  p->lastA[filter] = decoded + (predictionA * p->coeffsA[filter][0] >> 9);
846 
847  if ((decoded ^ predictionA) > 0)
848  p->coeffsA[filter][0]++;
849  else
850  p->coeffsA[filter][0]--;
851 
852  p->filterA[filter] += p->lastA[filter];
853 
854  return p->filterA[filter];
855 }
856 
858  const int decoded, const int filter,
859  const int delayA, const int delayB,
860  const int start, const int shift)
861 {
862  int32_t predictionA, predictionB, sign;
863  int32_t d0, d1, d2, d3, d4;
864 
865  p->buf[delayA] = p->lastA[filter];
866  p->buf[delayB] = p->filterB[filter];
867  if (p->sample_pos < start) {
868  predictionA = decoded + p->filterA[filter];
869  p->lastA[filter] = decoded;
870  p->filterB[filter] = decoded;
871  p->filterA[filter] = predictionA;
872  return predictionA;
873  }
874  d2 = p->buf[delayA];
875  d1 = (p->buf[delayA] - p->buf[delayA - 1]) << 1;
876  d0 = p->buf[delayA] + ((p->buf[delayA - 2] - p->buf[delayA - 1]) << 3);
877  d3 = p->buf[delayB] * 2 - p->buf[delayB - 1];
878  d4 = p->buf[delayB];
879 
880  predictionA = d0 * p->coeffsA[filter][0] +
881  d1 * p->coeffsA[filter][1] +
882  d2 * p->coeffsA[filter][2];
883 
884  sign = APESIGN(decoded);
885  p->coeffsA[filter][0] += (((d0 >> 30) & 2) - 1) * sign;
886  p->coeffsA[filter][1] += (((d1 >> 28) & 8) - 4) * sign;
887  p->coeffsA[filter][2] += (((d2 >> 28) & 8) - 4) * sign;
888 
889  predictionB = d3 * p->coeffsB[filter][0] -
890  d4 * p->coeffsB[filter][1];
891  p->lastA[filter] = decoded + (predictionA >> 11);
892  sign = APESIGN(p->lastA[filter]);
893  p->coeffsB[filter][0] += (((d3 >> 29) & 4) - 2) * sign;
894  p->coeffsB[filter][1] -= (((d4 >> 30) & 2) - 1) * sign;
895 
896  p->filterB[filter] = p->lastA[filter] + (predictionB >> shift);
897  p->filterA[filter] = p->filterB[filter] + ((p->filterA[filter] * 31) >> 5);
898 
899  return p->filterA[filter];
900 }
901 
902 static void long_filter_high_3800(int32_t *buffer, int order, int shift,
903  int32_t *coeffs, int32_t *delay, int length)
904 {
905  int i, j;
906  int32_t dotprod, sign;
907 
908  memset(coeffs, 0, order * sizeof(*coeffs));
909  for (i = 0; i < order; i++)
910  delay[i] = buffer[i];
911  for (i = order; i < length; i++) {
912  dotprod = 0;
913  sign = APESIGN(buffer[i]);
914  for (j = 0; j < order; j++) {
915  dotprod += delay[j] * coeffs[j];
916  coeffs[j] += ((delay[j] >> 31) | 1) * sign;
917  }
918  buffer[i] -= dotprod >> shift;
919  for (j = 0; j < order - 1; j++)
920  delay[j] = delay[j + 1];
921  delay[order - 1] = buffer[i];
922  }
923 }
924 
926 {
927  int i, j;
928  int32_t dotprod, sign;
929  int32_t coeffs[8] = { 0 }, delay[8] = { 0 };
930 
931  for (i = 0; i < length; i++) {
932  dotprod = 0;
933  sign = APESIGN(buffer[i]);
934  for (j = 7; j >= 0; j--) {
935  dotprod += delay[j] * coeffs[j];
936  coeffs[j] += ((delay[j] >> 31) | 1) * sign;
937  }
938  for (j = 7; j > 0; j--)
939  delay[j] = delay[j - 1];
940  delay[0] = buffer[i];
941  buffer[i] -= dotprod >> 9;
942  }
943 }
944 
946 {
947  APEPredictor *p = &ctx->predictor;
948  int32_t *decoded0 = ctx->decoded[0];
949  int32_t *decoded1 = ctx->decoded[1];
950  int32_t coeffs[256], delay[256];
951  int start = 4, shift = 10;
952 
954  start = 16;
955  long_filter_high_3800(decoded0, 16, 9, coeffs, delay, count);
956  long_filter_high_3800(decoded1, 16, 9, coeffs, delay, count);
957  } else if (ctx->compression_level == COMPRESSION_LEVEL_EXTRA_HIGH) {
958  int order = 128, shift2 = 11;
959 
960  if (ctx->fileversion >= 3830) {
961  order <<= 1;
962  shift++;
963  shift2++;
964  long_filter_ehigh_3830(decoded0 + order, count - order);
965  long_filter_ehigh_3830(decoded1 + order, count - order);
966  }
967  start = order;
968  long_filter_high_3800(decoded0, order, shift2, coeffs, delay, count);
969  long_filter_high_3800(decoded1, order, shift2, coeffs, delay, count);
970  }
971 
972  while (count--) {
973  int X = *decoded0, Y = *decoded1;
975  *decoded0 = filter_fast_3320(p, Y, 0, YDELAYA);
976  decoded0++;
977  *decoded1 = filter_fast_3320(p, X, 1, XDELAYA);
978  decoded1++;
979  } else {
980  *decoded0 = filter_3800(p, Y, 0, YDELAYA, YDELAYB,
981  start, shift);
982  decoded0++;
983  *decoded1 = filter_3800(p, X, 1, XDELAYA, XDELAYB,
984  start, shift);
985  decoded1++;
986  }
987 
988  /* Combined */
989  p->buf++;
990  p->sample_pos++;
991 
992  /* Have we filled the history buffer? */
993  if (p->buf == p->historybuffer + HISTORY_SIZE) {
994  memmove(p->historybuffer, p->buf,
995  PREDICTOR_SIZE * sizeof(*p->historybuffer));
996  p->buf = p->historybuffer;
997  }
998  }
999 }
1000 
1002 {
1003  APEPredictor *p = &ctx->predictor;
1004  int32_t *decoded0 = ctx->decoded[0];
1005  int32_t coeffs[256], delay[256];
1006  int start = 4, shift = 10;
1007 
1009  start = 16;
1010  long_filter_high_3800(decoded0, 16, 9, coeffs, delay, count);
1011  } else if (ctx->compression_level == COMPRESSION_LEVEL_EXTRA_HIGH) {
1012  int order = 128, shift2 = 11;
1013 
1014  if (ctx->fileversion >= 3830) {
1015  order <<= 1;
1016  shift++;
1017  shift2++;
1018  long_filter_ehigh_3830(decoded0 + order, count - order);
1019  }
1020  start = order;
1021  long_filter_high_3800(decoded0, order, shift2, coeffs, delay, count);
1022  }
1023 
1024  while (count--) {
1026  *decoded0 = filter_fast_3320(p, *decoded0, 0, YDELAYA);
1027  decoded0++;
1028  } else {
1029  *decoded0 = filter_3800(p, *decoded0, 0, YDELAYA, YDELAYB,
1030  start, shift);
1031  decoded0++;
1032  }
1033 
1034  /* Combined */
1035  p->buf++;
1036  p->sample_pos++;
1037 
1038  /* Have we filled the history buffer? */
1039  if (p->buf == p->historybuffer + HISTORY_SIZE) {
1040  memmove(p->historybuffer, p->buf,
1041  PREDICTOR_SIZE * sizeof(*p->historybuffer));
1042  p->buf = p->historybuffer;
1043  }
1044  }
1045 }
1046 
1048  const int decoded, const int filter,
1049  const int delayA)
1050 {
1051  int32_t predictionA, sign;
1052  int32_t d0, d1, d2, d3;
1053 
1054  p->buf[delayA] = p->lastA[filter];
1055  d0 = p->buf[delayA ];
1056  d1 = p->buf[delayA ] - p->buf[delayA - 1];
1057  d2 = p->buf[delayA - 1] - p->buf[delayA - 2];
1058  d3 = p->buf[delayA - 2] - p->buf[delayA - 3];
1059 
1060  predictionA = d0 * p->coeffsA[filter][0] +
1061  d1 * p->coeffsA[filter][1] +
1062  d2 * p->coeffsA[filter][2] +
1063  d3 * p->coeffsA[filter][3];
1064 
1065  p->lastA[filter] = decoded + (predictionA >> 9);
1066  p->filterA[filter] = p->lastA[filter] + ((p->filterA[filter] * 31) >> 5);
1067 
1068  sign = APESIGN(decoded);
1069  p->coeffsA[filter][0] += ((d0 < 0) * 2 - 1) * sign;
1070  p->coeffsA[filter][1] += ((d1 < 0) * 2 - 1) * sign;
1071  p->coeffsA[filter][2] += ((d2 < 0) * 2 - 1) * sign;
1072  p->coeffsA[filter][3] += ((d3 < 0) * 2 - 1) * sign;
1073 
1074  return p->filterA[filter];
1075 }
1076 
1078 {
1079  APEPredictor *p = &ctx->predictor;
1080  int32_t *decoded0 = ctx->decoded[0];
1081  int32_t *decoded1 = ctx->decoded[1];
1082 
1083  ape_apply_filters(ctx, ctx->decoded[0], ctx->decoded[1], count);
1084 
1085  while (count--) {
1086  /* Predictor Y */
1087  int Y = *decoded1, X = *decoded0;
1088  *decoded0 = predictor_update_3930(p, Y, 0, YDELAYA);
1089  decoded0++;
1090  *decoded1 = predictor_update_3930(p, X, 1, XDELAYA);
1091  decoded1++;
1092 
1093  /* Combined */
1094  p->buf++;
1095 
1096  /* Have we filled the history buffer? */
1097  if (p->buf == p->historybuffer + HISTORY_SIZE) {
1098  memmove(p->historybuffer, p->buf,
1099  PREDICTOR_SIZE * sizeof(*p->historybuffer));
1100  p->buf = p->historybuffer;
1101  }
1102  }
1103 }
1104 
1106 {
1107  APEPredictor *p = &ctx->predictor;
1108  int32_t *decoded0 = ctx->decoded[0];
1109 
1110  ape_apply_filters(ctx, ctx->decoded[0], NULL, count);
1111 
1112  while (count--) {
1113  *decoded0 = predictor_update_3930(p, *decoded0, 0, YDELAYA);
1114  decoded0++;
1115 
1116  p->buf++;
1117 
1118  /* Have we filled the history buffer? */
1119  if (p->buf == p->historybuffer + HISTORY_SIZE) {
1120  memmove(p->historybuffer, p->buf,
1121  PREDICTOR_SIZE * sizeof(*p->historybuffer));
1122  p->buf = p->historybuffer;
1123  }
1124  }
1125 }
1126 
1128  const int decoded, const int filter,
1129  const int delayA, const int delayB,
1130  const int adaptA, const int adaptB)
1131 {
1132  int32_t predictionA, predictionB, sign;
1133 
1134  p->buf[delayA] = p->lastA[filter];
1135  p->buf[adaptA] = APESIGN(p->buf[delayA]);
1136  p->buf[delayA - 1] = p->buf[delayA] - p->buf[delayA - 1];
1137  p->buf[adaptA - 1] = APESIGN(p->buf[delayA - 1]);
1138 
1139  predictionA = p->buf[delayA ] * p->coeffsA[filter][0] +
1140  p->buf[delayA - 1] * p->coeffsA[filter][1] +
1141  p->buf[delayA - 2] * p->coeffsA[filter][2] +
1142  p->buf[delayA - 3] * p->coeffsA[filter][3];
1143 
1144  /* Apply a scaled first-order filter compression */
1145  p->buf[delayB] = p->filterA[filter ^ 1] - ((p->filterB[filter] * 31) >> 5);
1146  p->buf[adaptB] = APESIGN(p->buf[delayB]);
1147  p->buf[delayB - 1] = p->buf[delayB] - p->buf[delayB - 1];
1148  p->buf[adaptB - 1] = APESIGN(p->buf[delayB - 1]);
1149  p->filterB[filter] = p->filterA[filter ^ 1];
1150 
1151  predictionB = p->buf[delayB ] * p->coeffsB[filter][0] +
1152  p->buf[delayB - 1] * p->coeffsB[filter][1] +
1153  p->buf[delayB - 2] * p->coeffsB[filter][2] +
1154  p->buf[delayB - 3] * p->coeffsB[filter][3] +
1155  p->buf[delayB - 4] * p->coeffsB[filter][4];
1156 
1157  p->lastA[filter] = decoded + ((predictionA + (predictionB >> 1)) >> 10);
1158  p->filterA[filter] = p->lastA[filter] + ((p->filterA[filter] * 31) >> 5);
1159 
1160  sign = APESIGN(decoded);
1161  p->coeffsA[filter][0] += p->buf[adaptA ] * sign;
1162  p->coeffsA[filter][1] += p->buf[adaptA - 1] * sign;
1163  p->coeffsA[filter][2] += p->buf[adaptA - 2] * sign;
1164  p->coeffsA[filter][3] += p->buf[adaptA - 3] * sign;
1165  p->coeffsB[filter][0] += p->buf[adaptB ] * sign;
1166  p->coeffsB[filter][1] += p->buf[adaptB - 1] * sign;
1167  p->coeffsB[filter][2] += p->buf[adaptB - 2] * sign;
1168  p->coeffsB[filter][3] += p->buf[adaptB - 3] * sign;
1169  p->coeffsB[filter][4] += p->buf[adaptB - 4] * sign;
1170 
1171  return p->filterA[filter];
1172 }
1173 
1175 {
1176  APEPredictor *p = &ctx->predictor;
1177  int32_t *decoded0 = ctx->decoded[0];
1178  int32_t *decoded1 = ctx->decoded[1];
1179 
1180  ape_apply_filters(ctx, ctx->decoded[0], ctx->decoded[1], count);
1181 
1182  while (count--) {
1183  /* Predictor Y */
1184  *decoded0 = predictor_update_filter(p, *decoded0, 0, YDELAYA, YDELAYB,
1186  decoded0++;
1187  *decoded1 = predictor_update_filter(p, *decoded1, 1, XDELAYA, XDELAYB,
1189  decoded1++;
1190 
1191  /* Combined */
1192  p->buf++;
1193 
1194  /* Have we filled the history buffer? */
1195  if (p->buf == p->historybuffer + HISTORY_SIZE) {
1196  memmove(p->historybuffer, p->buf,
1197  PREDICTOR_SIZE * sizeof(*p->historybuffer));
1198  p->buf = p->historybuffer;
1199  }
1200  }
1201 }
1202 
1204 {
1205  APEPredictor *p = &ctx->predictor;
1206  int32_t *decoded0 = ctx->decoded[0];
1207  int32_t predictionA, currentA, A, sign;
1208 
1209  ape_apply_filters(ctx, ctx->decoded[0], NULL, count);
1210 
1211  currentA = p->lastA[0];
1212 
1213  while (count--) {
1214  A = *decoded0;
1215 
1216  p->buf[YDELAYA] = currentA;
1217  p->buf[YDELAYA - 1] = p->buf[YDELAYA] - p->buf[YDELAYA - 1];
1218 
1219  predictionA = p->buf[YDELAYA ] * p->coeffsA[0][0] +
1220  p->buf[YDELAYA - 1] * p->coeffsA[0][1] +
1221  p->buf[YDELAYA - 2] * p->coeffsA[0][2] +
1222  p->buf[YDELAYA - 3] * p->coeffsA[0][3];
1223 
1224  currentA = A + (predictionA >> 10);
1225 
1226  p->buf[YADAPTCOEFFSA] = APESIGN(p->buf[YDELAYA ]);
1227  p->buf[YADAPTCOEFFSA - 1] = APESIGN(p->buf[YDELAYA - 1]);
1228 
1229  sign = APESIGN(A);
1230  p->coeffsA[0][0] += p->buf[YADAPTCOEFFSA ] * sign;
1231  p->coeffsA[0][1] += p->buf[YADAPTCOEFFSA - 1] * sign;
1232  p->coeffsA[0][2] += p->buf[YADAPTCOEFFSA - 2] * sign;
1233  p->coeffsA[0][3] += p->buf[YADAPTCOEFFSA - 3] * sign;
1234 
1235  p->buf++;
1236 
1237  /* Have we filled the history buffer? */
1238  if (p->buf == p->historybuffer + HISTORY_SIZE) {
1239  memmove(p->historybuffer, p->buf,
1240  PREDICTOR_SIZE * sizeof(*p->historybuffer));
1241  p->buf = p->historybuffer;
1242  }
1243 
1244  p->filterA[0] = currentA + ((p->filterA[0] * 31) >> 5);
1245  *(decoded0++) = p->filterA[0];
1246  }
1247 
1248  p->lastA[0] = currentA;
1249 }
1250 
1251 static void do_init_filter(APEFilter *f, int16_t *buf, int order)
1252 {
1253  f->coeffs = buf;
1254  f->historybuffer = buf + order;
1255  f->delay = f->historybuffer + order * 2;
1256  f->adaptcoeffs = f->historybuffer + order;
1257 
1258  memset(f->historybuffer, 0, (order * 2) * sizeof(*f->historybuffer));
1259  memset(f->coeffs, 0, order * sizeof(*f->coeffs));
1260  f->avg = 0;
1261 }
1262 
1263 static void init_filter(APEContext *ctx, APEFilter *f, int16_t *buf, int order)
1264 {
1265  do_init_filter(&f[0], buf, order);
1266  do_init_filter(&f[1], buf + order * 3 + HISTORY_SIZE, order);
1267 }
1268 
1269 static void do_apply_filter(APEContext *ctx, int version, APEFilter *f,
1270  int32_t *data, int count, int order, int fracbits)
1271 {
1272  int res;
1273  int absres;
1274 
1275  while (count--) {
1276  /* round fixedpoint scalar product */
1278  f->delay - order,
1279  f->adaptcoeffs - order,
1280  order, APESIGN(*data));
1281  res = (res + (1 << (fracbits - 1))) >> fracbits;
1282  res += *data;
1283  *data++ = res;
1284 
1285  /* Update the output history */
1286  *f->delay++ = av_clip_int16(res);
1287 
1288  if (version < 3980) {
1289  /* Version ??? to < 3.98 files (untested) */
1290  f->adaptcoeffs[0] = (res == 0) ? 0 : ((res >> 28) & 8) - 4;
1291  f->adaptcoeffs[-4] >>= 1;
1292  f->adaptcoeffs[-8] >>= 1;
1293  } else {
1294  /* Version 3.98 and later files */
1295 
1296  /* Update the adaption coefficients */
1297  absres = FFABS(res);
1298  if (absres)
1299  *f->adaptcoeffs = ((res & (-1<<31)) ^ (-1<<30)) >>
1300  (25 + (absres <= f->avg*3) + (absres <= f->avg*4/3));
1301  else
1302  *f->adaptcoeffs = 0;
1303 
1304  f->avg += (absres - f->avg) / 16;
1305 
1306  f->adaptcoeffs[-1] >>= 1;
1307  f->adaptcoeffs[-2] >>= 1;
1308  f->adaptcoeffs[-8] >>= 1;
1309  }
1310 
1311  f->adaptcoeffs++;
1312 
1313  /* Have we filled the history buffer? */
1314  if (f->delay == f->historybuffer + HISTORY_SIZE + (order * 2)) {
1315  memmove(f->historybuffer, f->delay - (order * 2),
1316  (order * 2) * sizeof(*f->historybuffer));
1317  f->delay = f->historybuffer + order * 2;
1318  f->adaptcoeffs = f->historybuffer + order;
1319  }
1320  }
1321 }
1322 
1323 static void apply_filter(APEContext *ctx, APEFilter *f,
1324  int32_t *data0, int32_t *data1,
1325  int count, int order, int fracbits)
1326 {
1327  do_apply_filter(ctx, ctx->fileversion, &f[0], data0, count, order, fracbits);
1328  if (data1)
1329  do_apply_filter(ctx, ctx->fileversion, &f[1], data1, count, order, fracbits);
1330 }
1331 
1332 static void ape_apply_filters(APEContext *ctx, int32_t *decoded0,
1333  int32_t *decoded1, int count)
1334 {
1335  int i;
1336 
1337  for (i = 0; i < APE_FILTER_LEVELS; i++) {
1338  if (!ape_filter_orders[ctx->fset][i])
1339  break;
1340  apply_filter(ctx, ctx->filters[i], decoded0, decoded1, count,
1341  ape_filter_orders[ctx->fset][i],
1342  ape_filter_fracbits[ctx->fset][i]);
1343  }
1344 }
1345 
1347 {
1348  int i, ret;
1349  if ((ret = init_entropy_decoder(ctx)) < 0)
1350  return ret;
1352 
1353  for (i = 0; i < APE_FILTER_LEVELS; i++) {
1354  if (!ape_filter_orders[ctx->fset][i])
1355  break;
1356  init_filter(ctx, ctx->filters[i], ctx->filterbuf[i],
1357  ape_filter_orders[ctx->fset][i]);
1358  }
1359  return 0;
1360 }
1361 
1362 static void ape_unpack_mono(APEContext *ctx, int count)
1363 {
1365  /* We are pure silence, so we're done. */
1366  av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence mono\n");
1367  return;
1368  }
1369 
1370  ctx->entropy_decode_mono(ctx, count);
1371 
1372  /* Now apply the predictor decoding */
1373  ctx->predictor_decode_mono(ctx, count);
1374 
1375  /* Pseudo-stereo - just copy left channel to right channel */
1376  if (ctx->channels == 2) {
1377  memcpy(ctx->decoded[1], ctx->decoded[0], count * sizeof(*ctx->decoded[1]));
1378  }
1379 }
1380 
1381 static void ape_unpack_stereo(APEContext *ctx, int count)
1382 {
1383  int32_t left, right;
1384  int32_t *decoded0 = ctx->decoded[0];
1385  int32_t *decoded1 = ctx->decoded[1];
1386 
1388  /* We are pure silence, so we're done. */
1389  av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence stereo\n");
1390  return;
1391  }
1392 
1393  ctx->entropy_decode_stereo(ctx, count);
1394 
1395  /* Now apply the predictor decoding */
1396  ctx->predictor_decode_stereo(ctx, count);
1397 
1398  /* Decorrelate and scale to output depth */
1399  while (count--) {
1400  left = *decoded1 - (*decoded0 / 2);
1401  right = left + *decoded0;
1402 
1403  *(decoded0++) = left;
1404  *(decoded1++) = right;
1405  }
1406 }
1407 
1409  int *got_frame_ptr, AVPacket *avpkt)
1410 {
1411  AVFrame *frame = data;
1412  const uint8_t *buf = avpkt->data;
1413  APEContext *s = avctx->priv_data;
1414  uint8_t *sample8;
1415  int16_t *sample16;
1416  int32_t *sample24;
1417  int i, ch, ret;
1418  int blockstodecode;
1419 
1420  /* this should never be negative, but bad things will happen if it is, so
1421  check it just to make sure. */
1422  av_assert0(s->samples >= 0);
1423 
1424  if(!s->samples){
1425  uint32_t nblocks, offset;
1426  int buf_size;
1427 
1428  if (!avpkt->size) {
1429  *got_frame_ptr = 0;
1430  return 0;
1431  }
1432  if (avpkt->size < 8) {
1433  av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
1434  return AVERROR_INVALIDDATA;
1435  }
1436  buf_size = avpkt->size & ~3;
1437  if (buf_size != avpkt->size) {
1438  av_log(avctx, AV_LOG_WARNING, "packet size is not a multiple of 4. "
1439  "extra bytes at the end will be skipped.\n");
1440  }
1441  if (s->fileversion < 3950) // previous versions overread two bytes
1442  buf_size += 2;
1443  av_fast_padded_malloc(&s->data, &s->data_size, buf_size);
1444  if (!s->data)
1445  return AVERROR(ENOMEM);
1446  s->bdsp.bswap_buf((uint32_t *) s->data, (const uint32_t *) buf,
1447  buf_size >> 2);
1448  memset(s->data + (buf_size & ~3), 0, buf_size & 3);
1449  s->ptr = s->data;
1450  s->data_end = s->data + buf_size;
1451 
1452  nblocks = bytestream_get_be32(&s->ptr);
1453  offset = bytestream_get_be32(&s->ptr);
1454  if (s->fileversion >= 3900) {
1455  if (offset > 3) {
1456  av_log(avctx, AV_LOG_ERROR, "Incorrect offset passed\n");
1457  s->data = NULL;
1458  return AVERROR_INVALIDDATA;
1459  }
1460  if (s->data_end - s->ptr < offset) {
1461  av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
1462  return AVERROR_INVALIDDATA;
1463  }
1464  s->ptr += offset;
1465  } else {
1466  if ((ret = init_get_bits8(&s->gb, s->ptr, s->data_end - s->ptr)) < 0)
1467  return ret;
1468  if (s->fileversion > 3800)
1469  skip_bits_long(&s->gb, offset * 8);
1470  else
1471  skip_bits_long(&s->gb, offset);
1472  }
1473 
1474  if (!nblocks || nblocks > INT_MAX) {
1475  av_log(avctx, AV_LOG_ERROR, "Invalid sample count: %"PRIu32".\n",
1476  nblocks);
1477  return AVERROR_INVALIDDATA;
1478  }
1479  s->samples = nblocks;
1480 
1481  /* Initialize the frame decoder */
1482  if (init_frame_decoder(s) < 0) {
1483  av_log(avctx, AV_LOG_ERROR, "Error reading frame header\n");
1484  return AVERROR_INVALIDDATA;
1485  }
1486  }
1487 
1488  if (!s->data) {
1489  *got_frame_ptr = 0;
1490  return avpkt->size;
1491  }
1492 
1493  blockstodecode = FFMIN(s->blocks_per_loop, s->samples);
1494  // for old files coefficients were not interleaved,
1495  // so we need to decode all of them at once
1496  if (s->fileversion < 3930)
1497  blockstodecode = s->samples;
1498 
1499  /* reallocate decoded sample buffer if needed */
1501  2 * FFALIGN(blockstodecode, 8) * sizeof(*s->decoded_buffer));
1502  if (!s->decoded_buffer)
1503  return AVERROR(ENOMEM);
1504  memset(s->decoded_buffer, 0, s->decoded_size);
1505  s->decoded[0] = s->decoded_buffer;
1506  s->decoded[1] = s->decoded_buffer + FFALIGN(blockstodecode, 8);
1507 
1508  /* get output buffer */
1509  frame->nb_samples = blockstodecode;
1510  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1511  return ret;
1512 
1513  s->error=0;
1514 
1515  if ((s->channels == 1) || (s->frameflags & APE_FRAMECODE_PSEUDO_STEREO))
1516  ape_unpack_mono(s, blockstodecode);
1517  else
1518  ape_unpack_stereo(s, blockstodecode);
1519  emms_c();
1520 
1521  if (s->error) {
1522  s->samples=0;
1523  av_log(avctx, AV_LOG_ERROR, "Error decoding frame\n");
1524  return AVERROR_INVALIDDATA;
1525  }
1526 
1527  switch (s->bps) {
1528  case 8:
1529  for (ch = 0; ch < s->channels; ch++) {
1530  sample8 = (uint8_t *)frame->data[ch];
1531  for (i = 0; i < blockstodecode; i++)
1532  *sample8++ = (s->decoded[ch][i] + 0x80) & 0xff;
1533  }
1534  break;
1535  case 16:
1536  for (ch = 0; ch < s->channels; ch++) {
1537  sample16 = (int16_t *)frame->data[ch];
1538  for (i = 0; i < blockstodecode; i++)
1539  *sample16++ = s->decoded[ch][i];
1540  }
1541  break;
1542  case 24:
1543  for (ch = 0; ch < s->channels; ch++) {
1544  sample24 = (int32_t *)frame->data[ch];
1545  for (i = 0; i < blockstodecode; i++)
1546  *sample24++ = s->decoded[ch][i] << 8;
1547  }
1548  break;
1549  }
1550 
1551  s->samples -= blockstodecode;
1552 
1553  *got_frame_ptr = 1;
1554 
1555  return !s->samples ? avpkt->size : 0;
1556 }
1557 
1559 {
1560  APEContext *s = avctx->priv_data;
1561  s->samples= 0;
1562 }
1563 
1564 #define OFFSET(x) offsetof(APEContext, x)
1565 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1566 static const AVOption options[] = {
1567  { "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" },
1568  { "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" },
1569  { NULL},
1570 };
1571 
1572 static const AVClass ape_decoder_class = {
1573  .class_name = "APE decoder",
1574  .item_name = av_default_item_name,
1575  .option = options,
1576  .version = LIBAVUTIL_VERSION_INT,
1577 };
1578 
1580  .name = "ape",
1581  .long_name = NULL_IF_CONFIG_SMALL("Monkey's Audio"),
1582  .type = AVMEDIA_TYPE_AUDIO,
1583  .id = AV_CODEC_ID_APE,
1584  .priv_data_size = sizeof(APEContext),
1585  .init = ape_decode_init,
1586  .close = ape_decode_close,
1589  .flush = ape_flush,
1590  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
1594  .priv_class = &ape_decoder_class,
1595 };