2 * Monkey's Audio lossless audio decoder
3 * Copyright (c) 2007 Benjamin Zores <ben@geexbox.org>
4 * based upon libdemac from Dave Chapman.
6 * This file is part of FFmpeg.
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.
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.
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
25 #include "libavutil/avassert.h"
26 #include "libavutil/channel_layout.h"
27 #include "libavutil/opt.h"
28 #include "lossless_audiodsp.h"
31 #include "bytestream.h"
38 * Monkey's Audio lossless audio decoder
41 #define MAX_CHANNELS 2
42 #define MAX_BYTESPERSAMPLE 3
44 #define APE_FRAMECODE_MONO_SILENCE 1
45 #define APE_FRAMECODE_STEREO_SILENCE 3
46 #define APE_FRAMECODE_PSEUDO_STEREO 4
48 #define HISTORY_SIZE 512
49 #define PREDICTOR_ORDER 8
50 /** Total size of all predictor histories */
51 #define PREDICTOR_SIZE 50
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)
58 #define YADAPTCOEFFSA 18
59 #define XADAPTCOEFFSA 14
60 #define YADAPTCOEFFSB 10
61 #define XADAPTCOEFFSB 5
64 * Possible compression levels
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
76 #define APE_FILTER_LEVELS 3
78 /** Filter orders depending on compression level */
79 static const uint16_t ape_filter_orders
[5][APE_FILTER_LEVELS
] = {
87 /** Filter fraction bits depending on compression level */
88 static const uint8_t ape_filter_fracbits
[5][APE_FILTER_LEVELS
] = {
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
107 typedef struct APERice
{
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
119 /** Filter histories */
120 typedef struct APEPredictor
{
128 int32_t coeffsA
[2][4]; ///< adaption coefficients
129 int32_t coeffsB
[2][5]; ///< adaption coefficients
130 int32_t historybuffer
[HISTORY_SIZE
+ PREDICTOR_SIZE
];
132 unsigned int sample_pos
;
135 /** Decoder context */
136 typedef struct APEContext
{
137 AVClass
*class; ///< class for AVOptions
138 AVCodecContext
*avctx
;
139 BswapDSPContext bdsp
;
140 LLAudDSPContext adsp
;
142 int samples
; ///< samples left to decode in current frame
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
150 uint32_t CRC
; ///< frame CRC
151 int frameflags
; ///< frame flags
152 APEPredictor predictor
; ///< predictor used for final reconstruction
154 int32_t *decoded_buffer
;
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
159 int16_t* filterbuf
[APE_FILTER_LEVELS
]; ///< filter memory
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
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
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
);
180 static void ape_apply_filters(APEContext
*ctx
, int32_t *decoded0
,
181 int32_t *decoded1
, int count
);
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
);
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
);
200 static av_cold
int ape_decode_close(AVCodecContext
*avctx
)
202 APEContext
*s
= avctx
->priv_data
;
205 for (i
= 0; i
< APE_FILTER_LEVELS
; i
++)
206 av_freep(&s
->filterbuf
[i
]);
208 av_freep(&s
->decoded_buffer
);
210 s
->decoded_size
= s
->data_size
= 0;
215 static av_cold
int ape_decode_init(AVCodecContext
*avctx
)
217 APEContext
*s
= avctx
->priv_data
;
220 if (avctx
->extradata_size
!= 6) {
221 av_log(avctx
, AV_LOG_ERROR
, "Incorrect extradata\n");
222 return AVERROR(EINVAL
);
224 if (avctx
->channels
> 2) {
225 av_log(avctx
, AV_LOG_ERROR
, "Only mono and stereo is supported\n");
226 return AVERROR(EINVAL
);
228 s
->bps
= avctx
->bits_per_coded_sample
;
231 avctx
->sample_fmt
= AV_SAMPLE_FMT_U8P
;
234 avctx
->sample_fmt
= AV_SAMPLE_FMT_S16P
;
237 avctx
->sample_fmt
= AV_SAMPLE_FMT_S32P
;
240 avpriv_request_sample(avctx
,
241 "%d bits per coded sample", s
->bps
);
242 return AVERROR_PATCHWELCOME
;
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);
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
;
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
])
263 FF_ALLOC_OR_GOTO(avctx
, s
->filterbuf
[i
],
264 (ape_filter_orders
[s
->fset
][i
] * 3 + HISTORY_SIZE
) * 4,
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
;
281 s
->entropy_decode_mono
= entropy_decode_mono_3990
;
282 s
->entropy_decode_stereo
= entropy_decode_stereo_3990
;
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
;
292 s
->predictor_decode_mono
= predictor_decode_mono_3950
;
293 s
->predictor_decode_stereo
= predictor_decode_stereo_3950
;
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
;
302 ape_decode_close(avctx
);
303 return AVERROR(ENOMEM
);
307 * @name APE range decoding functions
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)
317 /** Start the decoder */
318 static inline void range_start_decoding(APEContext
*ctx
)
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
;
325 /** Perform normalization */
326 static inline void range_dec_normalize(APEContext
*ctx
)
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
;
336 ctx
->rc
.low
= (ctx
->rc
.low
<< 8) | ((ctx
->rc
.buffer
>> 1) & 0xFF);
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
347 static inline int range_decode_culfreq(APEContext
*ctx
, int tot_f
)
349 range_dec_normalize(ctx
);
350 ctx
->rc
.help
= ctx
->rc
.range
/ tot_f
;
351 return ctx
->rc
.low
/ ctx
->rc
.help
;
355 * Decode value with given size in bits
356 * @param ctx decoder context
357 * @param shift number of bits to decode
359 static inline int range_decode_culshift(APEContext
*ctx
, int shift
)
361 range_dec_normalize(ctx
);
362 ctx
->rc
.help
= ctx
->rc
.range
>> shift
;
363 return ctx
->rc
.low
/ ctx
->rc
.help
;
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)
373 static inline void range_decode_update(APEContext
*ctx
, int sy_f
, int lt_f
)
375 ctx
->rc
.low
-= ctx
->rc
.help
* lt_f
;
376 ctx
->rc
.range
= ctx
->rc
.help
* sy_f
;
379 /** Decode n bits (n <= 16) without modelling */
380 static inline int range_decode_bits(APEContext
*ctx
, int n
)
382 int sym
= range_decode_culshift(ctx
, n
);
383 range_decode_update(ctx
, 1, sym
);
388 #define MODEL_ELEMENTS 64
391 * Fixed probabilities for symbols in Monkey Audio version 3.97
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,
400 * Probability ranges for symbols in Monkey Audio version 3.97
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,
409 * Fixed probabilities for symbols in Monkey Audio version 3.98
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,
418 * Probability ranges for symbols in Monkey Audio version 3.98
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,
428 * @param ctx decoder context
429 * @param counts probability range start position
430 * @param counts_diff probability range widths
432 static inline int range_get_symbol(APEContext
*ctx
,
433 const uint16_t counts
[],
434 const uint16_t counts_diff
[])
438 cf
= range_decode_culshift(ctx
, 16);
441 symbol
= cf
- 65535 + 63;
442 range_decode_update(ctx
, 1, cf
);
447 /* figure out the symbol inefficiently; a binary search would be much better */
448 for (symbol
= 0; counts
[symbol
+ 1] <= cf
; symbol
++);
450 range_decode_update(ctx
, counts_diff
[symbol
], counts
[symbol
]);
454 /** @} */ // group rangecoder
456 static inline void update_rice(APERice
*rice
, unsigned int x
)
458 int lim
= rice
->k
? (1 << (rice
->k
+ 4)) : 0;
459 rice
->ksum
+= ((x
+ 1) / 2) - ((rice
->ksum
+ 16) >> 5);
461 if (rice
->ksum
< lim
)
463 else if (rice
->ksum
>= (1 << (rice
->k
+ 5)))
467 static inline int get_rice_ook(GetBitContext
*gb
, int k
)
471 x
= get_unary(gb
, 1, get_bits_left(gb
));
474 x
= (x
<< k
) | get_bits(gb
, k
);
479 static inline int ape_decode_value_3860(APEContext
*ctx
, GetBitContext
*gb
,
482 unsigned int x
, overflow
;
484 overflow
= get_unary(gb
, 1, get_bits_left(gb
));
486 if (ctx
->fileversion
> 3880) {
487 while (overflow
>= 16) {
495 else if(rice
->k
<= MIN_CACHE_BITS
) {
496 x
= (overflow
<< rice
->k
) + get_bits(gb
, rice
->k
);
498 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Too many bits: %d\n", rice
->k
);
499 return AVERROR_INVALIDDATA
;
501 rice
->ksum
+= x
- (rice
->ksum
+ 8 >> 4);
502 if (rice
->ksum
< (rice
->k
? 1 << (rice
->k
+ 4) : 0))
504 else if (rice
->ksum
>= (1 << (rice
->k
+ 5)) && rice
->k
< 24)
507 /* Convert to signed */
514 static inline int ape_decode_value_3900(APEContext
*ctx
, APERice
*rice
)
516 unsigned int x
, overflow
;
519 overflow
= range_get_symbol(ctx
, counts_3970
, counts_diff_3970
);
521 if (overflow
== (MODEL_ELEMENTS
- 1)) {
522 tmpk
= range_decode_bits(ctx
, 5);
525 tmpk
= (rice
->k
< 1) ? 0 : rice
->k
- 1;
527 if (tmpk
<= 16 || ctx
->fileversion
< 3910) {
529 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Too many bits: %d\n", tmpk
);
530 return AVERROR_INVALIDDATA
;
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);
537 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Too many bits: %d\n", tmpk
);
538 return AVERROR_INVALIDDATA
;
540 x
+= overflow
<< tmpk
;
542 update_rice(rice
, x
);
544 /* Convert to signed */
551 static inline int ape_decode_value_3990(APEContext
*ctx
, APERice
*rice
)
553 unsigned int x
, overflow
;
556 pivot
= rice
->ksum
>> 5;
560 overflow
= range_get_symbol(ctx
, counts_3980
, counts_diff_3980
);
562 if (overflow
== (MODEL_ELEMENTS
- 1)) {
563 overflow
= range_decode_bits(ctx
, 16) << 16;
564 overflow
|= range_decode_bits(ctx
, 16);
567 if (pivot
< 0x10000) {
568 base
= range_decode_culfreq(ctx
, pivot
);
569 range_decode_update(ctx
, 1, base
);
571 int base_hi
= pivot
, base_lo
;
574 while (base_hi
& ~0xFFFF) {
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
);
583 base
= (base_hi
<< bbits
) + base_lo
;
586 x
= base
+ overflow
* pivot
;
588 update_rice(rice
, x
);
590 /* Convert to signed */
597 static void decode_array_0000(APEContext
*ctx
, GetBitContext
*gb
,
598 int32_t *out
, APERice
*rice
, int blockstodecode
)
601 int ksummax
, ksummin
;
604 for (i
= 0; i
< 5; i
++) {
605 out
[i
] = get_rice_ook(&ctx
->gb
, 10);
606 rice
->ksum
+= out
[i
];
608 rice
->k
= av_log2(rice
->ksum
/ 10) + 1;
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;
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
) {
625 ksummin
= rice
->k
? ksummin
>> 1 : 0;
628 while (rice
->ksum
>= ksummax
) {
633 ksummin
= ksummin
? ksummin
<< 1 : 128;
637 for (i
= 0; i
< blockstodecode
; i
++) {
639 out
[i
] = (out
[i
] >> 1) + 1;
641 out
[i
] = -(out
[i
] >> 1);
645 static void entropy_decode_mono_0000(APEContext
*ctx
, int blockstodecode
)
647 decode_array_0000(ctx
, &ctx
->gb
, ctx
->decoded
[0], &ctx
->riceY
,
651 static void entropy_decode_stereo_0000(APEContext
*ctx
, int blockstodecode
)
653 decode_array_0000(ctx
, &ctx
->gb
, ctx
->decoded
[0], &ctx
->riceY
,
655 decode_array_0000(ctx
, &ctx
->gb
, ctx
->decoded
[1], &ctx
->riceX
,
659 static void entropy_decode_mono_3860(APEContext
*ctx
, int blockstodecode
)
661 int32_t *decoded0
= ctx
->decoded
[0];
663 while (blockstodecode
--)
664 *decoded0
++ = ape_decode_value_3860(ctx
, &ctx
->gb
, &ctx
->riceY
);
667 static void entropy_decode_stereo_3860(APEContext
*ctx
, int blockstodecode
)
669 int32_t *decoded0
= ctx
->decoded
[0];
670 int32_t *decoded1
= ctx
->decoded
[1];
671 int blocks
= blockstodecode
;
673 while (blockstodecode
--)
674 *decoded0
++ = ape_decode_value_3860(ctx
, &ctx
->gb
, &ctx
->riceY
);
676 *decoded1
++ = ape_decode_value_3860(ctx
, &ctx
->gb
, &ctx
->riceX
);
679 static void entropy_decode_mono_3900(APEContext
*ctx
, int blockstodecode
)
681 int32_t *decoded0
= ctx
->decoded
[0];
683 while (blockstodecode
--)
684 *decoded0
++ = ape_decode_value_3900(ctx
, &ctx
->riceY
);
687 static void entropy_decode_stereo_3900(APEContext
*ctx
, int blockstodecode
)
689 int32_t *decoded0
= ctx
->decoded
[0];
690 int32_t *decoded1
= ctx
->decoded
[1];
691 int blocks
= blockstodecode
;
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
698 range_start_decoding(ctx
);
700 *decoded1
++ = ape_decode_value_3900(ctx
, &ctx
->riceX
);
703 static void entropy_decode_stereo_3930(APEContext
*ctx
, int blockstodecode
)
705 int32_t *decoded0
= ctx
->decoded
[0];
706 int32_t *decoded1
= ctx
->decoded
[1];
708 while (blockstodecode
--) {
709 *decoded0
++ = ape_decode_value_3900(ctx
, &ctx
->riceY
);
710 *decoded1
++ = ape_decode_value_3900(ctx
, &ctx
->riceX
);
714 static void entropy_decode_mono_3990(APEContext
*ctx
, int blockstodecode
)
716 int32_t *decoded0
= ctx
->decoded
[0];
718 while (blockstodecode
--)
719 *decoded0
++ = ape_decode_value_3990(ctx
, &ctx
->riceY
);
722 static void entropy_decode_stereo_3990(APEContext
*ctx
, int blockstodecode
)
724 int32_t *decoded0
= ctx
->decoded
[0];
725 int32_t *decoded1
= ctx
->decoded
[1];
727 while (blockstodecode
--) {
728 *decoded0
++ = ape_decode_value_3990(ctx
, &ctx
->riceY
);
729 *decoded1
++ = ape_decode_value_3990(ctx
, &ctx
->riceX
);
733 static int init_entropy_decoder(APEContext
*ctx
)
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
);
741 ctx
->CRC
= get_bits_long(&ctx
->gb
, 32);
744 /* Read the frame flags if they exist */
746 if ((ctx
->fileversion
> 3820) && (ctx
->CRC
& 0x80000000)) {
747 ctx
->CRC
&= ~0x80000000;
749 if (ctx
->data_end
- ctx
->ptr
< 6)
750 return AVERROR_INVALIDDATA
;
751 ctx
->frameflags
= bytestream_get_be32(&ctx
->ptr
);
754 /* Initialize the rice structs */
756 ctx
->riceX
.ksum
= (1 << ctx
->riceX
.k
) * 16;
758 ctx
->riceY
.ksum
= (1 << ctx
->riceY
.k
) * 16;
760 if (ctx
->fileversion
>= 3900) {
761 /* The first 8 bits of input are ignored. */
764 range_start_decoding(ctx
);
770 static const int32_t initial_coeffs_fast_3320
[1] = {
774 static const int32_t initial_coeffs_a_3800
[3] = {
778 static const int32_t initial_coeffs_b_3800
[2] = {
782 static const int32_t initial_coeffs_3930
[4] = {
786 static void init_predictor_decoder(APEContext
*ctx
)
788 APEPredictor
*p
= &ctx
->predictor
;
790 /* Zero the history buffers */
791 memset(p
->historybuffer
, 0, PREDICTOR_SIZE
* sizeof(*p
->historybuffer
));
792 p
->buf
= p
->historybuffer
;
794 /* Initialize and zero the coefficients */
795 if (ctx
->fileversion
< 3930) {
796 if (ctx
->compression_level
== COMPRESSION_LEVEL_FAST
) {
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
));
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
));
808 memcpy(p
->coeffsA
[0], initial_coeffs_3930
, sizeof(initial_coeffs_3930
));
809 memcpy(p
->coeffsA
[1], initial_coeffs_3930
, sizeof(initial_coeffs_3930
));
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
));
819 p
->filterA
[0] = p
->filterA
[1] = 0;
820 p
->filterB
[0] = p
->filterB
[1] = 0;
821 p
->lastA
[0] = p
->lastA
[1] = 0;
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);
831 static av_always_inline
int filter_fast_3320(APEPredictor
*p
,
832 const int decoded
, const int filter
,
837 p
->buf
[delayA
] = p
->lastA
[filter
];
838 if (p
->sample_pos
< 3) {
839 p
->lastA
[filter
] = decoded
;
840 p
->filterA
[filter
] = decoded
;
844 predictionA
= p
->buf
[delayA
] * 2 - p
->buf
[delayA
- 1];
845 p
->lastA
[filter
] = decoded
+ (predictionA
* p
->coeffsA
[filter
][0] >> 9);
847 if ((decoded
^ predictionA
) > 0)
848 p
->coeffsA
[filter
][0]++;
850 p
->coeffsA
[filter
][0]--;
852 p
->filterA
[filter
] += p
->lastA
[filter
];
854 return p
->filterA
[filter
];
857 static av_always_inline
int filter_3800(APEPredictor
*p
,
858 const int decoded
, const int filter
,
859 const int delayA
, const int delayB
,
860 const int start
, const int shift
)
862 int32_t predictionA
, predictionB
, sign
;
863 int32_t d0
, d1
, d2
, d3
, d4
;
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
;
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];
880 predictionA
= d0
* p
->coeffsA
[filter
][0] +
881 d1
* p
->coeffsA
[filter
][1] +
882 d2
* p
->coeffsA
[filter
][2];
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
;
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
;
896 p
->filterB
[filter
] = p
->lastA
[filter
] + (predictionB
>> shift
);
897 p
->filterA
[filter
] = p
->filterB
[filter
] + ((p
->filterA
[filter
] * 31) >> 5);
899 return p
->filterA
[filter
];
902 static void long_filter_high_3800(int32_t *buffer
, int order
, int shift
,
903 int32_t *coeffs
, int32_t *delay
, int length
)
906 int32_t dotprod
, sign
;
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
++) {
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
;
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
];
925 static void long_filter_ehigh_3830(int32_t *buffer
, int length
)
928 int32_t dotprod
, sign
;
929 int32_t coeffs
[8] = { 0 }, delay
[8] = { 0 };
931 for (i
= 0; i
< length
; i
++) {
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
;
938 for (j
= 7; j
> 0; j
--)
939 delay
[j
] = delay
[j
- 1];
940 delay
[0] = buffer
[i
];
941 buffer
[i
] -= dotprod
>> 9;
945 static void predictor_decode_stereo_3800(APEContext
*ctx
, int count
)
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;
953 if (ctx
->compression_level
== COMPRESSION_LEVEL_HIGH
) {
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;
960 if (ctx
->fileversion
>= 3830) {
964 long_filter_ehigh_3830(decoded0
+ order
, count
- order
);
965 long_filter_ehigh_3830(decoded1
+ order
, count
- order
);
968 long_filter_high_3800(decoded0
, order
, shift2
, coeffs
, delay
, count
);
969 long_filter_high_3800(decoded1
, order
, shift2
, coeffs
, delay
, count
);
973 int X
= *decoded0
, Y
= *decoded1
;
974 if (ctx
->compression_level
== COMPRESSION_LEVEL_FAST
) {
975 *decoded0
= filter_fast_3320(p
, Y
, 0, YDELAYA
);
977 *decoded1
= filter_fast_3320(p
, X
, 1, XDELAYA
);
980 *decoded0
= filter_3800(p
, Y
, 0, YDELAYA
, YDELAYB
,
983 *decoded1
= filter_3800(p
, X
, 1, XDELAYA
, XDELAYB
,
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
;
1001 static void predictor_decode_mono_3800(APEContext
*ctx
, int count
)
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;
1008 if (ctx
->compression_level
== COMPRESSION_LEVEL_HIGH
) {
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;
1014 if (ctx
->fileversion
>= 3830) {
1018 long_filter_ehigh_3830(decoded0
+ order
, count
- order
);
1021 long_filter_high_3800(decoded0
, order
, shift2
, coeffs
, delay
, count
);
1025 if (ctx
->compression_level
== COMPRESSION_LEVEL_FAST
) {
1026 *decoded0
= filter_fast_3320(p
, *decoded0
, 0, YDELAYA
);
1029 *decoded0
= filter_3800(p
, *decoded0
, 0, YDELAYA
, YDELAYB
,
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
;
1047 static av_always_inline
int predictor_update_3930(APEPredictor
*p
,
1048 const int decoded
, const int filter
,
1051 int32_t predictionA
, sign
;
1052 int32_t d0
, d1
, d2
, d3
;
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];
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];
1065 p
->lastA
[filter
] = decoded
+ (predictionA
>> 9);
1066 p
->filterA
[filter
] = p
->lastA
[filter
] + ((p
->filterA
[filter
] * 31) >> 5);
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
;
1074 return p
->filterA
[filter
];
1077 static void predictor_decode_stereo_3930(APEContext
*ctx
, int count
)
1079 APEPredictor
*p
= &ctx
->predictor
;
1080 int32_t *decoded0
= ctx
->decoded
[0];
1081 int32_t *decoded1
= ctx
->decoded
[1];
1083 ape_apply_filters(ctx
, ctx
->decoded
[0], ctx
->decoded
[1], count
);
1087 int Y
= *decoded1
, X
= *decoded0
;
1088 *decoded0
= predictor_update_3930(p
, Y
, 0, YDELAYA
);
1090 *decoded1
= predictor_update_3930(p
, X
, 1, XDELAYA
);
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
;
1105 static void predictor_decode_mono_3930(APEContext
*ctx
, int count
)
1107 APEPredictor
*p
= &ctx
->predictor
;
1108 int32_t *decoded0
= ctx
->decoded
[0];
1110 ape_apply_filters(ctx
, ctx
->decoded
[0], NULL
, count
);
1113 *decoded0
= predictor_update_3930(p
, *decoded0
, 0, YDELAYA
);
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
;
1127 static av_always_inline
int predictor_update_filter(APEPredictor
*p
,
1128 const int decoded
, const int filter
,
1129 const int delayA
, const int delayB
,
1130 const int adaptA
, const int adaptB
)
1132 int32_t predictionA
, predictionB
, sign
;
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]);
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];
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];
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];
1157 p
->lastA
[filter
] = decoded
+ ((predictionA
+ (predictionB
>> 1)) >> 10);
1158 p
->filterA
[filter
] = p
->lastA
[filter
] + ((p
->filterA
[filter
] * 31) >> 5);
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
;
1171 return p
->filterA
[filter
];
1174 static void predictor_decode_stereo_3950(APEContext
*ctx
, int count
)
1176 APEPredictor
*p
= &ctx
->predictor
;
1177 int32_t *decoded0
= ctx
->decoded
[0];
1178 int32_t *decoded1
= ctx
->decoded
[1];
1180 ape_apply_filters(ctx
, ctx
->decoded
[0], ctx
->decoded
[1], count
);
1184 *decoded0
= predictor_update_filter(p
, *decoded0
, 0, YDELAYA
, YDELAYB
,
1185 YADAPTCOEFFSA
, YADAPTCOEFFSB
);
1187 *decoded1
= predictor_update_filter(p
, *decoded1
, 1, XDELAYA
, XDELAYB
,
1188 XADAPTCOEFFSA
, XADAPTCOEFFSB
);
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
;
1203 static void predictor_decode_mono_3950(APEContext
*ctx
, int count
)
1205 APEPredictor
*p
= &ctx
->predictor
;
1206 int32_t *decoded0
= ctx
->decoded
[0];
1207 int32_t predictionA
, currentA
, A
, sign
;
1209 ape_apply_filters(ctx
, ctx
->decoded
[0], NULL
, count
);
1211 currentA
= p
->lastA
[0];
1216 p
->buf
[YDELAYA
] = currentA
;
1217 p
->buf
[YDELAYA
- 1] = p
->buf
[YDELAYA
] - p
->buf
[YDELAYA
- 1];
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];
1224 currentA
= A
+ (predictionA
>> 10);
1226 p
->buf
[YADAPTCOEFFSA
] = APESIGN(p
->buf
[YDELAYA
]);
1227 p
->buf
[YADAPTCOEFFSA
- 1] = APESIGN(p
->buf
[YDELAYA
- 1]);
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
;
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
;
1244 p
->filterA
[0] = currentA
+ ((p
->filterA
[0] * 31) >> 5);
1245 *(decoded0
++) = p
->filterA
[0];
1248 p
->lastA
[0] = currentA
;
1251 static void do_init_filter(APEFilter
*f
, int16_t *buf
, int order
)
1254 f
->historybuffer
= buf
+ order
;
1255 f
->delay
= f
->historybuffer
+ order
* 2;
1256 f
->adaptcoeffs
= f
->historybuffer
+ order
;
1258 memset(f
->historybuffer
, 0, (order
* 2) * sizeof(*f
->historybuffer
));
1259 memset(f
->coeffs
, 0, order
* sizeof(*f
->coeffs
));
1263 static void init_filter(APEContext
*ctx
, APEFilter
*f
, int16_t *buf
, int order
)
1265 do_init_filter(&f
[0], buf
, order
);
1266 do_init_filter(&f
[1], buf
+ order
* 3 + HISTORY_SIZE
, order
);
1269 static void do_apply_filter(APEContext
*ctx
, int version
, APEFilter
*f
,
1270 int32_t *data
, int count
, int order
, int fracbits
)
1276 /* round fixedpoint scalar product */
1277 res
= ctx
->adsp
.scalarproduct_and_madd_int16(f
->coeffs
,
1279 f
->adaptcoeffs
- order
,
1280 order
, APESIGN(*data
));
1281 res
= (res
+ (1 << (fracbits
- 1))) >> fracbits
;
1285 /* Update the output history */
1286 *f
->delay
++ = av_clip_int16(res
);
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;
1294 /* Version 3.98 and later files */
1296 /* Update the adaption coefficients */
1297 absres
= FFABS(res
);
1299 *f
->adaptcoeffs
= ((res
& (-1<<31)) ^ (-1<<30)) >>
1300 (25 + (absres
<= f
->avg
*3) + (absres
<= f
->avg
*4/3));
1302 *f
->adaptcoeffs
= 0;
1304 f
->avg
+= (absres
- f
->avg
) / 16;
1306 f
->adaptcoeffs
[-1] >>= 1;
1307 f
->adaptcoeffs
[-2] >>= 1;
1308 f
->adaptcoeffs
[-8] >>= 1;
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
;
1323 static void apply_filter(APEContext
*ctx
, APEFilter
*f
,
1324 int32_t *data0
, int32_t *data1
,
1325 int count
, int order
, int fracbits
)
1327 do_apply_filter(ctx
, ctx
->fileversion
, &f
[0], data0
, count
, order
, fracbits
);
1329 do_apply_filter(ctx
, ctx
->fileversion
, &f
[1], data1
, count
, order
, fracbits
);
1332 static void ape_apply_filters(APEContext
*ctx
, int32_t *decoded0
,
1333 int32_t *decoded1
, int count
)
1337 for (i
= 0; i
< APE_FILTER_LEVELS
; i
++) {
1338 if (!ape_filter_orders
[ctx
->fset
][i
])
1340 apply_filter(ctx
, ctx
->filters
[i
], decoded0
, decoded1
, count
,
1341 ape_filter_orders
[ctx
->fset
][i
],
1342 ape_filter_fracbits
[ctx
->fset
][i
]);
1346 static int init_frame_decoder(APEContext
*ctx
)
1349 if ((ret
= init_entropy_decoder(ctx
)) < 0)
1351 init_predictor_decoder(ctx
);
1353 for (i
= 0; i
< APE_FILTER_LEVELS
; i
++) {
1354 if (!ape_filter_orders
[ctx
->fset
][i
])
1356 init_filter(ctx
, ctx
->filters
[i
], ctx
->filterbuf
[i
],
1357 ape_filter_orders
[ctx
->fset
][i
]);
1362 static void ape_unpack_mono(APEContext
*ctx
, int count
)
1364 if (ctx
->frameflags
& APE_FRAMECODE_STEREO_SILENCE
) {
1365 /* We are pure silence, so we're done. */
1366 av_log(ctx
->avctx
, AV_LOG_DEBUG
, "pure silence mono\n");
1370 ctx
->entropy_decode_mono(ctx
, count
);
1372 /* Now apply the predictor decoding */
1373 ctx
->predictor_decode_mono(ctx
, count
);
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]));
1381 static void ape_unpack_stereo(APEContext
*ctx
, int count
)
1383 int32_t left
, right
;
1384 int32_t *decoded0
= ctx
->decoded
[0];
1385 int32_t *decoded1
= ctx
->decoded
[1];
1387 if (ctx
->frameflags
& APE_FRAMECODE_STEREO_SILENCE
) {
1388 /* We are pure silence, so we're done. */
1389 av_log(ctx
->avctx
, AV_LOG_DEBUG
, "pure silence stereo\n");
1393 ctx
->entropy_decode_stereo(ctx
, count
);
1395 /* Now apply the predictor decoding */
1396 ctx
->predictor_decode_stereo(ctx
, count
);
1398 /* Decorrelate and scale to output depth */
1400 left
= *decoded1
- (*decoded0
/ 2);
1401 right
= left
+ *decoded0
;
1403 *(decoded0
++) = left
;
1404 *(decoded1
++) = right
;
1408 static int ape_decode_frame(AVCodecContext
*avctx
, void *data
,
1409 int *got_frame_ptr
, AVPacket
*avpkt
)
1411 AVFrame
*frame
= data
;
1412 const uint8_t *buf
= avpkt
->data
;
1413 APEContext
*s
= avctx
->priv_data
;
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);
1425 uint32_t nblocks
, offset
;
1432 if (avpkt
->size
< 8) {
1433 av_log(avctx
, AV_LOG_ERROR
, "Packet is too small\n");
1434 return AVERROR_INVALIDDATA
;
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");
1441 if (s
->fileversion
< 3950) // previous versions overread two bytes
1443 av_fast_padded_malloc(&s
->data
, &s
->data_size
, buf_size
);
1445 return AVERROR(ENOMEM
);
1446 s
->bdsp
.bswap_buf((uint32_t *) s
->data
, (const uint32_t *) buf
,
1448 memset(s
->data
+ (buf_size
& ~3), 0, buf_size
& 3);
1450 s
->data_end
= s
->data
+ buf_size
;
1452 nblocks
= bytestream_get_be32(&s
->ptr
);
1453 offset
= bytestream_get_be32(&s
->ptr
);
1454 if (s
->fileversion
>= 3900) {
1456 av_log(avctx
, AV_LOG_ERROR
, "Incorrect offset passed\n");
1458 return AVERROR_INVALIDDATA
;
1460 if (s
->data_end
- s
->ptr
< offset
) {
1461 av_log(avctx
, AV_LOG_ERROR
, "Packet is too small\n");
1462 return AVERROR_INVALIDDATA
;
1466 if ((ret
= init_get_bits8(&s
->gb
, s
->ptr
, s
->data_end
- s
->ptr
)) < 0)
1468 if (s
->fileversion
> 3800)
1469 skip_bits_long(&s
->gb
, offset
* 8);
1471 skip_bits_long(&s
->gb
, offset
);
1474 if (!nblocks
|| nblocks
> INT_MAX
) {
1475 av_log(avctx
, AV_LOG_ERROR
, "Invalid sample count: %"PRIu32
".\n",
1477 return AVERROR_INVALIDDATA
;
1479 s
->samples
= nblocks
;
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
;
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
;
1499 /* reallocate decoded sample buffer if needed */
1500 av_fast_malloc(&s
->decoded_buffer
, &s
->decoded_size
,
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);
1508 /* get output buffer */
1509 frame
->nb_samples
= blockstodecode
;
1510 if ((ret
= ff_get_buffer(avctx
, frame
, 0)) < 0)
1515 if ((s
->channels
== 1) || (s
->frameflags
& APE_FRAMECODE_PSEUDO_STEREO
))
1516 ape_unpack_mono(s
, blockstodecode
);
1518 ape_unpack_stereo(s
, blockstodecode
);
1523 av_log(avctx
, AV_LOG_ERROR
, "Error decoding frame\n");
1524 return AVERROR_INVALIDDATA
;
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;
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
];
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;
1551 s
->samples
-= blockstodecode
;
1555 return !s
->samples
? avpkt
->size
: 0;
1558 static void ape_flush(AVCodecContext
*avctx
)
1560 APEContext
*s
= avctx
->priv_data
;
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" },
1572 static const AVClass ape_decoder_class
= {
1573 .class_name
= "APE decoder",
1574 .item_name
= av_default_item_name
,
1576 .version
= LIBAVUTIL_VERSION_INT
,
1579 AVCodec ff_ape_decoder
= {
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
,
1587 .decode
= ape_decode_frame
,
1588 .capabilities
= CODEC_CAP_SUBFRAMES
| CODEC_CAP_DELAY
| CODEC_CAP_DR1
,
1590 .sample_fmts
= (const enum AVSampleFormat
[]) { AV_SAMPLE_FMT_U8P
,
1593 AV_SAMPLE_FMT_NONE
},
1594 .priv_class
= &ape_decoder_class
,