Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Monkey's Audio lossless audio decoder
  3.  * Copyright (c) 2007 Benjamin Zores <ben@geexbox.org>
  4.  *  based upon libdemac from Dave Chapman.
  5.  *
  6.  * This file is part of FFmpeg.
  7.  *
  8.  * FFmpeg is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Lesser General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2.1 of the License, or (at your option) any later version.
  12.  *
  13.  * FFmpeg is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Lesser General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Lesser General Public
  19.  * License along with FFmpeg; if not, write to the Free Software
  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21.  */
  22.  
  23. #include <inttypes.h>
  24.  
  25. #include "libavutil/avassert.h"
  26. #include "libavutil/channel_layout.h"
  27. #include "libavutil/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.  */
  67. enum APECompressionLevel {
  68.     COMPRESSION_LEVEL_FAST       = 1000,
  69.     COMPRESSION_LEVEL_NORMAL     = 2000,
  70.     COMPRESSION_LEVEL_HIGH       = 3000,
  71.     COMPRESSION_LEVEL_EXTRA_HIGH = 4000,
  72.     COMPRESSION_LEVEL_INSANE     = 5000
  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 */
  88. static const uint8_t ape_filter_fracbits[5][APE_FILTER_LEVELS] = {
  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 {
  121.     int32_t *buf;
  122.  
  123.     int32_t lastA[2];
  124.  
  125.     int32_t filterA[2];
  126.     int32_t filterB[2];
  127.  
  128.     int32_t coeffsA[2][4];  ///< adaption coefficients
  129.     int32_t coeffsB[2][5];  ///< adaption coefficients
  130.     int32_t historybuffer[HISTORY_SIZE + PREDICTOR_SIZE];
  131.  
  132.     unsigned int sample_pos;
  133. } APEPredictor;
  134.  
  135. /** Decoder context */
  136. typedef struct APEContext {
  137.     AVClass *class;                          ///< class for AVOptions
  138.     AVCodecContext *avctx;
  139.     BswapDSPContext bdsp;
  140.     LLAudDSPContext adsp;
  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.  
  154.     int32_t *decoded_buffer;
  155.     int decoded_size;
  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
  165.     GetBitContext gb;
  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);
  176.     void (*predictor_decode_mono)(struct APEContext *ctx, int count);
  177.     void (*predictor_decode_stereo)(struct APEContext *ctx, int count);
  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.  
  200. static av_cold int ape_decode_close(AVCodecContext *avctx)
  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.  
  208.     av_freep(&s->decoded_buffer);
  209.     av_freep(&s->data);
  210.     s->decoded_size = s->data_size = 0;
  211.  
  212.     return 0;
  213. }
  214.  
  215. static av_cold int ape_decode_init(AVCodecContext *avctx)
  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:
  234.         avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
  235.         break;
  236.     case 24:
  237.         avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
  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);
  252.     if (s->compression_level % 1000 || s->compression_level > COMPRESSION_LEVEL_INSANE ||
  253.         !s->compression_level ||
  254.         (s->fileversion < 3930 && s->compression_level == COMPRESSION_LEVEL_INSANE)) {
  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) {
  269.         s->entropy_decode_mono   = entropy_decode_mono_0000;
  270.         s->entropy_decode_stereo = entropy_decode_stereo_0000;
  271.     } else if (s->fileversion < 3900) {
  272.         s->entropy_decode_mono   = entropy_decode_mono_3860;
  273.         s->entropy_decode_stereo = entropy_decode_stereo_3860;
  274.     } else if (s->fileversion < 3930) {
  275.         s->entropy_decode_mono   = entropy_decode_mono_3900;
  276.         s->entropy_decode_stereo = entropy_decode_stereo_3900;
  277.     } else if (s->fileversion < 3990) {
  278.         s->entropy_decode_mono   = entropy_decode_mono_3900;
  279.         s->entropy_decode_stereo = entropy_decode_stereo_3930;
  280.     } else {
  281.         s->entropy_decode_mono   = entropy_decode_mono_3990;
  282.         s->entropy_decode_stereo = entropy_decode_stereo_3990;
  283.     }
  284.  
  285.     if (s->fileversion < 3930) {
  286.         s->predictor_decode_mono   = predictor_decode_mono_3800;
  287.         s->predictor_decode_stereo = predictor_decode_stereo_3800;
  288.     } else if (s->fileversion < 3950) {
  289.         s->predictor_decode_mono   = predictor_decode_mono_3930;
  290.         s->predictor_decode_stereo = predictor_decode_stereo_3930;
  291.     } else {
  292.         s->predictor_decode_mono   = predictor_decode_mono_3950;
  293.         s->predictor_decode_stereo = predictor_decode_stereo_3950;
  294.     }
  295.  
  296.     ff_bswapdsp_init(&s->bdsp);
  297.     ff_llauddsp_init(&s->adsp);
  298.     avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
  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.  
  479. static inline int ape_decode_value_3860(APEContext *ctx, GetBitContext *gb,
  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.     return ((x >> 1) ^ ((x & 1) - 1)) + 1;
  509. }
  510.  
  511. static inline int ape_decode_value_3900(APEContext *ctx, APERice *rice)
  512. {
  513.     unsigned int x, overflow;
  514.     int tmpk;
  515.  
  516.     overflow = range_get_symbol(ctx, counts_3970, counts_diff_3970);
  517.  
  518.     if (overflow == (MODEL_ELEMENTS - 1)) {
  519.         tmpk = range_decode_bits(ctx, 5);
  520.         overflow = 0;
  521.     } else
  522.         tmpk = (rice->k < 1) ? 0 : rice->k - 1;
  523.  
  524.     if (tmpk <= 16 || ctx->fileversion < 3910) {
  525.         if (tmpk > 23) {
  526.             av_log(ctx->avctx, AV_LOG_ERROR, "Too many bits: %d\n", tmpk);
  527.             return AVERROR_INVALIDDATA;
  528.         }
  529.         x = range_decode_bits(ctx, tmpk);
  530.     } else if (tmpk <= 31) {
  531.         x = range_decode_bits(ctx, 16);
  532.         x |= (range_decode_bits(ctx, tmpk - 16) << 16);
  533.     } else {
  534.         av_log(ctx->avctx, AV_LOG_ERROR, "Too many bits: %d\n", tmpk);
  535.         return AVERROR_INVALIDDATA;
  536.     }
  537.     x += overflow << tmpk;
  538.  
  539.     update_rice(rice, x);
  540.  
  541.     /* Convert to signed */
  542.     return ((x >> 1) ^ ((x & 1) - 1)) + 1;
  543. }
  544.  
  545. static inline int ape_decode_value_3990(APEContext *ctx, APERice *rice)
  546. {
  547.     unsigned int x, overflow;
  548.     int base, pivot;
  549.  
  550.     pivot = rice->ksum >> 5;
  551.     if (pivot == 0)
  552.         pivot = 1;
  553.  
  554.     overflow = range_get_symbol(ctx, counts_3980, counts_diff_3980);
  555.  
  556.     if (overflow == (MODEL_ELEMENTS - 1)) {
  557.         overflow  = range_decode_bits(ctx, 16) << 16;
  558.         overflow |= range_decode_bits(ctx, 16);
  559.     }
  560.  
  561.     if (pivot < 0x10000) {
  562.         base = range_decode_culfreq(ctx, pivot);
  563.         range_decode_update(ctx, 1, base);
  564.     } else {
  565.         int base_hi = pivot, base_lo;
  566.         int bbits = 0;
  567.  
  568.         while (base_hi & ~0xFFFF) {
  569.             base_hi >>= 1;
  570.             bbits++;
  571.         }
  572.         base_hi = range_decode_culfreq(ctx, base_hi + 1);
  573.         range_decode_update(ctx, 1, base_hi);
  574.         base_lo = range_decode_culfreq(ctx, 1 << bbits);
  575.         range_decode_update(ctx, 1, base_lo);
  576.  
  577.         base = (base_hi << bbits) + base_lo;
  578.     }
  579.  
  580.     x = base + overflow * pivot;
  581.  
  582.     update_rice(rice, x);
  583.  
  584.     /* Convert to signed */
  585.     return ((x >> 1) ^ ((x & 1) - 1)) + 1;
  586. }
  587.  
  588. static void decode_array_0000(APEContext *ctx, GetBitContext *gb,
  589.                               int32_t *out, APERice *rice, int blockstodecode)
  590. {
  591.     int i;
  592.     int ksummax, ksummin;
  593.  
  594.     rice->ksum = 0;
  595.     for (i = 0; i < FFMIN(blockstodecode, 5); i++) {
  596.         out[i] = get_rice_ook(&ctx->gb, 10);
  597.         rice->ksum += out[i];
  598.     }
  599.     rice->k = av_log2(rice->ksum / 10) + 1;
  600.     if (rice->k >= 24)
  601.         return;
  602.     for (; i < FFMIN(blockstodecode, 64); i++) {
  603.         out[i] = get_rice_ook(&ctx->gb, rice->k);
  604.         rice->ksum += out[i];
  605.         rice->k = av_log2(rice->ksum / ((i + 1) * 2)) + 1;
  606.         if (rice->k >= 24)
  607.             return;
  608.     }
  609.     ksummax = 1 << rice->k + 7;
  610.     ksummin = rice->k ? (1 << rice->k + 6) : 0;
  611.     for (; i < blockstodecode; i++) {
  612.         out[i] = get_rice_ook(&ctx->gb, rice->k);
  613.         rice->ksum += out[i] - out[i - 64];
  614.         while (rice->ksum < ksummin) {
  615.             rice->k--;
  616.             ksummin = rice->k ? ksummin >> 1 : 0;
  617.             ksummax >>= 1;
  618.         }
  619.         while (rice->ksum >= ksummax) {
  620.             rice->k++;
  621.             if (rice->k > 24)
  622.                 return;
  623.             ksummax <<= 1;
  624.             ksummin = ksummin ? ksummin << 1 : 128;
  625.         }
  626.     }
  627.  
  628.     for (i = 0; i < blockstodecode; i++)
  629.         out[i] = ((out[i] >> 1) ^ ((out[i] & 1) - 1)) + 1;
  630. }
  631.  
  632. static void entropy_decode_mono_0000(APEContext *ctx, int blockstodecode)
  633. {
  634.     decode_array_0000(ctx, &ctx->gb, ctx->decoded[0], &ctx->riceY,
  635.                       blockstodecode);
  636. }
  637.  
  638. static void entropy_decode_stereo_0000(APEContext *ctx, int blockstodecode)
  639. {
  640.     decode_array_0000(ctx, &ctx->gb, ctx->decoded[0], &ctx->riceY,
  641.                       blockstodecode);
  642.     decode_array_0000(ctx, &ctx->gb, ctx->decoded[1], &ctx->riceX,
  643.                       blockstodecode);
  644. }
  645.  
  646. static void entropy_decode_mono_3860(APEContext *ctx, int blockstodecode)
  647. {
  648.     int32_t *decoded0 = ctx->decoded[0];
  649.  
  650.     while (blockstodecode--)
  651.         *decoded0++ = ape_decode_value_3860(ctx, &ctx->gb, &ctx->riceY);
  652. }
  653.  
  654. static void entropy_decode_stereo_3860(APEContext *ctx, int blockstodecode)
  655. {
  656.     int32_t *decoded0 = ctx->decoded[0];
  657.     int32_t *decoded1 = ctx->decoded[1];
  658.     int blocks = blockstodecode;
  659.  
  660.     while (blockstodecode--)
  661.         *decoded0++ = ape_decode_value_3860(ctx, &ctx->gb, &ctx->riceY);
  662.     while (blocks--)
  663.         *decoded1++ = ape_decode_value_3860(ctx, &ctx->gb, &ctx->riceX);
  664. }
  665.  
  666. static void entropy_decode_mono_3900(APEContext *ctx, int blockstodecode)
  667. {
  668.     int32_t *decoded0 = ctx->decoded[0];
  669.  
  670.     while (blockstodecode--)
  671.         *decoded0++ = ape_decode_value_3900(ctx, &ctx->riceY);
  672. }
  673.  
  674. static void entropy_decode_stereo_3900(APEContext *ctx, int blockstodecode)
  675. {
  676.     int32_t *decoded0 = ctx->decoded[0];
  677.     int32_t *decoded1 = ctx->decoded[1];
  678.     int blocks = blockstodecode;
  679.  
  680.     while (blockstodecode--)
  681.         *decoded0++ = ape_decode_value_3900(ctx, &ctx->riceY);
  682.     range_dec_normalize(ctx);
  683.     // because of some implementation peculiarities we need to backpedal here
  684.     ctx->ptr -= 1;
  685.     range_start_decoding(ctx);
  686.     while (blocks--)
  687.         *decoded1++ = ape_decode_value_3900(ctx, &ctx->riceX);
  688. }
  689.  
  690. static void entropy_decode_stereo_3930(APEContext *ctx, int blockstodecode)
  691. {
  692.     int32_t *decoded0 = ctx->decoded[0];
  693.     int32_t *decoded1 = ctx->decoded[1];
  694.  
  695.     while (blockstodecode--) {
  696.         *decoded0++ = ape_decode_value_3900(ctx, &ctx->riceY);
  697.         *decoded1++ = ape_decode_value_3900(ctx, &ctx->riceX);
  698.     }
  699. }
  700.  
  701. static void entropy_decode_mono_3990(APEContext *ctx, int blockstodecode)
  702. {
  703.     int32_t *decoded0 = ctx->decoded[0];
  704.  
  705.     while (blockstodecode--)
  706.         *decoded0++ = ape_decode_value_3990(ctx, &ctx->riceY);
  707. }
  708.  
  709. static void entropy_decode_stereo_3990(APEContext *ctx, int blockstodecode)
  710. {
  711.     int32_t *decoded0 = ctx->decoded[0];
  712.     int32_t *decoded1 = ctx->decoded[1];
  713.  
  714.     while (blockstodecode--) {
  715.         *decoded0++ = ape_decode_value_3990(ctx, &ctx->riceY);
  716.         *decoded1++ = ape_decode_value_3990(ctx, &ctx->riceX);
  717.     }
  718. }
  719.  
  720. static int init_entropy_decoder(APEContext *ctx)
  721. {
  722.     /* Read the CRC */
  723.     if (ctx->fileversion >= 3900) {
  724.         if (ctx->data_end - ctx->ptr < 6)
  725.             return AVERROR_INVALIDDATA;
  726.         ctx->CRC = bytestream_get_be32(&ctx->ptr);
  727.     } else {
  728.         ctx->CRC = get_bits_long(&ctx->gb, 32);
  729.     }
  730.  
  731.     /* Read the frame flags if they exist */
  732.     ctx->frameflags = 0;
  733.     if ((ctx->fileversion > 3820) && (ctx->CRC & 0x80000000)) {
  734.         ctx->CRC &= ~0x80000000;
  735.  
  736.         if (ctx->data_end - ctx->ptr < 6)
  737.             return AVERROR_INVALIDDATA;
  738.         ctx->frameflags = bytestream_get_be32(&ctx->ptr);
  739.     }
  740.  
  741.     /* Initialize the rice structs */
  742.     ctx->riceX.k = 10;
  743.     ctx->riceX.ksum = (1 << ctx->riceX.k) * 16;
  744.     ctx->riceY.k = 10;
  745.     ctx->riceY.ksum = (1 << ctx->riceY.k) * 16;
  746.  
  747.     if (ctx->fileversion >= 3900) {
  748.         /* The first 8 bits of input are ignored. */
  749.         ctx->ptr++;
  750.  
  751.         range_start_decoding(ctx);
  752.     }
  753.  
  754.     return 0;
  755. }
  756.  
  757. static const int32_t initial_coeffs_fast_3320[1] = {
  758.     375,
  759. };
  760.  
  761. static const int32_t initial_coeffs_a_3800[3] = {
  762.     64, 115, 64,
  763. };
  764.  
  765. static const int32_t initial_coeffs_b_3800[2] = {
  766.     740, 0
  767. };
  768.  
  769. static const int32_t initial_coeffs_3930[4] = {
  770.     360, 317, -109, 98
  771. };
  772.  
  773. static void init_predictor_decoder(APEContext *ctx)
  774. {
  775.     APEPredictor *p = &ctx->predictor;
  776.  
  777.     /* Zero the history buffers */
  778.     memset(p->historybuffer, 0, PREDICTOR_SIZE * sizeof(*p->historybuffer));
  779.     p->buf = p->historybuffer;
  780.  
  781.     /* Initialize and zero the coefficients */
  782.     if (ctx->fileversion < 3930) {
  783.         if (ctx->compression_level == COMPRESSION_LEVEL_FAST) {
  784.             memcpy(p->coeffsA[0], initial_coeffs_fast_3320,
  785.                    sizeof(initial_coeffs_fast_3320));
  786.             memcpy(p->coeffsA[1], initial_coeffs_fast_3320,
  787.                    sizeof(initial_coeffs_fast_3320));
  788.         } else {
  789.             memcpy(p->coeffsA[0], initial_coeffs_a_3800,
  790.                    sizeof(initial_coeffs_a_3800));
  791.             memcpy(p->coeffsA[1], initial_coeffs_a_3800,
  792.                    sizeof(initial_coeffs_a_3800));
  793.         }
  794.     } else {
  795.         memcpy(p->coeffsA[0], initial_coeffs_3930, sizeof(initial_coeffs_3930));
  796.         memcpy(p->coeffsA[1], initial_coeffs_3930, sizeof(initial_coeffs_3930));
  797.     }
  798.     memset(p->coeffsB, 0, sizeof(p->coeffsB));
  799.     if (ctx->fileversion < 3930) {
  800.         memcpy(p->coeffsB[0], initial_coeffs_b_3800,
  801.                sizeof(initial_coeffs_b_3800));
  802.         memcpy(p->coeffsB[1], initial_coeffs_b_3800,
  803.                sizeof(initial_coeffs_b_3800));
  804.     }
  805.  
  806.     p->filterA[0] = p->filterA[1] = 0;
  807.     p->filterB[0] = p->filterB[1] = 0;
  808.     p->lastA[0]   = p->lastA[1]   = 0;
  809.  
  810.     p->sample_pos = 0;
  811. }
  812.  
  813. /** Get inverse sign of integer (-1 for positive, 1 for negative and 0 for zero) */
  814. static inline int APESIGN(int32_t x) {
  815.     return (x < 0) - (x > 0);
  816. }
  817.  
  818. static av_always_inline int filter_fast_3320(APEPredictor *p,
  819.                                              const int decoded, const int filter,
  820.                                              const int delayA)
  821. {
  822.     int32_t predictionA;
  823.  
  824.     p->buf[delayA] = p->lastA[filter];
  825.     if (p->sample_pos < 3) {
  826.         p->lastA[filter]   = decoded;
  827.         p->filterA[filter] = decoded;
  828.         return decoded;
  829.     }
  830.  
  831.     predictionA = p->buf[delayA] * 2 - p->buf[delayA - 1];
  832.     p->lastA[filter] = decoded + (predictionA  * p->coeffsA[filter][0] >> 9);
  833.  
  834.     if ((decoded ^ predictionA) > 0)
  835.         p->coeffsA[filter][0]++;
  836.     else
  837.         p->coeffsA[filter][0]--;
  838.  
  839.     p->filterA[filter] += p->lastA[filter];
  840.  
  841.     return p->filterA[filter];
  842. }
  843.  
  844. static av_always_inline int filter_3800(APEPredictor *p,
  845.                                         const int decoded, const int filter,
  846.                                         const int delayA,  const int delayB,
  847.                                         const int start,   const int shift)
  848. {
  849.     int32_t predictionA, predictionB, sign;
  850.     int32_t d0, d1, d2, d3, d4;
  851.  
  852.     p->buf[delayA] = p->lastA[filter];
  853.     p->buf[delayB] = p->filterB[filter];
  854.     if (p->sample_pos < start) {
  855.         predictionA = decoded + p->filterA[filter];
  856.         p->lastA[filter]   = decoded;
  857.         p->filterB[filter] = decoded;
  858.         p->filterA[filter] = predictionA;
  859.         return predictionA;
  860.     }
  861.     d2 =  p->buf[delayA];
  862.     d1 = (p->buf[delayA] - p->buf[delayA - 1]) << 1;
  863.     d0 =  p->buf[delayA] + ((p->buf[delayA - 2] - p->buf[delayA - 1]) << 3);
  864.     d3 =  p->buf[delayB] * 2 - p->buf[delayB - 1];
  865.     d4 =  p->buf[delayB];
  866.  
  867.     predictionA = d0 * p->coeffsA[filter][0] +
  868.                   d1 * p->coeffsA[filter][1] +
  869.                   d2 * p->coeffsA[filter][2];
  870.  
  871.     sign = APESIGN(decoded);
  872.     p->coeffsA[filter][0] += (((d0 >> 30) & 2) - 1) * sign;
  873.     p->coeffsA[filter][1] += (((d1 >> 28) & 8) - 4) * sign;
  874.     p->coeffsA[filter][2] += (((d2 >> 28) & 8) - 4) * sign;
  875.  
  876.     predictionB = d3 * p->coeffsB[filter][0] -
  877.                   d4 * p->coeffsB[filter][1];
  878.     p->lastA[filter] = decoded + (predictionA >> 11);
  879.     sign = APESIGN(p->lastA[filter]);
  880.     p->coeffsB[filter][0] += (((d3 >> 29) & 4) - 2) * sign;
  881.     p->coeffsB[filter][1] -= (((d4 >> 30) & 2) - 1) * sign;
  882.  
  883.     p->filterB[filter] = p->lastA[filter] + (predictionB >> shift);
  884.     p->filterA[filter] = p->filterB[filter] + ((p->filterA[filter] * 31) >> 5);
  885.  
  886.     return p->filterA[filter];
  887. }
  888.  
  889. static void long_filter_high_3800(int32_t *buffer, int order, int shift, int length)
  890. {
  891.     int i, j;
  892.     int32_t dotprod, sign;
  893.     int32_t coeffs[256], delay[256];
  894.  
  895.     if (order >= length)
  896.         return;
  897.  
  898.     memset(coeffs, 0, order * sizeof(*coeffs));
  899.     for (i = 0; i < order; i++)
  900.         delay[i] = buffer[i];
  901.     for (i = order; i < length; i++) {
  902.         dotprod = 0;
  903.         sign = APESIGN(buffer[i]);
  904.         for (j = 0; j < order; j++) {
  905.             dotprod += delay[j] * coeffs[j];
  906.             coeffs[j] += ((delay[j] >> 31) | 1) * sign;
  907.         }
  908.         buffer[i] -= dotprod >> shift;
  909.         for (j = 0; j < order - 1; j++)
  910.             delay[j] = delay[j + 1];
  911.         delay[order - 1] = buffer[i];
  912.     }
  913. }
  914.  
  915. static void long_filter_ehigh_3830(int32_t *buffer, int length)
  916. {
  917.     int i, j;
  918.     int32_t dotprod, sign;
  919.     int32_t coeffs[8] = { 0 }, delay[8] = { 0 };
  920.  
  921.     for (i = 0; i < length; i++) {
  922.         dotprod = 0;
  923.         sign = APESIGN(buffer[i]);
  924.         for (j = 7; j >= 0; j--) {
  925.             dotprod += delay[j] * coeffs[j];
  926.             coeffs[j] += ((delay[j] >> 31) | 1) * sign;
  927.         }
  928.         for (j = 7; j > 0; j--)
  929.             delay[j] = delay[j - 1];
  930.         delay[0] = buffer[i];
  931.         buffer[i] -= dotprod >> 9;
  932.     }
  933. }
  934.  
  935. static void predictor_decode_stereo_3800(APEContext *ctx, int count)
  936. {
  937.     APEPredictor *p = &ctx->predictor;
  938.     int32_t *decoded0 = ctx->decoded[0];
  939.     int32_t *decoded1 = ctx->decoded[1];
  940.     int start = 4, shift = 10;
  941.  
  942.     if (ctx->compression_level == COMPRESSION_LEVEL_HIGH) {
  943.         start = 16;
  944.         long_filter_high_3800(decoded0, 16, 9, count);
  945.         long_filter_high_3800(decoded1, 16, 9, count);
  946.     } else if (ctx->compression_level == COMPRESSION_LEVEL_EXTRA_HIGH) {
  947.         int order = 128, shift2 = 11;
  948.  
  949.         if (ctx->fileversion >= 3830) {
  950.             order <<= 1;
  951.             shift++;
  952.             shift2++;
  953.             long_filter_ehigh_3830(decoded0 + order, count - order);
  954.             long_filter_ehigh_3830(decoded1 + order, count - order);
  955.         }
  956.         start = order;
  957.         long_filter_high_3800(decoded0, order, shift2, count);
  958.         long_filter_high_3800(decoded1, order, shift2, count);
  959.     }
  960.  
  961.     while (count--) {
  962.         int X = *decoded0, Y = *decoded1;
  963.         if (ctx->compression_level == COMPRESSION_LEVEL_FAST) {
  964.             *decoded0 = filter_fast_3320(p, Y, 0, YDELAYA);
  965.             decoded0++;
  966.             *decoded1 = filter_fast_3320(p, X, 1, XDELAYA);
  967.             decoded1++;
  968.         } else {
  969.             *decoded0 = filter_3800(p, Y, 0, YDELAYA, YDELAYB,
  970.                                     start, shift);
  971.             decoded0++;
  972.             *decoded1 = filter_3800(p, X, 1, XDELAYA, XDELAYB,
  973.                                     start, shift);
  974.             decoded1++;
  975.         }
  976.  
  977.         /* Combined */
  978.         p->buf++;
  979.         p->sample_pos++;
  980.  
  981.         /* Have we filled the history buffer? */
  982.         if (p->buf == p->historybuffer + HISTORY_SIZE) {
  983.             memmove(p->historybuffer, p->buf,
  984.                     PREDICTOR_SIZE * sizeof(*p->historybuffer));
  985.             p->buf = p->historybuffer;
  986.         }
  987.     }
  988. }
  989.  
  990. static void predictor_decode_mono_3800(APEContext *ctx, int count)
  991. {
  992.     APEPredictor *p = &ctx->predictor;
  993.     int32_t *decoded0 = ctx->decoded[0];
  994.     int start = 4, shift = 10;
  995.  
  996.     if (ctx->compression_level == COMPRESSION_LEVEL_HIGH) {
  997.         start = 16;
  998.         long_filter_high_3800(decoded0, 16, 9, count);
  999.     } else if (ctx->compression_level == COMPRESSION_LEVEL_EXTRA_HIGH) {
  1000.         int order = 128, shift2 = 11;
  1001.  
  1002.         if (ctx->fileversion >= 3830) {
  1003.             order <<= 1;
  1004.             shift++;
  1005.             shift2++;
  1006.             long_filter_ehigh_3830(decoded0 + order, count - order);
  1007.         }
  1008.         start = order;
  1009.         long_filter_high_3800(decoded0, order, shift2, count);
  1010.     }
  1011.  
  1012.     while (count--) {
  1013.         if (ctx->compression_level == COMPRESSION_LEVEL_FAST) {
  1014.             *decoded0 = filter_fast_3320(p, *decoded0, 0, YDELAYA);
  1015.             decoded0++;
  1016.         } else {
  1017.             *decoded0 = filter_3800(p, *decoded0, 0, YDELAYA, YDELAYB,
  1018.                                     start, shift);
  1019.             decoded0++;
  1020.         }
  1021.  
  1022.         /* Combined */
  1023.         p->buf++;
  1024.         p->sample_pos++;
  1025.  
  1026.         /* Have we filled the history buffer? */
  1027.         if (p->buf == p->historybuffer + HISTORY_SIZE) {
  1028.             memmove(p->historybuffer, p->buf,
  1029.                     PREDICTOR_SIZE * sizeof(*p->historybuffer));
  1030.             p->buf = p->historybuffer;
  1031.         }
  1032.     }
  1033. }
  1034.  
  1035. static av_always_inline int predictor_update_3930(APEPredictor *p,
  1036.                                                   const int decoded, const int filter,
  1037.                                                   const int delayA)
  1038. {
  1039.     int32_t predictionA, sign;
  1040.     int32_t d0, d1, d2, d3;
  1041.  
  1042.     p->buf[delayA]     = p->lastA[filter];
  1043.     d0 = p->buf[delayA    ];
  1044.     d1 = p->buf[delayA    ] - p->buf[delayA - 1];
  1045.     d2 = p->buf[delayA - 1] - p->buf[delayA - 2];
  1046.     d3 = p->buf[delayA - 2] - p->buf[delayA - 3];
  1047.  
  1048.     predictionA = d0 * p->coeffsA[filter][0] +
  1049.                   d1 * p->coeffsA[filter][1] +
  1050.                   d2 * p->coeffsA[filter][2] +
  1051.                   d3 * p->coeffsA[filter][3];
  1052.  
  1053.     p->lastA[filter] = decoded + (predictionA >> 9);
  1054.     p->filterA[filter] = p->lastA[filter] + ((p->filterA[filter] * 31) >> 5);
  1055.  
  1056.     sign = APESIGN(decoded);
  1057.     p->coeffsA[filter][0] += ((d0 < 0) * 2 - 1) * sign;
  1058.     p->coeffsA[filter][1] += ((d1 < 0) * 2 - 1) * sign;
  1059.     p->coeffsA[filter][2] += ((d2 < 0) * 2 - 1) * sign;
  1060.     p->coeffsA[filter][3] += ((d3 < 0) * 2 - 1) * sign;
  1061.  
  1062.     return p->filterA[filter];
  1063. }
  1064.  
  1065. static void predictor_decode_stereo_3930(APEContext *ctx, int count)
  1066. {
  1067.     APEPredictor *p = &ctx->predictor;
  1068.     int32_t *decoded0 = ctx->decoded[0];
  1069.     int32_t *decoded1 = ctx->decoded[1];
  1070.  
  1071.     ape_apply_filters(ctx, ctx->decoded[0], ctx->decoded[1], count);
  1072.  
  1073.     while (count--) {
  1074.         /* Predictor Y */
  1075.         int Y = *decoded1, X = *decoded0;
  1076.         *decoded0 = predictor_update_3930(p, Y, 0, YDELAYA);
  1077.         decoded0++;
  1078.         *decoded1 = predictor_update_3930(p, X, 1, XDELAYA);
  1079.         decoded1++;
  1080.  
  1081.         /* Combined */
  1082.         p->buf++;
  1083.  
  1084.         /* Have we filled the history buffer? */
  1085.         if (p->buf == p->historybuffer + HISTORY_SIZE) {
  1086.             memmove(p->historybuffer, p->buf,
  1087.                     PREDICTOR_SIZE * sizeof(*p->historybuffer));
  1088.             p->buf = p->historybuffer;
  1089.         }
  1090.     }
  1091. }
  1092.  
  1093. static void predictor_decode_mono_3930(APEContext *ctx, int count)
  1094. {
  1095.     APEPredictor *p = &ctx->predictor;
  1096.     int32_t *decoded0 = ctx->decoded[0];
  1097.  
  1098.     ape_apply_filters(ctx, ctx->decoded[0], NULL, count);
  1099.  
  1100.     while (count--) {
  1101.         *decoded0 = predictor_update_3930(p, *decoded0, 0, YDELAYA);
  1102.         decoded0++;
  1103.  
  1104.         p->buf++;
  1105.  
  1106.         /* Have we filled the history buffer? */
  1107.         if (p->buf == p->historybuffer + HISTORY_SIZE) {
  1108.             memmove(p->historybuffer, p->buf,
  1109.                     PREDICTOR_SIZE * sizeof(*p->historybuffer));
  1110.             p->buf = p->historybuffer;
  1111.         }
  1112.     }
  1113. }
  1114.  
  1115. static av_always_inline int predictor_update_filter(APEPredictor *p,
  1116.                                                     const int decoded, const int filter,
  1117.                                                     const int delayA,  const int delayB,
  1118.                                                     const int adaptA,  const int adaptB)
  1119. {
  1120.     int32_t predictionA, predictionB, sign;
  1121.  
  1122.     p->buf[delayA]     = p->lastA[filter];
  1123.     p->buf[adaptA]     = APESIGN(p->buf[delayA]);
  1124.     p->buf[delayA - 1] = p->buf[delayA] - p->buf[delayA - 1];
  1125.     p->buf[adaptA - 1] = APESIGN(p->buf[delayA - 1]);
  1126.  
  1127.     predictionA = p->buf[delayA    ] * p->coeffsA[filter][0] +
  1128.                   p->buf[delayA - 1] * p->coeffsA[filter][1] +
  1129.                   p->buf[delayA - 2] * p->coeffsA[filter][2] +
  1130.                   p->buf[delayA - 3] * p->coeffsA[filter][3];
  1131.  
  1132.     /*  Apply a scaled first-order filter compression */
  1133.     p->buf[delayB]     = p->filterA[filter ^ 1] - ((p->filterB[filter] * 31) >> 5);
  1134.     p->buf[adaptB]     = APESIGN(p->buf[delayB]);
  1135.     p->buf[delayB - 1] = p->buf[delayB] - p->buf[delayB - 1];
  1136.     p->buf[adaptB - 1] = APESIGN(p->buf[delayB - 1]);
  1137.     p->filterB[filter] = p->filterA[filter ^ 1];
  1138.  
  1139.     predictionB = p->buf[delayB    ] * p->coeffsB[filter][0] +
  1140.                   p->buf[delayB - 1] * p->coeffsB[filter][1] +
  1141.                   p->buf[delayB - 2] * p->coeffsB[filter][2] +
  1142.                   p->buf[delayB - 3] * p->coeffsB[filter][3] +
  1143.                   p->buf[delayB - 4] * p->coeffsB[filter][4];
  1144.  
  1145.     p->lastA[filter] = decoded + ((predictionA + (predictionB >> 1)) >> 10);
  1146.     p->filterA[filter] = p->lastA[filter] + ((p->filterA[filter] * 31) >> 5);
  1147.  
  1148.     sign = APESIGN(decoded);
  1149.     p->coeffsA[filter][0] += p->buf[adaptA    ] * sign;
  1150.     p->coeffsA[filter][1] += p->buf[adaptA - 1] * sign;
  1151.     p->coeffsA[filter][2] += p->buf[adaptA - 2] * sign;
  1152.     p->coeffsA[filter][3] += p->buf[adaptA - 3] * sign;
  1153.     p->coeffsB[filter][0] += p->buf[adaptB    ] * sign;
  1154.     p->coeffsB[filter][1] += p->buf[adaptB - 1] * sign;
  1155.     p->coeffsB[filter][2] += p->buf[adaptB - 2] * sign;
  1156.     p->coeffsB[filter][3] += p->buf[adaptB - 3] * sign;
  1157.     p->coeffsB[filter][4] += p->buf[adaptB - 4] * sign;
  1158.  
  1159.     return p->filterA[filter];
  1160. }
  1161.  
  1162. static void predictor_decode_stereo_3950(APEContext *ctx, int count)
  1163. {
  1164.     APEPredictor *p = &ctx->predictor;
  1165.     int32_t *decoded0 = ctx->decoded[0];
  1166.     int32_t *decoded1 = ctx->decoded[1];
  1167.  
  1168.     ape_apply_filters(ctx, ctx->decoded[0], ctx->decoded[1], count);
  1169.  
  1170.     while (count--) {
  1171.         /* Predictor Y */
  1172.         *decoded0 = predictor_update_filter(p, *decoded0, 0, YDELAYA, YDELAYB,
  1173.                                             YADAPTCOEFFSA, YADAPTCOEFFSB);
  1174.         decoded0++;
  1175.         *decoded1 = predictor_update_filter(p, *decoded1, 1, XDELAYA, XDELAYB,
  1176.                                             XADAPTCOEFFSA, XADAPTCOEFFSB);
  1177.         decoded1++;
  1178.  
  1179.         /* Combined */
  1180.         p->buf++;
  1181.  
  1182.         /* Have we filled the history buffer? */
  1183.         if (p->buf == p->historybuffer + HISTORY_SIZE) {
  1184.             memmove(p->historybuffer, p->buf,
  1185.                     PREDICTOR_SIZE * sizeof(*p->historybuffer));
  1186.             p->buf = p->historybuffer;
  1187.         }
  1188.     }
  1189. }
  1190.  
  1191. static void predictor_decode_mono_3950(APEContext *ctx, int count)
  1192. {
  1193.     APEPredictor *p = &ctx->predictor;
  1194.     int32_t *decoded0 = ctx->decoded[0];
  1195.     int32_t predictionA, currentA, A, sign;
  1196.  
  1197.     ape_apply_filters(ctx, ctx->decoded[0], NULL, count);
  1198.  
  1199.     currentA = p->lastA[0];
  1200.  
  1201.     while (count--) {
  1202.         A = *decoded0;
  1203.  
  1204.         p->buf[YDELAYA] = currentA;
  1205.         p->buf[YDELAYA - 1] = p->buf[YDELAYA] - p->buf[YDELAYA - 1];
  1206.  
  1207.         predictionA = p->buf[YDELAYA    ] * p->coeffsA[0][0] +
  1208.                       p->buf[YDELAYA - 1] * p->coeffsA[0][1] +
  1209.                       p->buf[YDELAYA - 2] * p->coeffsA[0][2] +
  1210.                       p->buf[YDELAYA - 3] * p->coeffsA[0][3];
  1211.  
  1212.         currentA = A + (predictionA >> 10);
  1213.  
  1214.         p->buf[YADAPTCOEFFSA]     = APESIGN(p->buf[YDELAYA    ]);
  1215.         p->buf[YADAPTCOEFFSA - 1] = APESIGN(p->buf[YDELAYA - 1]);
  1216.  
  1217.         sign = APESIGN(A);
  1218.         p->coeffsA[0][0] += p->buf[YADAPTCOEFFSA    ] * sign;
  1219.         p->coeffsA[0][1] += p->buf[YADAPTCOEFFSA - 1] * sign;
  1220.         p->coeffsA[0][2] += p->buf[YADAPTCOEFFSA - 2] * sign;
  1221.         p->coeffsA[0][3] += p->buf[YADAPTCOEFFSA - 3] * sign;
  1222.  
  1223.         p->buf++;
  1224.  
  1225.         /* Have we filled the history buffer? */
  1226.         if (p->buf == p->historybuffer + HISTORY_SIZE) {
  1227.             memmove(p->historybuffer, p->buf,
  1228.                     PREDICTOR_SIZE * sizeof(*p->historybuffer));
  1229.             p->buf = p->historybuffer;
  1230.         }
  1231.  
  1232.         p->filterA[0] = currentA + ((p->filterA[0] * 31) >> 5);
  1233.         *(decoded0++) = p->filterA[0];
  1234.     }
  1235.  
  1236.     p->lastA[0] = currentA;
  1237. }
  1238.  
  1239. static void do_init_filter(APEFilter *f, int16_t *buf, int order)
  1240. {
  1241.     f->coeffs = buf;
  1242.     f->historybuffer = buf + order;
  1243.     f->delay       = f->historybuffer + order * 2;
  1244.     f->adaptcoeffs = f->historybuffer + order;
  1245.  
  1246.     memset(f->historybuffer, 0, (order * 2) * sizeof(*f->historybuffer));
  1247.     memset(f->coeffs, 0, order * sizeof(*f->coeffs));
  1248.     f->avg = 0;
  1249. }
  1250.  
  1251. static void init_filter(APEContext *ctx, APEFilter *f, int16_t *buf, int order)
  1252. {
  1253.     do_init_filter(&f[0], buf, order);
  1254.     do_init_filter(&f[1], buf + order * 3 + HISTORY_SIZE, order);
  1255. }
  1256.  
  1257. static void do_apply_filter(APEContext *ctx, int version, APEFilter *f,
  1258.                             int32_t *data, int count, int order, int fracbits)
  1259. {
  1260.     int res;
  1261.     int absres;
  1262.  
  1263.     while (count--) {
  1264.         /* round fixedpoint scalar product */
  1265.         res = ctx->adsp.scalarproduct_and_madd_int16(f->coeffs,
  1266.                                                      f->delay - order,
  1267.                                                      f->adaptcoeffs - order,
  1268.                                                      order, APESIGN(*data));
  1269.         res = (res + (1 << (fracbits - 1))) >> fracbits;
  1270.         res += *data;
  1271.         *data++ = res;
  1272.  
  1273.         /* Update the output history */
  1274.         *f->delay++ = av_clip_int16(res);
  1275.  
  1276.         if (version < 3980) {
  1277.             /* Version ??? to < 3.98 files (untested) */
  1278.             f->adaptcoeffs[0]  = (res == 0) ? 0 : ((res >> 28) & 8) - 4;
  1279.             f->adaptcoeffs[-4] >>= 1;
  1280.             f->adaptcoeffs[-8] >>= 1;
  1281.         } else {
  1282.             /* Version 3.98 and later files */
  1283.  
  1284.             /* Update the adaption coefficients */
  1285.             absres = FFABS(res);
  1286.             if (absres)
  1287.                 *f->adaptcoeffs = ((res & (-1<<31)) ^ (-1<<30)) >>
  1288.                                   (25 + (absres <= f->avg*3) + (absres <= f->avg*4/3));
  1289.             else
  1290.                 *f->adaptcoeffs = 0;
  1291.  
  1292.             f->avg += (absres - f->avg) / 16;
  1293.  
  1294.             f->adaptcoeffs[-1] >>= 1;
  1295.             f->adaptcoeffs[-2] >>= 1;
  1296.             f->adaptcoeffs[-8] >>= 1;
  1297.         }
  1298.  
  1299.         f->adaptcoeffs++;
  1300.  
  1301.         /* Have we filled the history buffer? */
  1302.         if (f->delay == f->historybuffer + HISTORY_SIZE + (order * 2)) {
  1303.             memmove(f->historybuffer, f->delay - (order * 2),
  1304.                     (order * 2) * sizeof(*f->historybuffer));
  1305.             f->delay = f->historybuffer + order * 2;
  1306.             f->adaptcoeffs = f->historybuffer + order;
  1307.         }
  1308.     }
  1309. }
  1310.  
  1311. static void apply_filter(APEContext *ctx, APEFilter *f,
  1312.                          int32_t *data0, int32_t *data1,
  1313.                          int count, int order, int fracbits)
  1314. {
  1315.     do_apply_filter(ctx, ctx->fileversion, &f[0], data0, count, order, fracbits);
  1316.     if (data1)
  1317.         do_apply_filter(ctx, ctx->fileversion, &f[1], data1, count, order, fracbits);
  1318. }
  1319.  
  1320. static void ape_apply_filters(APEContext *ctx, int32_t *decoded0,
  1321.                               int32_t *decoded1, int count)
  1322. {
  1323.     int i;
  1324.  
  1325.     for (i = 0; i < APE_FILTER_LEVELS; i++) {
  1326.         if (!ape_filter_orders[ctx->fset][i])
  1327.             break;
  1328.         apply_filter(ctx, ctx->filters[i], decoded0, decoded1, count,
  1329.                      ape_filter_orders[ctx->fset][i],
  1330.                      ape_filter_fracbits[ctx->fset][i]);
  1331.     }
  1332. }
  1333.  
  1334. static int init_frame_decoder(APEContext *ctx)
  1335. {
  1336.     int i, ret;
  1337.     if ((ret = init_entropy_decoder(ctx)) < 0)
  1338.         return ret;
  1339.     init_predictor_decoder(ctx);
  1340.  
  1341.     for (i = 0; i < APE_FILTER_LEVELS; i++) {
  1342.         if (!ape_filter_orders[ctx->fset][i])
  1343.             break;
  1344.         init_filter(ctx, ctx->filters[i], ctx->filterbuf[i],
  1345.                     ape_filter_orders[ctx->fset][i]);
  1346.     }
  1347.     return 0;
  1348. }
  1349.  
  1350. static void ape_unpack_mono(APEContext *ctx, int count)
  1351. {
  1352.     if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {
  1353.         /* We are pure silence, so we're done. */
  1354.         av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence mono\n");
  1355.         return;
  1356.     }
  1357.  
  1358.     ctx->entropy_decode_mono(ctx, count);
  1359.  
  1360.     /* Now apply the predictor decoding */
  1361.     ctx->predictor_decode_mono(ctx, count);
  1362.  
  1363.     /* Pseudo-stereo - just copy left channel to right channel */
  1364.     if (ctx->channels == 2) {
  1365.         memcpy(ctx->decoded[1], ctx->decoded[0], count * sizeof(*ctx->decoded[1]));
  1366.     }
  1367. }
  1368.  
  1369. static void ape_unpack_stereo(APEContext *ctx, int count)
  1370. {
  1371.     int32_t left, right;
  1372.     int32_t *decoded0 = ctx->decoded[0];
  1373.     int32_t *decoded1 = ctx->decoded[1];
  1374.  
  1375.     if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {
  1376.         /* We are pure silence, so we're done. */
  1377.         av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence stereo\n");
  1378.         return;
  1379.     }
  1380.  
  1381.     ctx->entropy_decode_stereo(ctx, count);
  1382.  
  1383.     /* Now apply the predictor decoding */
  1384.     ctx->predictor_decode_stereo(ctx, count);
  1385.  
  1386.     /* Decorrelate and scale to output depth */
  1387.     while (count--) {
  1388.         left = *decoded1 - (*decoded0 / 2);
  1389.         right = left + *decoded0;
  1390.  
  1391.         *(decoded0++) = left;
  1392.         *(decoded1++) = right;
  1393.     }
  1394. }
  1395.  
  1396. static int ape_decode_frame(AVCodecContext *avctx, void *data,
  1397.                             int *got_frame_ptr, AVPacket *avpkt)
  1398. {
  1399.     AVFrame *frame     = data;
  1400.     const uint8_t *buf = avpkt->data;
  1401.     APEContext *s = avctx->priv_data;
  1402.     uint8_t *sample8;
  1403.     int16_t *sample16;
  1404.     int32_t *sample24;
  1405.     int i, ch, ret;
  1406.     int blockstodecode;
  1407.  
  1408.     /* this should never be negative, but bad things will happen if it is, so
  1409.        check it just to make sure. */
  1410.     av_assert0(s->samples >= 0);
  1411.  
  1412.     if(!s->samples){
  1413.         uint32_t nblocks, offset;
  1414.         int buf_size;
  1415.  
  1416.         if (!avpkt->size) {
  1417.             *got_frame_ptr = 0;
  1418.             return 0;
  1419.         }
  1420.         if (avpkt->size < 8) {
  1421.             av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
  1422.             return AVERROR_INVALIDDATA;
  1423.         }
  1424.         buf_size = avpkt->size & ~3;
  1425.         if (buf_size != avpkt->size) {
  1426.             av_log(avctx, AV_LOG_WARNING, "packet size is not a multiple of 4. "
  1427.                    "extra bytes at the end will be skipped.\n");
  1428.         }
  1429.         if (s->fileversion < 3950) // previous versions overread two bytes
  1430.             buf_size += 2;
  1431.         av_fast_padded_malloc(&s->data, &s->data_size, buf_size);
  1432.         if (!s->data)
  1433.             return AVERROR(ENOMEM);
  1434.         s->bdsp.bswap_buf((uint32_t *) s->data, (const uint32_t *) buf,
  1435.                           buf_size >> 2);
  1436.         memset(s->data + (buf_size & ~3), 0, buf_size & 3);
  1437.         s->ptr = s->data;
  1438.         s->data_end = s->data + buf_size;
  1439.  
  1440.         nblocks = bytestream_get_be32(&s->ptr);
  1441.         offset  = bytestream_get_be32(&s->ptr);
  1442.         if (s->fileversion >= 3900) {
  1443.             if (offset > 3) {
  1444.                 av_log(avctx, AV_LOG_ERROR, "Incorrect offset passed\n");
  1445.                 s->data = NULL;
  1446.                 return AVERROR_INVALIDDATA;
  1447.             }
  1448.             if (s->data_end - s->ptr < offset) {
  1449.                 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
  1450.                 return AVERROR_INVALIDDATA;
  1451.             }
  1452.             s->ptr += offset;
  1453.         } else {
  1454.             if ((ret = init_get_bits8(&s->gb, s->ptr, s->data_end - s->ptr)) < 0)
  1455.                 return ret;
  1456.             if (s->fileversion > 3800)
  1457.                 skip_bits_long(&s->gb, offset * 8);
  1458.             else
  1459.                 skip_bits_long(&s->gb, offset);
  1460.         }
  1461.  
  1462.         if (!nblocks || nblocks > INT_MAX) {
  1463.             av_log(avctx, AV_LOG_ERROR, "Invalid sample count: %"PRIu32".\n",
  1464.                    nblocks);
  1465.             return AVERROR_INVALIDDATA;
  1466.         }
  1467.  
  1468.         /* Initialize the frame decoder */
  1469.         if (init_frame_decoder(s) < 0) {
  1470.             av_log(avctx, AV_LOG_ERROR, "Error reading frame header\n");
  1471.             return AVERROR_INVALIDDATA;
  1472.         }
  1473.         s->samples = nblocks;
  1474.     }
  1475.  
  1476.     if (!s->data) {
  1477.         *got_frame_ptr = 0;
  1478.         return avpkt->size;
  1479.     }
  1480.  
  1481.     blockstodecode = FFMIN(s->blocks_per_loop, s->samples);
  1482.     // for old files coefficients were not interleaved,
  1483.     // so we need to decode all of them at once
  1484.     if (s->fileversion < 3930)
  1485.         blockstodecode = s->samples;
  1486.  
  1487.     /* reallocate decoded sample buffer if needed */
  1488.     av_fast_malloc(&s->decoded_buffer, &s->decoded_size,
  1489.                    2 * FFALIGN(blockstodecode, 8) * sizeof(*s->decoded_buffer));
  1490.     if (!s->decoded_buffer)
  1491.         return AVERROR(ENOMEM);
  1492.     memset(s->decoded_buffer, 0, s->decoded_size);
  1493.     s->decoded[0] = s->decoded_buffer;
  1494.     s->decoded[1] = s->decoded_buffer + FFALIGN(blockstodecode, 8);
  1495.  
  1496.     /* get output buffer */
  1497.     frame->nb_samples = blockstodecode;
  1498.     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
  1499.         return ret;
  1500.  
  1501.     s->error=0;
  1502.  
  1503.     if ((s->channels == 1) || (s->frameflags & APE_FRAMECODE_PSEUDO_STEREO))
  1504.         ape_unpack_mono(s, blockstodecode);
  1505.     else
  1506.         ape_unpack_stereo(s, blockstodecode);
  1507.     emms_c();
  1508.  
  1509.     if (s->error) {
  1510.         s->samples=0;
  1511.         av_log(avctx, AV_LOG_ERROR, "Error decoding frame\n");
  1512.         return AVERROR_INVALIDDATA;
  1513.     }
  1514.  
  1515.     switch (s->bps) {
  1516.     case 8:
  1517.         for (ch = 0; ch < s->channels; ch++) {
  1518.             sample8 = (uint8_t *)frame->data[ch];
  1519.             for (i = 0; i < blockstodecode; i++)
  1520.                 *sample8++ = (s->decoded[ch][i] + 0x80) & 0xff;
  1521.         }
  1522.         break;
  1523.     case 16:
  1524.         for (ch = 0; ch < s->channels; ch++) {
  1525.             sample16 = (int16_t *)frame->data[ch];
  1526.             for (i = 0; i < blockstodecode; i++)
  1527.                 *sample16++ = s->decoded[ch][i];
  1528.         }
  1529.         break;
  1530.     case 24:
  1531.         for (ch = 0; ch < s->channels; ch++) {
  1532.             sample24 = (int32_t *)frame->data[ch];
  1533.             for (i = 0; i < blockstodecode; i++)
  1534.                 *sample24++ = s->decoded[ch][i] << 8;
  1535.         }
  1536.         break;
  1537.     }
  1538.  
  1539.     s->samples -= blockstodecode;
  1540.  
  1541.     *got_frame_ptr = 1;
  1542.  
  1543.     return !s->samples ? avpkt->size : 0;
  1544. }
  1545.  
  1546. static void ape_flush(AVCodecContext *avctx)
  1547. {
  1548.     APEContext *s = avctx->priv_data;
  1549.     s->samples= 0;
  1550. }
  1551.  
  1552. #define OFFSET(x) offsetof(APEContext, x)
  1553. #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
  1554. static const AVOption options[] = {
  1555.     { "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" },
  1556.     { "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" },
  1557.     { NULL},
  1558. };
  1559.  
  1560. static const AVClass ape_decoder_class = {
  1561.     .class_name = "APE decoder",
  1562.     .item_name  = av_default_item_name,
  1563.     .option     = options,
  1564.     .version    = LIBAVUTIL_VERSION_INT,
  1565. };
  1566.  
  1567. AVCodec ff_ape_decoder = {
  1568.     .name           = "ape",
  1569.     .long_name      = NULL_IF_CONFIG_SMALL("Monkey's Audio"),
  1570.     .type           = AVMEDIA_TYPE_AUDIO,
  1571.     .id             = AV_CODEC_ID_APE,
  1572.     .priv_data_size = sizeof(APEContext),
  1573.     .init           = ape_decode_init,
  1574.     .close          = ape_decode_close,
  1575.     .decode         = ape_decode_frame,
  1576.     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DELAY |
  1577.                       AV_CODEC_CAP_DR1,
  1578.     .flush          = ape_flush,
  1579.     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
  1580.                                                       AV_SAMPLE_FMT_S16P,
  1581.                                                       AV_SAMPLE_FMT_S32P,
  1582.                                                       AV_SAMPLE_FMT_NONE },
  1583.     .priv_class     = &ape_decoder_class,
  1584. };
  1585.