Mercurial > libavcodec.hg
annotate apedec.c @ 6920:d02af7474bff libavcodec
Prevent 128*1<<trellis from becoming 0 and creating 0 sized arrays.
fixes CID84 RUN2
CID85 RUN2
CID86 RUN2
CID87 RUN2
CID88 RUN2
CID89 RUN2
CID90 RUN2
CID91 RUN2
CID92 RUN2
CID93 RUN2
CID94 RUN2
CID95 RUN2
CID96 RUN2
CID97 RUN2
CID98 RUN2
CID99 RUN2
CID100 RUN2
CID101 RUN2
CID102 RUN2
CID103 RUN2
CID104 RUN2
CID105 RUN2
CID106 RUN2
author | michael |
---|---|
date | Wed, 28 May 2008 11:59:41 +0000 |
parents | 5b3acf9fd50a |
children | e943e1409077 |
rev | line source |
---|---|
5673 | 1 /* |
2 * Monkey's Audio lossless audio decoder | |
3 * Copyright (c) 2007 Benjamin Zores <ben@geexbox.org> | |
4 * based upon libdemac from Dave Chapman. | |
5 * | |
6 * This file is part of FFmpeg. | |
7 * | |
8 * FFmpeg is free software; you can redistribute it and/or | |
9 * modify it under the terms of the GNU Lesser General Public | |
10 * License as published by the Free Software Foundation; either | |
11 * version 2.1 of the License, or (at your option) any later version. | |
12 * | |
13 * FFmpeg is distributed in the hope that it will be useful, | |
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 * Lesser General Public License for more details. | |
17 * | |
18 * You should have received a copy of the GNU Lesser General Public | |
19 * License along with FFmpeg; if not, write to the Free Software | |
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
21 */ | |
22 | |
23 #define ALT_BITSTREAM_READER_LE | |
24 #include "avcodec.h" | |
25 #include "dsputil.h" | |
26 #include "bitstream.h" | |
27 #include "bytestream.h" | |
28 | |
29 /** | |
30 * @file apedec.c | |
31 * Monkey's Audio lossless audio decoder | |
32 */ | |
33 | |
34 #define BLOCKS_PER_LOOP 4608 | |
35 #define MAX_CHANNELS 2 | |
36 #define MAX_BYTESPERSAMPLE 3 | |
37 | |
38 #define APE_FRAMECODE_MONO_SILENCE 1 | |
39 #define APE_FRAMECODE_STEREO_SILENCE 3 | |
40 #define APE_FRAMECODE_PSEUDO_STEREO 4 | |
41 | |
42 #define HISTORY_SIZE 512 | |
43 #define PREDICTOR_ORDER 8 | |
44 /** Total size of all predictor histories */ | |
45 #define PREDICTOR_SIZE 50 | |
46 | |
47 #define YDELAYA (18 + PREDICTOR_ORDER*4) | |
48 #define YDELAYB (18 + PREDICTOR_ORDER*3) | |
49 #define XDELAYA (18 + PREDICTOR_ORDER*2) | |
50 #define XDELAYB (18 + PREDICTOR_ORDER) | |
51 | |
52 #define YADAPTCOEFFSA 18 | |
53 #define XADAPTCOEFFSA 14 | |
54 #define YADAPTCOEFFSB 10 | |
55 #define XADAPTCOEFFSB 5 | |
56 | |
57 /** | |
58 * Possible compression levels | |
59 * @{ | |
60 */ | |
61 enum APECompressionLevel { | |
62 COMPRESSION_LEVEL_FAST = 1000, | |
63 COMPRESSION_LEVEL_NORMAL = 2000, | |
64 COMPRESSION_LEVEL_HIGH = 3000, | |
65 COMPRESSION_LEVEL_EXTRA_HIGH = 4000, | |
66 COMPRESSION_LEVEL_INSANE = 5000 | |
67 }; | |
68 /** @} */ | |
69 | |
70 #define APE_FILTER_LEVELS 3 | |
71 | |
72 /** Filter orders depending on compression level */ | |
73 static const uint16_t ape_filter_orders[5][APE_FILTER_LEVELS] = { | |
74 { 0, 0, 0 }, | |
75 { 16, 0, 0 }, | |
76 { 64, 0, 0 }, | |
77 { 32, 256, 0 }, | |
78 { 16, 256, 1280 } | |
79 }; | |
80 | |
81 /** Filter fraction bits depending on compression level */ | |
6482 | 82 static const uint8_t ape_filter_fracbits[5][APE_FILTER_LEVELS] = { |
5673 | 83 { 0, 0, 0 }, |
84 { 11, 0, 0 }, | |
85 { 11, 0, 0 }, | |
86 { 10, 13, 0 }, | |
87 { 11, 13, 15 } | |
88 }; | |
89 | |
90 | |
91 /** Filters applied to the decoded data */ | |
92 typedef struct APEFilter { | |
93 int16_t *coeffs; ///< actual coefficients used in filtering | |
94 int16_t *adaptcoeffs; ///< adaptive filter coefficients used for correcting of actual filter coefficients | |
95 int16_t *historybuffer; ///< filter memory | |
96 int16_t *delay; ///< filtered values | |
97 | |
98 int avg; | |
99 } APEFilter; | |
100 | |
101 typedef struct APERice { | |
102 uint32_t k; | |
103 uint32_t ksum; | |
104 } APERice; | |
105 | |
106 typedef struct APERangecoder { | |
107 uint32_t low; ///< low end of interval | |
108 uint32_t range; ///< length of interval | |
109 uint32_t help; ///< bytes_to_follow resp. intermediate value | |
110 unsigned int buffer; ///< buffer for input/output | |
111 } APERangecoder; | |
112 | |
113 /** Filter histories */ | |
114 typedef struct APEPredictor { | |
115 int32_t *buf; | |
116 | |
117 int32_t lastA[2]; | |
118 | |
119 int32_t filterA[2]; | |
120 int32_t filterB[2]; | |
121 | |
122 int32_t coeffsA[2][4]; ///< adaption coefficients | |
123 int32_t coeffsB[2][5]; ///< adaption coefficients | |
124 int32_t historybuffer[HISTORY_SIZE + PREDICTOR_SIZE]; | |
125 } APEPredictor; | |
126 | |
127 /** Decoder context */ | |
128 typedef struct APEContext { | |
129 AVCodecContext *avctx; | |
130 DSPContext dsp; | |
131 int channels; | |
132 int samples; ///< samples left to decode in current frame | |
133 | |
134 int fileversion; ///< codec version, very important in decoding process | |
135 int compression_level; ///< compression levels | |
136 int fset; ///< which filter set to use (calculated from compression level) | |
137 int flags; ///< global decoder flags | |
138 | |
139 uint32_t CRC; ///< frame CRC | |
140 int frameflags; ///< frame flags | |
141 int currentframeblocks; ///< samples (per channel) in current frame | |
142 int blocksdecoded; ///< count of decoded samples in current frame | |
143 APEPredictor predictor; ///< predictor used for final reconstruction | |
144 | |
145 int32_t decoded0[BLOCKS_PER_LOOP]; ///< decoded data for the first channel | |
146 int32_t decoded1[BLOCKS_PER_LOOP]; ///< decoded data for the second channel | |
147 | |
148 int16_t* filterbuf[APE_FILTER_LEVELS]; ///< filter memory | |
149 | |
150 APERangecoder rc; ///< rangecoder used to decode actual values | |
151 APERice riceX; ///< rice code parameters for the second channel | |
152 APERice riceY; ///< rice code parameters for the first channel | |
153 APEFilter filters[APE_FILTER_LEVELS][2]; ///< filters used for reconstruction | |
154 | |
155 uint8_t *data; ///< current frame data | |
156 uint8_t *data_end; ///< frame data end | |
6223 | 157 const uint8_t *ptr; ///< current position in frame data |
158 const uint8_t *last_ptr; ///< position where last 4608-sample block ended | |
6443
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
159 |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
160 int error; |
5673 | 161 } APEContext; |
162 | |
163 // TODO: dsputilize | |
164 static inline void vector_add(int16_t * v1, int16_t * v2, int order) | |
165 { | |
166 while (order--) | |
167 *v1++ += *v2++; | |
168 } | |
169 | |
170 // TODO: dsputilize | |
171 static inline void vector_sub(int16_t * v1, int16_t * v2, int order) | |
172 { | |
173 while (order--) | |
174 *v1++ -= *v2++; | |
175 } | |
176 | |
177 // TODO: dsputilize | |
178 static inline int32_t scalarproduct(int16_t * v1, int16_t * v2, int order) | |
179 { | |
180 int res = 0; | |
181 | |
182 while (order--) | |
183 res += *v1++ * *v2++; | |
184 | |
185 return res; | |
186 } | |
187 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6482
diff
changeset
|
188 static av_cold int ape_decode_init(AVCodecContext * avctx) |
5673 | 189 { |
190 APEContext *s = avctx->priv_data; | |
191 int i; | |
192 | |
193 if (avctx->extradata_size != 6) { | |
194 av_log(avctx, AV_LOG_ERROR, "Incorrect extradata\n"); | |
195 return -1; | |
196 } | |
197 if (avctx->bits_per_sample != 16) { | |
198 av_log(avctx, AV_LOG_ERROR, "Only 16-bit samples are supported\n"); | |
199 return -1; | |
200 } | |
201 if (avctx->channels > 2) { | |
202 av_log(avctx, AV_LOG_ERROR, "Only mono and stereo is supported\n"); | |
203 return -1; | |
204 } | |
205 s->avctx = avctx; | |
206 s->channels = avctx->channels; | |
207 s->fileversion = AV_RL16(avctx->extradata); | |
208 s->compression_level = AV_RL16(avctx->extradata + 2); | |
209 s->flags = AV_RL16(avctx->extradata + 4); | |
210 | |
211 av_log(avctx, AV_LOG_DEBUG, "Compression Level: %d - Flags: %d\n", s->compression_level, s->flags); | |
212 if (s->compression_level % 1000 || s->compression_level > COMPRESSION_LEVEL_INSANE) { | |
213 av_log(avctx, AV_LOG_ERROR, "Incorrect compression level %d\n", s->compression_level); | |
214 return -1; | |
215 } | |
216 s->fset = s->compression_level / 1000 - 1; | |
217 for (i = 0; i < APE_FILTER_LEVELS; i++) { | |
218 if (!ape_filter_orders[s->fset][i]) | |
219 break; | |
220 s->filterbuf[i] = av_malloc((ape_filter_orders[s->fset][i] * 3 + HISTORY_SIZE) * 4); | |
221 } | |
222 | |
223 dsputil_init(&s->dsp, avctx); | |
224 return 0; | |
225 } | |
226 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6482
diff
changeset
|
227 static av_cold int ape_decode_close(AVCodecContext * avctx) |
5673 | 228 { |
229 APEContext *s = avctx->priv_data; | |
230 int i; | |
231 | |
232 for (i = 0; i < APE_FILTER_LEVELS; i++) | |
233 av_freep(&s->filterbuf[i]); | |
234 | |
235 return 0; | |
236 } | |
237 | |
238 /** | |
239 * @defgroup rangecoder APE range decoder | |
240 * @{ | |
241 */ | |
242 | |
243 #define CODE_BITS 32 | |
244 #define TOP_VALUE ((unsigned int)1 << (CODE_BITS-1)) | |
245 #define SHIFT_BITS (CODE_BITS - 9) | |
246 #define EXTRA_BITS ((CODE_BITS-2) % 8 + 1) | |
247 #define BOTTOM_VALUE (TOP_VALUE >> 8) | |
248 | |
249 /** Start the decoder */ | |
250 static inline void range_start_decoding(APEContext * ctx) | |
251 { | |
252 ctx->rc.buffer = bytestream_get_byte(&ctx->ptr); | |
253 ctx->rc.low = ctx->rc.buffer >> (8 - EXTRA_BITS); | |
254 ctx->rc.range = (uint32_t) 1 << EXTRA_BITS; | |
255 } | |
256 | |
257 /** Perform normalization */ | |
258 static inline void range_dec_normalize(APEContext * ctx) | |
259 { | |
260 while (ctx->rc.range <= BOTTOM_VALUE) { | |
6442
28e45bf84973
Prevent segfault due to reading over the end of the input buffer.
michael
parents:
6223
diff
changeset
|
261 ctx->rc.buffer <<= 8; |
28e45bf84973
Prevent segfault due to reading over the end of the input buffer.
michael
parents:
6223
diff
changeset
|
262 if(ctx->ptr < ctx->data_end) |
28e45bf84973
Prevent segfault due to reading over the end of the input buffer.
michael
parents:
6223
diff
changeset
|
263 ctx->rc.buffer += *ctx->ptr; |
28e45bf84973
Prevent segfault due to reading over the end of the input buffer.
michael
parents:
6223
diff
changeset
|
264 ctx->ptr++; |
5673 | 265 ctx->rc.low = (ctx->rc.low << 8) | ((ctx->rc.buffer >> 1) & 0xFF); |
266 ctx->rc.range <<= 8; | |
267 } | |
268 } | |
269 | |
270 /** | |
271 * Calculate culmulative frequency for next symbol. Does NO update! | |
272 * @param tot_f is the total frequency or (code_value)1<<shift | |
273 * @return the culmulative frequency | |
274 */ | |
275 static inline int range_decode_culfreq(APEContext * ctx, int tot_f) | |
276 { | |
277 range_dec_normalize(ctx); | |
278 ctx->rc.help = ctx->rc.range / tot_f; | |
279 return ctx->rc.low / ctx->rc.help; | |
280 } | |
281 | |
282 /** | |
283 * Decode value with given size in bits | |
284 * @param shift number of bits to decode | |
285 */ | |
286 static inline int range_decode_culshift(APEContext * ctx, int shift) | |
287 { | |
288 range_dec_normalize(ctx); | |
289 ctx->rc.help = ctx->rc.range >> shift; | |
290 return ctx->rc.low / ctx->rc.help; | |
291 } | |
292 | |
293 | |
294 /** | |
295 * Update decoding state | |
296 * @param sy_f the interval length (frequency of the symbol) | |
297 * @param lt_f the lower end (frequency sum of < symbols) | |
298 */ | |
299 static inline void range_decode_update(APEContext * ctx, int sy_f, int lt_f) | |
300 { | |
301 ctx->rc.low -= ctx->rc.help * lt_f; | |
302 ctx->rc.range = ctx->rc.help * sy_f; | |
303 } | |
304 | |
305 /** Decode n bits (n <= 16) without modelling */ | |
306 static inline int range_decode_bits(APEContext * ctx, int n) | |
307 { | |
308 int sym = range_decode_culshift(ctx, n); | |
309 range_decode_update(ctx, 1, sym); | |
310 return sym; | |
311 } | |
312 | |
313 | |
314 #define MODEL_ELEMENTS 64 | |
315 | |
316 /** | |
317 * Fixed probabilities for symbols in Monkey Audio version 3.97 | |
318 */ | |
6482 | 319 static const uint16_t counts_3970[22] = { |
5673 | 320 0, 14824, 28224, 39348, 47855, 53994, 58171, 60926, |
321 62682, 63786, 64463, 64878, 65126, 65276, 65365, 65419, | |
6444 | 322 65450, 65469, 65480, 65487, 65491, 65493, |
5673 | 323 }; |
324 | |
325 /** | |
326 * Probability ranges for symbols in Monkey Audio version 3.97 | |
327 */ | |
6444 | 328 static const uint16_t counts_diff_3970[21] = { |
5673 | 329 14824, 13400, 11124, 8507, 6139, 4177, 2755, 1756, |
330 1104, 677, 415, 248, 150, 89, 54, 31, | |
6444 | 331 19, 11, 7, 4, 2, |
5673 | 332 }; |
333 | |
334 /** | |
335 * Fixed probabilities for symbols in Monkey Audio version 3.98 | |
336 */ | |
6482 | 337 static const uint16_t counts_3980[22] = { |
5673 | 338 0, 19578, 36160, 48417, 56323, 60899, 63265, 64435, |
339 64971, 65232, 65351, 65416, 65447, 65466, 65476, 65482, | |
6444 | 340 65485, 65488, 65490, 65491, 65492, 65493, |
5673 | 341 }; |
342 | |
343 /** | |
344 * Probability ranges for symbols in Monkey Audio version 3.98 | |
345 */ | |
6444 | 346 static const uint16_t counts_diff_3980[21] = { |
5673 | 347 19578, 16582, 12257, 7906, 4576, 2366, 1170, 536, |
348 261, 119, 65, 31, 19, 10, 6, 3, | |
6444 | 349 3, 2, 1, 1, 1, |
5673 | 350 }; |
351 | |
352 /** | |
353 * Decode symbol | |
354 * @param counts probability range start position | |
355 * @param count_diffs probability range widths | |
356 */ | |
357 static inline int range_get_symbol(APEContext * ctx, | |
6482 | 358 const uint16_t counts[], |
5673 | 359 const uint16_t counts_diff[]) |
360 { | |
361 int symbol, cf; | |
362 | |
363 cf = range_decode_culshift(ctx, 16); | |
364 | |
6443
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
365 if(cf > 65492){ |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
366 symbol= cf - 65535 + 63; |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
367 range_decode_update(ctx, 1, cf); |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
368 if(cf > 65535) |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
369 ctx->error=1; |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
370 return symbol; |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
371 } |
5673 | 372 /* figure out the symbol inefficiently; a binary search would be much better */ |
373 for (symbol = 0; counts[symbol + 1] <= cf; symbol++); | |
374 | |
375 range_decode_update(ctx, counts_diff[symbol], counts[symbol]); | |
376 | |
377 return symbol; | |
378 } | |
379 /** @} */ // group rangecoder | |
380 | |
381 static inline void update_rice(APERice *rice, int x) | |
382 { | |
383 rice->ksum += ((x + 1) / 2) - ((rice->ksum + 16) >> 5); | |
384 | |
385 if (rice->k == 0) | |
386 rice->k = 1; | |
387 else if (rice->ksum < (1 << (rice->k + 4))) | |
388 rice->k--; | |
389 else if (rice->ksum >= (1 << (rice->k + 5))) | |
390 rice->k++; | |
391 } | |
392 | |
393 static inline int ape_decode_value(APEContext * ctx, APERice *rice) | |
394 { | |
395 int x, overflow; | |
396 | |
397 if (ctx->fileversion < 3980) { | |
398 int tmpk; | |
399 | |
400 overflow = range_get_symbol(ctx, counts_3970, counts_diff_3970); | |
401 | |
402 if (overflow == (MODEL_ELEMENTS - 1)) { | |
403 tmpk = range_decode_bits(ctx, 5); | |
404 overflow = 0; | |
405 } else | |
406 tmpk = (rice->k < 1) ? 0 : rice->k - 1; | |
407 | |
408 if (tmpk <= 16) | |
409 x = range_decode_bits(ctx, tmpk); | |
410 else { | |
411 x = range_decode_bits(ctx, 16); | |
412 x |= (range_decode_bits(ctx, tmpk - 16) << 16); | |
413 } | |
414 x += overflow << tmpk; | |
415 } else { | |
416 int base, pivot; | |
417 | |
418 pivot = rice->ksum >> 5; | |
419 if (pivot == 0) | |
420 pivot = 1; | |
421 | |
422 overflow = range_get_symbol(ctx, counts_3980, counts_diff_3980); | |
423 | |
424 if (overflow == (MODEL_ELEMENTS - 1)) { | |
425 overflow = range_decode_bits(ctx, 16) << 16; | |
426 overflow |= range_decode_bits(ctx, 16); | |
427 } | |
428 | |
429 base = range_decode_culfreq(ctx, pivot); | |
430 range_decode_update(ctx, 1, base); | |
431 | |
432 x = base + overflow * pivot; | |
433 } | |
434 | |
435 update_rice(rice, x); | |
436 | |
437 /* Convert to signed */ | |
438 if (x & 1) | |
439 return (x >> 1) + 1; | |
440 else | |
441 return -(x >> 1); | |
442 } | |
443 | |
444 static void entropy_decode(APEContext * ctx, int blockstodecode, int stereo) | |
445 { | |
446 int32_t *decoded0 = ctx->decoded0; | |
447 int32_t *decoded1 = ctx->decoded1; | |
448 | |
449 ctx->blocksdecoded = blockstodecode; | |
450 | |
451 if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) { | |
452 /* We are pure silence, just memset the output buffer. */ | |
453 memset(decoded0, 0, blockstodecode * sizeof(int32_t)); | |
454 memset(decoded1, 0, blockstodecode * sizeof(int32_t)); | |
455 } else { | |
456 while (blockstodecode--) { | |
457 *decoded0++ = ape_decode_value(ctx, &ctx->riceY); | |
458 if (stereo) | |
459 *decoded1++ = ape_decode_value(ctx, &ctx->riceX); | |
460 } | |
461 } | |
462 | |
463 if (ctx->blocksdecoded == ctx->currentframeblocks) | |
464 range_dec_normalize(ctx); /* normalize to use up all bytes */ | |
465 } | |
466 | |
467 static void init_entropy_decoder(APEContext * ctx) | |
468 { | |
469 /* Read the CRC */ | |
470 ctx->CRC = bytestream_get_be32(&ctx->ptr); | |
471 | |
472 /* Read the frame flags if they exist */ | |
473 ctx->frameflags = 0; | |
474 if ((ctx->fileversion > 3820) && (ctx->CRC & 0x80000000)) { | |
475 ctx->CRC &= ~0x80000000; | |
476 | |
477 ctx->frameflags = bytestream_get_be32(&ctx->ptr); | |
478 } | |
479 | |
480 /* Keep a count of the blocks decoded in this frame */ | |
481 ctx->blocksdecoded = 0; | |
482 | |
5963 | 483 /* Initialize the rice structs */ |
5673 | 484 ctx->riceX.k = 10; |
485 ctx->riceX.ksum = (1 << ctx->riceX.k) * 16; | |
486 ctx->riceY.k = 10; | |
487 ctx->riceY.ksum = (1 << ctx->riceY.k) * 16; | |
488 | |
489 /* The first 8 bits of input are ignored. */ | |
490 ctx->ptr++; | |
491 | |
492 range_start_decoding(ctx); | |
493 } | |
494 | |
495 static const int32_t initial_coeffs[4] = { | |
496 360, 317, -109, 98 | |
497 }; | |
498 | |
499 static void init_predictor_decoder(APEContext * ctx) | |
500 { | |
501 APEPredictor *p = &ctx->predictor; | |
502 | |
503 /* Zero the history buffers */ | |
504 memset(p->historybuffer, 0, PREDICTOR_SIZE * sizeof(int32_t)); | |
505 p->buf = p->historybuffer; | |
506 | |
5966 | 507 /* Initialize and zero the coefficients */ |
5673 | 508 memcpy(p->coeffsA[0], initial_coeffs, sizeof(initial_coeffs)); |
509 memcpy(p->coeffsA[1], initial_coeffs, sizeof(initial_coeffs)); | |
510 memset(p->coeffsB, 0, sizeof(p->coeffsB)); | |
511 | |
512 p->filterA[0] = p->filterA[1] = 0; | |
513 p->filterB[0] = p->filterB[1] = 0; | |
514 p->lastA[0] = p->lastA[1] = 0; | |
515 } | |
516 | |
517 /** Get inverse sign of integer (-1 for positive, 1 for negative and 0 for zero) */ | |
518 static inline int APESIGN(int32_t x) { | |
519 return (x < 0) - (x > 0); | |
520 } | |
521 | |
522 static int predictor_update_filter(APEPredictor *p, const int decoded, const int filter, const int delayA, const int delayB, const int adaptA, const int adaptB) | |
523 { | |
524 int32_t predictionA, predictionB; | |
525 | |
526 p->buf[delayA] = p->lastA[filter]; | |
527 p->buf[adaptA] = APESIGN(p->buf[delayA]); | |
528 p->buf[delayA - 1] = p->buf[delayA] - p->buf[delayA - 1]; | |
529 p->buf[adaptA - 1] = APESIGN(p->buf[delayA - 1]); | |
530 | |
531 predictionA = p->buf[delayA ] * p->coeffsA[filter][0] + | |
532 p->buf[delayA - 1] * p->coeffsA[filter][1] + | |
533 p->buf[delayA - 2] * p->coeffsA[filter][2] + | |
534 p->buf[delayA - 3] * p->coeffsA[filter][3]; | |
535 | |
536 /* Apply a scaled first-order filter compression */ | |
537 p->buf[delayB] = p->filterA[filter ^ 1] - ((p->filterB[filter] * 31) >> 5); | |
538 p->buf[adaptB] = APESIGN(p->buf[delayB]); | |
539 p->buf[delayB - 1] = p->buf[delayB] - p->buf[delayB - 1]; | |
540 p->buf[adaptB - 1] = APESIGN(p->buf[delayB - 1]); | |
541 p->filterB[filter] = p->filterA[filter ^ 1]; | |
542 | |
543 predictionB = p->buf[delayB ] * p->coeffsB[filter][0] + | |
544 p->buf[delayB - 1] * p->coeffsB[filter][1] + | |
545 p->buf[delayB - 2] * p->coeffsB[filter][2] + | |
546 p->buf[delayB - 3] * p->coeffsB[filter][3] + | |
547 p->buf[delayB - 4] * p->coeffsB[filter][4]; | |
548 | |
549 p->lastA[filter] = decoded + ((predictionA + (predictionB >> 1)) >> 10); | |
550 p->filterA[filter] = p->lastA[filter] + ((p->filterA[filter] * 31) >> 5); | |
551 | |
552 if (!decoded) // no need updating filter coefficients | |
553 return p->filterA[filter]; | |
554 | |
555 if (decoded > 0) { | |
556 p->coeffsA[filter][0] -= p->buf[adaptA ]; | |
557 p->coeffsA[filter][1] -= p->buf[adaptA - 1]; | |
558 p->coeffsA[filter][2] -= p->buf[adaptA - 2]; | |
559 p->coeffsA[filter][3] -= p->buf[adaptA - 3]; | |
560 | |
561 p->coeffsB[filter][0] -= p->buf[adaptB ]; | |
562 p->coeffsB[filter][1] -= p->buf[adaptB - 1]; | |
563 p->coeffsB[filter][2] -= p->buf[adaptB - 2]; | |
564 p->coeffsB[filter][3] -= p->buf[adaptB - 3]; | |
565 p->coeffsB[filter][4] -= p->buf[adaptB - 4]; | |
566 } else { | |
567 p->coeffsA[filter][0] += p->buf[adaptA ]; | |
568 p->coeffsA[filter][1] += p->buf[adaptA - 1]; | |
569 p->coeffsA[filter][2] += p->buf[adaptA - 2]; | |
570 p->coeffsA[filter][3] += p->buf[adaptA - 3]; | |
571 | |
572 p->coeffsB[filter][0] += p->buf[adaptB ]; | |
573 p->coeffsB[filter][1] += p->buf[adaptB - 1]; | |
574 p->coeffsB[filter][2] += p->buf[adaptB - 2]; | |
575 p->coeffsB[filter][3] += p->buf[adaptB - 3]; | |
576 p->coeffsB[filter][4] += p->buf[adaptB - 4]; | |
577 } | |
578 return p->filterA[filter]; | |
579 } | |
580 | |
581 static void predictor_decode_stereo(APEContext * ctx, int count) | |
582 { | |
583 int32_t predictionA, predictionB; | |
584 APEPredictor *p = &ctx->predictor; | |
585 int32_t *decoded0 = ctx->decoded0; | |
586 int32_t *decoded1 = ctx->decoded1; | |
587 | |
588 while (count--) { | |
589 /* Predictor Y */ | |
590 predictionA = predictor_update_filter(p, *decoded0, 0, YDELAYA, YDELAYB, YADAPTCOEFFSA, YADAPTCOEFFSB); | |
591 predictionB = predictor_update_filter(p, *decoded1, 1, XDELAYA, XDELAYB, XADAPTCOEFFSA, XADAPTCOEFFSB); | |
592 *(decoded0++) = predictionA; | |
593 *(decoded1++) = predictionB; | |
594 | |
595 /* Combined */ | |
596 p->buf++; | |
597 | |
598 /* Have we filled the history buffer? */ | |
599 if (p->buf == p->historybuffer + HISTORY_SIZE) { | |
600 memmove(p->historybuffer, p->buf, PREDICTOR_SIZE * sizeof(int32_t)); | |
601 p->buf = p->historybuffer; | |
602 } | |
603 } | |
604 } | |
605 | |
606 static void predictor_decode_mono(APEContext * ctx, int count) | |
607 { | |
608 APEPredictor *p = &ctx->predictor; | |
609 int32_t *decoded0 = ctx->decoded0; | |
610 int32_t predictionA, currentA, A; | |
611 | |
612 currentA = p->lastA[0]; | |
613 | |
614 while (count--) { | |
615 A = *decoded0; | |
616 | |
617 p->buf[YDELAYA] = currentA; | |
618 p->buf[YDELAYA - 1] = p->buf[YDELAYA] - p->buf[YDELAYA - 1]; | |
619 | |
620 predictionA = p->buf[YDELAYA ] * p->coeffsA[0][0] + | |
621 p->buf[YDELAYA - 1] * p->coeffsA[0][1] + | |
622 p->buf[YDELAYA - 2] * p->coeffsA[0][2] + | |
623 p->buf[YDELAYA - 3] * p->coeffsA[0][3]; | |
624 | |
625 currentA = A + (predictionA >> 10); | |
626 | |
627 p->buf[YADAPTCOEFFSA] = APESIGN(p->buf[YDELAYA ]); | |
628 p->buf[YADAPTCOEFFSA - 1] = APESIGN(p->buf[YDELAYA - 1]); | |
629 | |
630 if (A > 0) { | |
631 p->coeffsA[0][0] -= p->buf[YADAPTCOEFFSA ]; | |
632 p->coeffsA[0][1] -= p->buf[YADAPTCOEFFSA - 1]; | |
633 p->coeffsA[0][2] -= p->buf[YADAPTCOEFFSA - 2]; | |
634 p->coeffsA[0][3] -= p->buf[YADAPTCOEFFSA - 3]; | |
635 } else if (A < 0) { | |
636 p->coeffsA[0][0] += p->buf[YADAPTCOEFFSA ]; | |
637 p->coeffsA[0][1] += p->buf[YADAPTCOEFFSA - 1]; | |
638 p->coeffsA[0][2] += p->buf[YADAPTCOEFFSA - 2]; | |
639 p->coeffsA[0][3] += p->buf[YADAPTCOEFFSA - 3]; | |
640 } | |
641 | |
642 p->buf++; | |
643 | |
644 /* Have we filled the history buffer? */ | |
645 if (p->buf == p->historybuffer + HISTORY_SIZE) { | |
646 memmove(p->historybuffer, p->buf, PREDICTOR_SIZE * sizeof(int32_t)); | |
647 p->buf = p->historybuffer; | |
648 } | |
649 | |
650 p->filterA[0] = currentA + ((p->filterA[0] * 31) >> 5); | |
651 *(decoded0++) = p->filterA[0]; | |
652 } | |
653 | |
654 p->lastA[0] = currentA; | |
655 } | |
656 | |
657 static void do_init_filter(APEFilter *f, int16_t * buf, int order) | |
658 { | |
659 f->coeffs = buf; | |
660 f->historybuffer = buf + order; | |
661 f->delay = f->historybuffer + order * 2; | |
662 f->adaptcoeffs = f->historybuffer + order; | |
663 | |
664 memset(f->historybuffer, 0, (order * 2) * sizeof(int16_t)); | |
665 memset(f->coeffs, 0, order * sizeof(int16_t)); | |
666 f->avg = 0; | |
667 } | |
668 | |
669 static void init_filter(APEContext * ctx, APEFilter *f, int16_t * buf, int order) | |
670 { | |
671 do_init_filter(&f[0], buf, order); | |
672 do_init_filter(&f[1], buf + order * 3 + HISTORY_SIZE, order); | |
673 } | |
674 | |
675 static inline void do_apply_filter(int version, APEFilter *f, int32_t *data, int count, int order, int fracbits) | |
676 { | |
677 int res; | |
678 int absres; | |
679 | |
680 while (count--) { | |
681 /* round fixedpoint scalar product */ | |
682 res = (scalarproduct(f->delay - order, f->coeffs, order) + (1 << (fracbits - 1))) >> fracbits; | |
683 | |
684 if (*data < 0) | |
685 vector_add(f->coeffs, f->adaptcoeffs - order, order); | |
686 else if (*data > 0) | |
687 vector_sub(f->coeffs, f->adaptcoeffs - order, order); | |
688 | |
689 res += *data; | |
690 | |
691 *data++ = res; | |
692 | |
693 /* Update the output history */ | |
694 *f->delay++ = av_clip_int16(res); | |
695 | |
696 if (version < 3980) { | |
697 /* Version ??? to < 3.98 files (untested) */ | |
698 f->adaptcoeffs[0] = (res == 0) ? 0 : ((res >> 28) & 8) - 4; | |
699 f->adaptcoeffs[-4] >>= 1; | |
700 f->adaptcoeffs[-8] >>= 1; | |
701 } else { | |
702 /* Version 3.98 and later files */ | |
703 | |
704 /* Update the adaption coefficients */ | |
705 absres = (res < 0 ? -res : res); | |
706 | |
707 if (absres > (f->avg * 3)) | |
708 *f->adaptcoeffs = ((res >> 25) & 64) - 32; | |
709 else if (absres > (f->avg * 4) / 3) | |
710 *f->adaptcoeffs = ((res >> 26) & 32) - 16; | |
711 else if (absres > 0) | |
712 *f->adaptcoeffs = ((res >> 27) & 16) - 8; | |
713 else | |
714 *f->adaptcoeffs = 0; | |
715 | |
716 f->avg += (absres - f->avg) / 16; | |
717 | |
718 f->adaptcoeffs[-1] >>= 1; | |
719 f->adaptcoeffs[-2] >>= 1; | |
720 f->adaptcoeffs[-8] >>= 1; | |
721 } | |
722 | |
723 f->adaptcoeffs++; | |
724 | |
725 /* Have we filled the history buffer? */ | |
726 if (f->delay == f->historybuffer + HISTORY_SIZE + (order * 2)) { | |
727 memmove(f->historybuffer, f->delay - (order * 2), | |
728 (order * 2) * sizeof(int16_t)); | |
729 f->delay = f->historybuffer + order * 2; | |
730 f->adaptcoeffs = f->historybuffer + order; | |
731 } | |
732 } | |
733 } | |
734 | |
735 static void apply_filter(APEContext * ctx, APEFilter *f, | |
736 int32_t * data0, int32_t * data1, | |
737 int count, int order, int fracbits) | |
738 { | |
739 do_apply_filter(ctx->fileversion, &f[0], data0, count, order, fracbits); | |
740 if (data1) | |
741 do_apply_filter(ctx->fileversion, &f[1], data1, count, order, fracbits); | |
742 } | |
743 | |
744 static void ape_apply_filters(APEContext * ctx, int32_t * decoded0, | |
745 int32_t * decoded1, int count) | |
746 { | |
747 int i; | |
748 | |
749 for (i = 0; i < APE_FILTER_LEVELS; i++) { | |
750 if (!ape_filter_orders[ctx->fset][i]) | |
751 break; | |
752 apply_filter(ctx, ctx->filters[i], decoded0, decoded1, count, ape_filter_orders[ctx->fset][i], ape_filter_fracbits[ctx->fset][i]); | |
753 } | |
754 } | |
755 | |
756 static void init_frame_decoder(APEContext * ctx) | |
757 { | |
758 int i; | |
759 init_entropy_decoder(ctx); | |
760 init_predictor_decoder(ctx); | |
761 | |
762 for (i = 0; i < APE_FILTER_LEVELS; i++) { | |
763 if (!ape_filter_orders[ctx->fset][i]) | |
764 break; | |
765 init_filter(ctx, ctx->filters[i], ctx->filterbuf[i], ape_filter_orders[ctx->fset][i]); | |
766 } | |
767 } | |
768 | |
769 static void ape_unpack_mono(APEContext * ctx, int count) | |
770 { | |
771 int32_t left; | |
772 int32_t *decoded0 = ctx->decoded0; | |
773 int32_t *decoded1 = ctx->decoded1; | |
774 | |
775 if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) { | |
776 entropy_decode(ctx, count, 0); | |
777 /* We are pure silence, so we're done. */ | |
778 av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence mono\n"); | |
779 return; | |
780 } | |
781 | |
782 entropy_decode(ctx, count, 0); | |
783 ape_apply_filters(ctx, decoded0, NULL, count); | |
784 | |
785 /* Now apply the predictor decoding */ | |
786 predictor_decode_mono(ctx, count); | |
787 | |
788 /* Pseudo-stereo - just copy left channel to right channel */ | |
789 if (ctx->channels == 2) { | |
790 while (count--) { | |
791 left = *decoded0; | |
792 *(decoded1++) = *(decoded0++) = left; | |
793 } | |
794 } | |
795 } | |
796 | |
797 static void ape_unpack_stereo(APEContext * ctx, int count) | |
798 { | |
799 int32_t left, right; | |
800 int32_t *decoded0 = ctx->decoded0; | |
801 int32_t *decoded1 = ctx->decoded1; | |
802 | |
803 if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) { | |
804 /* We are pure silence, so we're done. */ | |
805 av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence stereo\n"); | |
806 return; | |
807 } | |
808 | |
809 entropy_decode(ctx, count, 1); | |
810 ape_apply_filters(ctx, decoded0, decoded1, count); | |
811 | |
812 /* Now apply the predictor decoding */ | |
813 predictor_decode_stereo(ctx, count); | |
814 | |
815 /* Decorrelate and scale to output depth */ | |
816 while (count--) { | |
817 left = *decoded1 - (*decoded0 / 2); | |
818 right = left + *decoded0; | |
819 | |
820 *(decoded0++) = left; | |
821 *(decoded1++) = right; | |
822 } | |
823 } | |
824 | |
825 static int ape_decode_frame(AVCodecContext * avctx, | |
826 void *data, int *data_size, | |
6223 | 827 const uint8_t * buf, int buf_size) |
5673 | 828 { |
829 APEContext *s = avctx->priv_data; | |
830 int16_t *samples = data; | |
831 int nblocks; | |
832 int i, n; | |
833 int blockstodecode; | |
834 int bytes_used; | |
835 | |
836 if (buf_size == 0 && !s->samples) { | |
837 *data_size = 0; | |
838 return 0; | |
839 } | |
840 | |
841 /* should not happen but who knows */ | |
842 if (BLOCKS_PER_LOOP * 2 * avctx->channels > *data_size) { | |
843 av_log (avctx, AV_LOG_ERROR, "Packet size is too big to be handled in lavc! (max is %d where you have %d)\n", *data_size, s->samples * 2 * avctx->channels); | |
844 return -1; | |
845 } | |
846 | |
847 if(!s->samples){ | |
848 s->data = av_realloc(s->data, (buf_size + 3) & ~3); | |
6223 | 849 s->dsp.bswap_buf((uint32_t*)s->data, (const uint32_t*)buf, buf_size >> 2); |
5673 | 850 s->ptr = s->last_ptr = s->data; |
851 s->data_end = s->data + buf_size; | |
852 | |
853 nblocks = s->samples = bytestream_get_be32(&s->ptr); | |
854 n = bytestream_get_be32(&s->ptr); | |
855 if(n < 0 || n > 3){ | |
856 av_log(avctx, AV_LOG_ERROR, "Incorrect offset passed\n"); | |
857 s->data = NULL; | |
858 return -1; | |
859 } | |
860 s->ptr += n; | |
861 | |
862 s->currentframeblocks = nblocks; | |
863 buf += 4; | |
864 if (s->samples <= 0) { | |
865 *data_size = 0; | |
866 return buf_size; | |
867 } | |
868 | |
869 memset(s->decoded0, 0, sizeof(s->decoded0)); | |
870 memset(s->decoded1, 0, sizeof(s->decoded1)); | |
871 | |
872 /* Initialize the frame decoder */ | |
873 init_frame_decoder(s); | |
874 } | |
875 | |
876 if (!s->data) { | |
877 *data_size = 0; | |
878 return buf_size; | |
879 } | |
880 | |
881 nblocks = s->samples; | |
882 blockstodecode = FFMIN(BLOCKS_PER_LOOP, nblocks); | |
883 | |
6443
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
884 s->error=0; |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
885 |
5673 | 886 if ((s->channels == 1) || (s->frameflags & APE_FRAMECODE_PSEUDO_STEREO)) |
887 ape_unpack_mono(s, blockstodecode); | |
888 else | |
889 ape_unpack_stereo(s, blockstodecode); | |
890 | |
6443
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
891 if(s->error || s->ptr > s->data_end){ |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
892 s->samples=0; |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
893 av_log(avctx, AV_LOG_ERROR, "Error decoding frame\n"); |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
894 return -1; |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
895 } |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
896 |
5673 | 897 for (i = 0; i < blockstodecode; i++) { |
898 *samples++ = s->decoded0[i]; | |
899 if(s->channels == 2) | |
900 *samples++ = s->decoded1[i]; | |
901 } | |
902 | |
903 s->samples -= blockstodecode; | |
904 | |
905 *data_size = blockstodecode * 2 * s->channels; | |
906 bytes_used = s->samples ? s->ptr - s->last_ptr : buf_size; | |
907 s->last_ptr = s->ptr; | |
908 return bytes_used; | |
909 } | |
910 | |
911 AVCodec ape_decoder = { | |
912 "ape", | |
913 CODEC_TYPE_AUDIO, | |
914 CODEC_ID_APE, | |
915 sizeof(APEContext), | |
916 ape_decode_init, | |
917 NULL, | |
918 ape_decode_close, | |
919 ape_decode_frame, | |
6712 | 920 .long_name = "Monkey's Audio", |
5673 | 921 }; |