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