Mercurial > libavcodec.hg
annotate apedec.c @ 10893:2aafcafbe1f0 libavcodec
Replace cabac checks in inline functions from h264.h with constants.
No benchmark because its just replacing variables with litteral constants
(so no risk for slowdown outside gcc silliness) and i need sleep.
author | michael |
---|---|
date | Sat, 16 Jan 2010 05:41:33 +0000 |
parents | 5da7180afadf |
children | 5518cf6b6f2e |
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" | |
9428 | 26 #include "get_bits.h" |
5673 | 27 #include "bytestream.h" |
28 | |
29 /** | |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8683
diff
changeset
|
30 * @file libavcodec/apedec.c |
5673 | 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 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6482
diff
changeset
|
165 static av_cold int ape_decode_init(AVCodecContext * avctx) |
5673 | 166 { |
167 APEContext *s = avctx->priv_data; | |
168 int i; | |
169 | |
170 if (avctx->extradata_size != 6) { | |
171 av_log(avctx, AV_LOG_ERROR, "Incorrect extradata\n"); | |
172 return -1; | |
173 } | |
7823
4525dcd81357
Bump Major version, this commit is almost just renaming bits_per_sample to
michael
parents:
7723
diff
changeset
|
174 if (avctx->bits_per_coded_sample != 16) { |
5673 | 175 av_log(avctx, AV_LOG_ERROR, "Only 16-bit samples are supported\n"); |
176 return -1; | |
177 } | |
178 if (avctx->channels > 2) { | |
179 av_log(avctx, AV_LOG_ERROR, "Only mono and stereo is supported\n"); | |
180 return -1; | |
181 } | |
182 s->avctx = avctx; | |
183 s->channels = avctx->channels; | |
184 s->fileversion = AV_RL16(avctx->extradata); | |
185 s->compression_level = AV_RL16(avctx->extradata + 2); | |
186 s->flags = AV_RL16(avctx->extradata + 4); | |
187 | |
188 av_log(avctx, AV_LOG_DEBUG, "Compression Level: %d - Flags: %d\n", s->compression_level, s->flags); | |
189 if (s->compression_level % 1000 || s->compression_level > COMPRESSION_LEVEL_INSANE) { | |
190 av_log(avctx, AV_LOG_ERROR, "Incorrect compression level %d\n", s->compression_level); | |
191 return -1; | |
192 } | |
193 s->fset = s->compression_level / 1000 - 1; | |
194 for (i = 0; i < APE_FILTER_LEVELS; i++) { | |
195 if (!ape_filter_orders[s->fset][i]) | |
196 break; | |
197 s->filterbuf[i] = av_malloc((ape_filter_orders[s->fset][i] * 3 + HISTORY_SIZE) * 4); | |
198 } | |
199 | |
200 dsputil_init(&s->dsp, avctx); | |
7451
85ab7655ad4d
Modify all codecs to report their supported input and output sample format(s).
pross
parents:
7203
diff
changeset
|
201 avctx->sample_fmt = SAMPLE_FMT_S16; |
8174
f11197441364
Add channel layout to several audio decoders I maintain
kostya
parents:
7914
diff
changeset
|
202 avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO; |
5673 | 203 return 0; |
204 } | |
205 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6482
diff
changeset
|
206 static av_cold int ape_decode_close(AVCodecContext * avctx) |
5673 | 207 { |
208 APEContext *s = avctx->priv_data; | |
209 int i; | |
210 | |
211 for (i = 0; i < APE_FILTER_LEVELS; i++) | |
212 av_freep(&s->filterbuf[i]); | |
213 | |
214 return 0; | |
215 } | |
216 | |
217 /** | |
218 * @defgroup rangecoder APE range decoder | |
219 * @{ | |
220 */ | |
221 | |
222 #define CODE_BITS 32 | |
223 #define TOP_VALUE ((unsigned int)1 << (CODE_BITS-1)) | |
224 #define SHIFT_BITS (CODE_BITS - 9) | |
225 #define EXTRA_BITS ((CODE_BITS-2) % 8 + 1) | |
226 #define BOTTOM_VALUE (TOP_VALUE >> 8) | |
227 | |
228 /** Start the decoder */ | |
229 static inline void range_start_decoding(APEContext * ctx) | |
230 { | |
231 ctx->rc.buffer = bytestream_get_byte(&ctx->ptr); | |
232 ctx->rc.low = ctx->rc.buffer >> (8 - EXTRA_BITS); | |
233 ctx->rc.range = (uint32_t) 1 << EXTRA_BITS; | |
234 } | |
235 | |
236 /** Perform normalization */ | |
237 static inline void range_dec_normalize(APEContext * ctx) | |
238 { | |
239 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
|
240 ctx->rc.buffer <<= 8; |
28e45bf84973
Prevent segfault due to reading over the end of the input buffer.
michael
parents:
6223
diff
changeset
|
241 if(ctx->ptr < ctx->data_end) |
28e45bf84973
Prevent segfault due to reading over the end of the input buffer.
michael
parents:
6223
diff
changeset
|
242 ctx->rc.buffer += *ctx->ptr; |
28e45bf84973
Prevent segfault due to reading over the end of the input buffer.
michael
parents:
6223
diff
changeset
|
243 ctx->ptr++; |
5673 | 244 ctx->rc.low = (ctx->rc.low << 8) | ((ctx->rc.buffer >> 1) & 0xFF); |
245 ctx->rc.range <<= 8; | |
246 } | |
247 } | |
248 | |
249 /** | |
250 * Calculate culmulative frequency for next symbol. Does NO update! | |
8683 | 251 * @param ctx decoder context |
5673 | 252 * @param tot_f is the total frequency or (code_value)1<<shift |
253 * @return the culmulative frequency | |
254 */ | |
255 static inline int range_decode_culfreq(APEContext * ctx, int tot_f) | |
256 { | |
257 range_dec_normalize(ctx); | |
258 ctx->rc.help = ctx->rc.range / tot_f; | |
259 return ctx->rc.low / ctx->rc.help; | |
260 } | |
261 | |
262 /** | |
263 * Decode value with given size in bits | |
8683 | 264 * @param ctx decoder context |
5673 | 265 * @param shift number of bits to decode |
266 */ | |
267 static inline int range_decode_culshift(APEContext * ctx, int shift) | |
268 { | |
269 range_dec_normalize(ctx); | |
270 ctx->rc.help = ctx->rc.range >> shift; | |
271 return ctx->rc.low / ctx->rc.help; | |
272 } | |
273 | |
274 | |
275 /** | |
276 * Update decoding state | |
8683 | 277 * @param ctx decoder context |
5673 | 278 * @param sy_f the interval length (frequency of the symbol) |
279 * @param lt_f the lower end (frequency sum of < symbols) | |
280 */ | |
281 static inline void range_decode_update(APEContext * ctx, int sy_f, int lt_f) | |
282 { | |
283 ctx->rc.low -= ctx->rc.help * lt_f; | |
284 ctx->rc.range = ctx->rc.help * sy_f; | |
285 } | |
286 | |
287 /** Decode n bits (n <= 16) without modelling */ | |
288 static inline int range_decode_bits(APEContext * ctx, int n) | |
289 { | |
290 int sym = range_decode_culshift(ctx, n); | |
291 range_decode_update(ctx, 1, sym); | |
292 return sym; | |
293 } | |
294 | |
295 | |
296 #define MODEL_ELEMENTS 64 | |
297 | |
298 /** | |
299 * Fixed probabilities for symbols in Monkey Audio version 3.97 | |
300 */ | |
6482 | 301 static const uint16_t counts_3970[22] = { |
5673 | 302 0, 14824, 28224, 39348, 47855, 53994, 58171, 60926, |
303 62682, 63786, 64463, 64878, 65126, 65276, 65365, 65419, | |
6444 | 304 65450, 65469, 65480, 65487, 65491, 65493, |
5673 | 305 }; |
306 | |
307 /** | |
308 * Probability ranges for symbols in Monkey Audio version 3.97 | |
309 */ | |
6444 | 310 static const uint16_t counts_diff_3970[21] = { |
5673 | 311 14824, 13400, 11124, 8507, 6139, 4177, 2755, 1756, |
312 1104, 677, 415, 248, 150, 89, 54, 31, | |
6444 | 313 19, 11, 7, 4, 2, |
5673 | 314 }; |
315 | |
316 /** | |
317 * Fixed probabilities for symbols in Monkey Audio version 3.98 | |
318 */ | |
6482 | 319 static const uint16_t counts_3980[22] = { |
5673 | 320 0, 19578, 36160, 48417, 56323, 60899, 63265, 64435, |
321 64971, 65232, 65351, 65416, 65447, 65466, 65476, 65482, | |
6444 | 322 65485, 65488, 65490, 65491, 65492, 65493, |
5673 | 323 }; |
324 | |
325 /** | |
326 * Probability ranges for symbols in Monkey Audio version 3.98 | |
327 */ | |
6444 | 328 static const uint16_t counts_diff_3980[21] = { |
5673 | 329 19578, 16582, 12257, 7906, 4576, 2366, 1170, 536, |
330 261, 119, 65, 31, 19, 10, 6, 3, | |
6444 | 331 3, 2, 1, 1, 1, |
5673 | 332 }; |
333 | |
334 /** | |
335 * Decode symbol | |
8683 | 336 * @param ctx decoder context |
5673 | 337 * @param counts probability range start position |
8683 | 338 * @param counts_diff probability range widths |
5673 | 339 */ |
340 static inline int range_get_symbol(APEContext * ctx, | |
6482 | 341 const uint16_t counts[], |
5673 | 342 const uint16_t counts_diff[]) |
343 { | |
344 int symbol, cf; | |
345 | |
346 cf = range_decode_culshift(ctx, 16); | |
347 | |
6443
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
348 if(cf > 65492){ |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
349 symbol= cf - 65535 + 63; |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
350 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
|
351 if(cf > 65535) |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
352 ctx->error=1; |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
353 return symbol; |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
354 } |
5673 | 355 /* figure out the symbol inefficiently; a binary search would be much better */ |
356 for (symbol = 0; counts[symbol + 1] <= cf; symbol++); | |
357 | |
358 range_decode_update(ctx, counts_diff[symbol], counts[symbol]); | |
359 | |
360 return symbol; | |
361 } | |
362 /** @} */ // group rangecoder | |
363 | |
364 static inline void update_rice(APERice *rice, int x) | |
365 { | |
7914
c15b1e83d27d
Correct wrong lower limit and condition used in APE decoder
kostya
parents:
7823
diff
changeset
|
366 int lim = rice->k ? (1 << (rice->k + 4)) : 0; |
5673 | 367 rice->ksum += ((x + 1) / 2) - ((rice->ksum + 16) >> 5); |
368 | |
7914
c15b1e83d27d
Correct wrong lower limit and condition used in APE decoder
kostya
parents:
7823
diff
changeset
|
369 if (rice->ksum < lim) |
5673 | 370 rice->k--; |
371 else if (rice->ksum >= (1 << (rice->k + 5))) | |
372 rice->k++; | |
373 } | |
374 | |
375 static inline int ape_decode_value(APEContext * ctx, APERice *rice) | |
376 { | |
377 int x, overflow; | |
378 | |
7723
20b105281e87
While APE changed container format in 3.98, frequency tables for range coding
kostya
parents:
7451
diff
changeset
|
379 if (ctx->fileversion < 3990) { |
5673 | 380 int tmpk; |
381 | |
382 overflow = range_get_symbol(ctx, counts_3970, counts_diff_3970); | |
383 | |
384 if (overflow == (MODEL_ELEMENTS - 1)) { | |
385 tmpk = range_decode_bits(ctx, 5); | |
386 overflow = 0; | |
387 } else | |
388 tmpk = (rice->k < 1) ? 0 : rice->k - 1; | |
389 | |
390 if (tmpk <= 16) | |
391 x = range_decode_bits(ctx, tmpk); | |
392 else { | |
393 x = range_decode_bits(ctx, 16); | |
394 x |= (range_decode_bits(ctx, tmpk - 16) << 16); | |
395 } | |
396 x += overflow << tmpk; | |
397 } else { | |
398 int base, pivot; | |
399 | |
400 pivot = rice->ksum >> 5; | |
401 if (pivot == 0) | |
402 pivot = 1; | |
403 | |
404 overflow = range_get_symbol(ctx, counts_3980, counts_diff_3980); | |
405 | |
406 if (overflow == (MODEL_ELEMENTS - 1)) { | |
407 overflow = range_decode_bits(ctx, 16) << 16; | |
408 overflow |= range_decode_bits(ctx, 16); | |
409 } | |
410 | |
10545
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
411 if (pivot < 0x10000) { |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
412 base = range_decode_culfreq(ctx, pivot); |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
413 range_decode_update(ctx, 1, base); |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
414 } else { |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
415 int base_hi = pivot, base_lo; |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
416 int bbits = 0; |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
417 |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
418 while (base_hi & ~0xFFFF) { |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
419 base_hi >>= 1; |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
420 bbits++; |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
421 } |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
422 base_hi = range_decode_culfreq(ctx, base_hi + 1); |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
423 range_decode_update(ctx, 1, base_hi); |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
424 base_lo = range_decode_culfreq(ctx, 1 << bbits); |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
425 range_decode_update(ctx, 1, base_lo); |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
426 |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
427 base = (base_hi << bbits) + base_lo; |
e5a8a6b9a717
Implement missing case for decoding samples with large pivot value in APE
kostya
parents:
10181
diff
changeset
|
428 } |
5673 | 429 |
430 x = base + overflow * pivot; | |
431 } | |
432 | |
433 update_rice(rice, x); | |
434 | |
435 /* Convert to signed */ | |
436 if (x & 1) | |
437 return (x >> 1) + 1; | |
438 else | |
439 return -(x >> 1); | |
440 } | |
441 | |
442 static void entropy_decode(APEContext * ctx, int blockstodecode, int stereo) | |
443 { | |
444 int32_t *decoded0 = ctx->decoded0; | |
445 int32_t *decoded1 = ctx->decoded1; | |
446 | |
447 ctx->blocksdecoded = blockstodecode; | |
448 | |
449 if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) { | |
450 /* We are pure silence, just memset the output buffer. */ | |
451 memset(decoded0, 0, blockstodecode * sizeof(int32_t)); | |
452 memset(decoded1, 0, blockstodecode * sizeof(int32_t)); | |
453 } else { | |
454 while (blockstodecode--) { | |
455 *decoded0++ = ape_decode_value(ctx, &ctx->riceY); | |
456 if (stereo) | |
457 *decoded1++ = ape_decode_value(ctx, &ctx->riceX); | |
458 } | |
459 } | |
460 | |
461 if (ctx->blocksdecoded == ctx->currentframeblocks) | |
462 range_dec_normalize(ctx); /* normalize to use up all bytes */ | |
463 } | |
464 | |
465 static void init_entropy_decoder(APEContext * ctx) | |
466 { | |
467 /* Read the CRC */ | |
468 ctx->CRC = bytestream_get_be32(&ctx->ptr); | |
469 | |
470 /* Read the frame flags if they exist */ | |
471 ctx->frameflags = 0; | |
472 if ((ctx->fileversion > 3820) && (ctx->CRC & 0x80000000)) { | |
473 ctx->CRC &= ~0x80000000; | |
474 | |
475 ctx->frameflags = bytestream_get_be32(&ctx->ptr); | |
476 } | |
477 | |
478 /* Keep a count of the blocks decoded in this frame */ | |
479 ctx->blocksdecoded = 0; | |
480 | |
5963 | 481 /* Initialize the rice structs */ |
5673 | 482 ctx->riceX.k = 10; |
483 ctx->riceX.ksum = (1 << ctx->riceX.k) * 16; | |
484 ctx->riceY.k = 10; | |
485 ctx->riceY.ksum = (1 << ctx->riceY.k) * 16; | |
486 | |
487 /* The first 8 bits of input are ignored. */ | |
488 ctx->ptr++; | |
489 | |
490 range_start_decoding(ctx); | |
491 } | |
492 | |
493 static const int32_t initial_coeffs[4] = { | |
494 360, 317, -109, 98 | |
495 }; | |
496 | |
497 static void init_predictor_decoder(APEContext * ctx) | |
498 { | |
499 APEPredictor *p = &ctx->predictor; | |
500 | |
501 /* Zero the history buffers */ | |
502 memset(p->historybuffer, 0, PREDICTOR_SIZE * sizeof(int32_t)); | |
503 p->buf = p->historybuffer; | |
504 | |
5966 | 505 /* Initialize and zero the coefficients */ |
5673 | 506 memcpy(p->coeffsA[0], initial_coeffs, sizeof(initial_coeffs)); |
507 memcpy(p->coeffsA[1], initial_coeffs, sizeof(initial_coeffs)); | |
508 memset(p->coeffsB, 0, sizeof(p->coeffsB)); | |
509 | |
510 p->filterA[0] = p->filterA[1] = 0; | |
511 p->filterB[0] = p->filterB[1] = 0; | |
512 p->lastA[0] = p->lastA[1] = 0; | |
513 } | |
514 | |
515 /** Get inverse sign of integer (-1 for positive, 1 for negative and 0 for zero) */ | |
516 static inline int APESIGN(int32_t x) { | |
517 return (x < 0) - (x > 0); | |
518 } | |
519 | |
10631 | 520 static av_always_inline int predictor_update_filter(APEPredictor *p, const int decoded, const int filter, const int delayA, const int delayB, const int adaptA, const int adaptB) |
5673 | 521 { |
10632 | 522 int32_t predictionA, predictionB, sign; |
5673 | 523 |
524 p->buf[delayA] = p->lastA[filter]; | |
525 p->buf[adaptA] = APESIGN(p->buf[delayA]); | |
526 p->buf[delayA - 1] = p->buf[delayA] - p->buf[delayA - 1]; | |
527 p->buf[adaptA - 1] = APESIGN(p->buf[delayA - 1]); | |
528 | |
529 predictionA = p->buf[delayA ] * p->coeffsA[filter][0] + | |
530 p->buf[delayA - 1] * p->coeffsA[filter][1] + | |
531 p->buf[delayA - 2] * p->coeffsA[filter][2] + | |
532 p->buf[delayA - 3] * p->coeffsA[filter][3]; | |
533 | |
534 /* Apply a scaled first-order filter compression */ | |
535 p->buf[delayB] = p->filterA[filter ^ 1] - ((p->filterB[filter] * 31) >> 5); | |
536 p->buf[adaptB] = APESIGN(p->buf[delayB]); | |
537 p->buf[delayB - 1] = p->buf[delayB] - p->buf[delayB - 1]; | |
538 p->buf[adaptB - 1] = APESIGN(p->buf[delayB - 1]); | |
539 p->filterB[filter] = p->filterA[filter ^ 1]; | |
540 | |
541 predictionB = p->buf[delayB ] * p->coeffsB[filter][0] + | |
542 p->buf[delayB - 1] * p->coeffsB[filter][1] + | |
543 p->buf[delayB - 2] * p->coeffsB[filter][2] + | |
544 p->buf[delayB - 3] * p->coeffsB[filter][3] + | |
545 p->buf[delayB - 4] * p->coeffsB[filter][4]; | |
546 | |
547 p->lastA[filter] = decoded + ((predictionA + (predictionB >> 1)) >> 10); | |
548 p->filterA[filter] = p->lastA[filter] + ((p->filterA[filter] * 31) >> 5); | |
549 | |
10632 | 550 sign = APESIGN(decoded); |
551 p->coeffsA[filter][0] += p->buf[adaptA ] * sign; | |
552 p->coeffsA[filter][1] += p->buf[adaptA - 1] * sign; | |
553 p->coeffsA[filter][2] += p->buf[adaptA - 2] * sign; | |
554 p->coeffsA[filter][3] += p->buf[adaptA - 3] * sign; | |
555 p->coeffsB[filter][0] += p->buf[adaptB ] * sign; | |
556 p->coeffsB[filter][1] += p->buf[adaptB - 1] * sign; | |
557 p->coeffsB[filter][2] += p->buf[adaptB - 2] * sign; | |
558 p->coeffsB[filter][3] += p->buf[adaptB - 3] * sign; | |
559 p->coeffsB[filter][4] += p->buf[adaptB - 4] * sign; | |
5673 | 560 |
561 return p->filterA[filter]; | |
562 } | |
563 | |
564 static void predictor_decode_stereo(APEContext * ctx, int count) | |
565 { | |
566 APEPredictor *p = &ctx->predictor; | |
567 int32_t *decoded0 = ctx->decoded0; | |
568 int32_t *decoded1 = ctx->decoded1; | |
569 | |
570 while (count--) { | |
571 /* Predictor Y */ | |
10631 | 572 *decoded0 = predictor_update_filter(p, *decoded0, 0, YDELAYA, YDELAYB, YADAPTCOEFFSA, YADAPTCOEFFSB); |
573 decoded0++; | |
574 *decoded1 = predictor_update_filter(p, *decoded1, 1, XDELAYA, XDELAYB, XADAPTCOEFFSA, XADAPTCOEFFSB); | |
575 decoded1++; | |
5673 | 576 |
577 /* Combined */ | |
578 p->buf++; | |
579 | |
580 /* Have we filled the history buffer? */ | |
581 if (p->buf == p->historybuffer + HISTORY_SIZE) { | |
582 memmove(p->historybuffer, p->buf, PREDICTOR_SIZE * sizeof(int32_t)); | |
583 p->buf = p->historybuffer; | |
584 } | |
585 } | |
586 } | |
587 | |
588 static void predictor_decode_mono(APEContext * ctx, int count) | |
589 { | |
590 APEPredictor *p = &ctx->predictor; | |
591 int32_t *decoded0 = ctx->decoded0; | |
10632 | 592 int32_t predictionA, currentA, A, sign; |
5673 | 593 |
594 currentA = p->lastA[0]; | |
595 | |
596 while (count--) { | |
597 A = *decoded0; | |
598 | |
599 p->buf[YDELAYA] = currentA; | |
600 p->buf[YDELAYA - 1] = p->buf[YDELAYA] - p->buf[YDELAYA - 1]; | |
601 | |
602 predictionA = p->buf[YDELAYA ] * p->coeffsA[0][0] + | |
603 p->buf[YDELAYA - 1] * p->coeffsA[0][1] + | |
604 p->buf[YDELAYA - 2] * p->coeffsA[0][2] + | |
605 p->buf[YDELAYA - 3] * p->coeffsA[0][3]; | |
606 | |
607 currentA = A + (predictionA >> 10); | |
608 | |
609 p->buf[YADAPTCOEFFSA] = APESIGN(p->buf[YDELAYA ]); | |
610 p->buf[YADAPTCOEFFSA - 1] = APESIGN(p->buf[YDELAYA - 1]); | |
611 | |
10632 | 612 sign = APESIGN(A); |
613 p->coeffsA[0][0] += p->buf[YADAPTCOEFFSA ] * sign; | |
614 p->coeffsA[0][1] += p->buf[YADAPTCOEFFSA - 1] * sign; | |
615 p->coeffsA[0][2] += p->buf[YADAPTCOEFFSA - 2] * sign; | |
616 p->coeffsA[0][3] += p->buf[YADAPTCOEFFSA - 3] * sign; | |
5673 | 617 |
618 p->buf++; | |
619 | |
620 /* Have we filled the history buffer? */ | |
621 if (p->buf == p->historybuffer + HISTORY_SIZE) { | |
622 memmove(p->historybuffer, p->buf, PREDICTOR_SIZE * sizeof(int32_t)); | |
623 p->buf = p->historybuffer; | |
624 } | |
625 | |
626 p->filterA[0] = currentA + ((p->filterA[0] * 31) >> 5); | |
627 *(decoded0++) = p->filterA[0]; | |
628 } | |
629 | |
630 p->lastA[0] = currentA; | |
631 } | |
632 | |
633 static void do_init_filter(APEFilter *f, int16_t * buf, int order) | |
634 { | |
635 f->coeffs = buf; | |
636 f->historybuffer = buf + order; | |
637 f->delay = f->historybuffer + order * 2; | |
638 f->adaptcoeffs = f->historybuffer + order; | |
639 | |
640 memset(f->historybuffer, 0, (order * 2) * sizeof(int16_t)); | |
641 memset(f->coeffs, 0, order * sizeof(int16_t)); | |
642 f->avg = 0; | |
643 } | |
644 | |
645 static void init_filter(APEContext * ctx, APEFilter *f, int16_t * buf, int order) | |
646 { | |
647 do_init_filter(&f[0], buf, order); | |
648 do_init_filter(&f[1], buf + order * 3 + HISTORY_SIZE, order); | |
649 } | |
650 | |
10644 | 651 static void do_apply_filter(APEContext * ctx, int version, APEFilter *f, int32_t *data, int count, int order, int fracbits) |
5673 | 652 { |
653 int res; | |
654 int absres; | |
655 | |
656 while (count--) { | |
657 /* round fixedpoint scalar product */ | |
10644 | 658 res = ctx->dsp.scalarproduct_and_madd_int16(f->coeffs, f->delay - order, f->adaptcoeffs - order, order, APESIGN(*data)); |
659 res = (res + (1 << (fracbits - 1))) >> fracbits; | |
5673 | 660 res += *data; |
661 *data++ = res; | |
662 | |
663 /* Update the output history */ | |
664 *f->delay++ = av_clip_int16(res); | |
665 | |
666 if (version < 3980) { | |
667 /* Version ??? to < 3.98 files (untested) */ | |
668 f->adaptcoeffs[0] = (res == 0) ? 0 : ((res >> 28) & 8) - 4; | |
669 f->adaptcoeffs[-4] >>= 1; | |
670 f->adaptcoeffs[-8] >>= 1; | |
671 } else { | |
672 /* Version 3.98 and later files */ | |
673 | |
674 /* Update the adaption coefficients */ | |
10639
4e0b0c0cb915
1-13% faster apply_filter, 1-3% faster ape decoding on core2
lorenm
parents:
10638
diff
changeset
|
675 absres = FFABS(res); |
4e0b0c0cb915
1-13% faster apply_filter, 1-3% faster ape decoding on core2
lorenm
parents:
10638
diff
changeset
|
676 if (absres) |
4e0b0c0cb915
1-13% faster apply_filter, 1-3% faster ape decoding on core2
lorenm
parents:
10638
diff
changeset
|
677 *f->adaptcoeffs = ((res & (1<<31)) - (1<<30)) >> (25 + (absres <= f->avg*3) + (absres <= f->avg*4/3)); |
5673 | 678 else |
679 *f->adaptcoeffs = 0; | |
680 | |
681 f->avg += (absres - f->avg) / 16; | |
682 | |
683 f->adaptcoeffs[-1] >>= 1; | |
684 f->adaptcoeffs[-2] >>= 1; | |
685 f->adaptcoeffs[-8] >>= 1; | |
686 } | |
687 | |
688 f->adaptcoeffs++; | |
689 | |
690 /* Have we filled the history buffer? */ | |
691 if (f->delay == f->historybuffer + HISTORY_SIZE + (order * 2)) { | |
692 memmove(f->historybuffer, f->delay - (order * 2), | |
693 (order * 2) * sizeof(int16_t)); | |
694 f->delay = f->historybuffer + order * 2; | |
695 f->adaptcoeffs = f->historybuffer + order; | |
696 } | |
697 } | |
698 } | |
699 | |
700 static void apply_filter(APEContext * ctx, APEFilter *f, | |
701 int32_t * data0, int32_t * data1, | |
702 int count, int order, int fracbits) | |
703 { | |
7203
87b1dfb5a98d
Add several vector functions used by Monkey's Audio decoder to dsputil
kostya
parents:
7040
diff
changeset
|
704 do_apply_filter(ctx, ctx->fileversion, &f[0], data0, count, order, fracbits); |
5673 | 705 if (data1) |
7203
87b1dfb5a98d
Add several vector functions used by Monkey's Audio decoder to dsputil
kostya
parents:
7040
diff
changeset
|
706 do_apply_filter(ctx, ctx->fileversion, &f[1], data1, count, order, fracbits); |
5673 | 707 } |
708 | |
709 static void ape_apply_filters(APEContext * ctx, int32_t * decoded0, | |
710 int32_t * decoded1, int count) | |
711 { | |
712 int i; | |
713 | |
714 for (i = 0; i < APE_FILTER_LEVELS; i++) { | |
715 if (!ape_filter_orders[ctx->fset][i]) | |
716 break; | |
717 apply_filter(ctx, ctx->filters[i], decoded0, decoded1, count, ape_filter_orders[ctx->fset][i], ape_filter_fracbits[ctx->fset][i]); | |
718 } | |
719 } | |
720 | |
721 static void init_frame_decoder(APEContext * ctx) | |
722 { | |
723 int i; | |
724 init_entropy_decoder(ctx); | |
725 init_predictor_decoder(ctx); | |
726 | |
727 for (i = 0; i < APE_FILTER_LEVELS; i++) { | |
728 if (!ape_filter_orders[ctx->fset][i]) | |
729 break; | |
730 init_filter(ctx, ctx->filters[i], ctx->filterbuf[i], ape_filter_orders[ctx->fset][i]); | |
731 } | |
732 } | |
733 | |
734 static void ape_unpack_mono(APEContext * ctx, int count) | |
735 { | |
736 int32_t left; | |
737 int32_t *decoded0 = ctx->decoded0; | |
738 int32_t *decoded1 = ctx->decoded1; | |
739 | |
740 if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) { | |
741 entropy_decode(ctx, count, 0); | |
742 /* We are pure silence, so we're done. */ | |
743 av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence mono\n"); | |
744 return; | |
745 } | |
746 | |
747 entropy_decode(ctx, count, 0); | |
748 ape_apply_filters(ctx, decoded0, NULL, count); | |
749 | |
750 /* Now apply the predictor decoding */ | |
751 predictor_decode_mono(ctx, count); | |
752 | |
753 /* Pseudo-stereo - just copy left channel to right channel */ | |
754 if (ctx->channels == 2) { | |
755 while (count--) { | |
756 left = *decoded0; | |
757 *(decoded1++) = *(decoded0++) = left; | |
758 } | |
759 } | |
760 } | |
761 | |
762 static void ape_unpack_stereo(APEContext * ctx, int count) | |
763 { | |
764 int32_t left, right; | |
765 int32_t *decoded0 = ctx->decoded0; | |
766 int32_t *decoded1 = ctx->decoded1; | |
767 | |
768 if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) { | |
769 /* We are pure silence, so we're done. */ | |
770 av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence stereo\n"); | |
771 return; | |
772 } | |
773 | |
774 entropy_decode(ctx, count, 1); | |
775 ape_apply_filters(ctx, decoded0, decoded1, count); | |
776 | |
777 /* Now apply the predictor decoding */ | |
778 predictor_decode_stereo(ctx, count); | |
779 | |
780 /* Decorrelate and scale to output depth */ | |
781 while (count--) { | |
782 left = *decoded1 - (*decoded0 / 2); | |
783 right = left + *decoded0; | |
784 | |
785 *(decoded0++) = left; | |
786 *(decoded1++) = right; | |
787 } | |
788 } | |
789 | |
790 static int ape_decode_frame(AVCodecContext * avctx, | |
791 void *data, int *data_size, | |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
792 AVPacket *avpkt) |
5673 | 793 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
794 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
795 int buf_size = avpkt->size; |
5673 | 796 APEContext *s = avctx->priv_data; |
797 int16_t *samples = data; | |
798 int nblocks; | |
799 int i, n; | |
800 int blockstodecode; | |
801 int bytes_used; | |
802 | |
803 if (buf_size == 0 && !s->samples) { | |
804 *data_size = 0; | |
805 return 0; | |
806 } | |
807 | |
808 /* should not happen but who knows */ | |
809 if (BLOCKS_PER_LOOP * 2 * avctx->channels > *data_size) { | |
810 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); | |
811 return -1; | |
812 } | |
813 | |
814 if(!s->samples){ | |
815 s->data = av_realloc(s->data, (buf_size + 3) & ~3); | |
6223 | 816 s->dsp.bswap_buf((uint32_t*)s->data, (const uint32_t*)buf, buf_size >> 2); |
5673 | 817 s->ptr = s->last_ptr = s->data; |
818 s->data_end = s->data + buf_size; | |
819 | |
820 nblocks = s->samples = bytestream_get_be32(&s->ptr); | |
821 n = bytestream_get_be32(&s->ptr); | |
822 if(n < 0 || n > 3){ | |
823 av_log(avctx, AV_LOG_ERROR, "Incorrect offset passed\n"); | |
824 s->data = NULL; | |
825 return -1; | |
826 } | |
827 s->ptr += n; | |
828 | |
829 s->currentframeblocks = nblocks; | |
830 buf += 4; | |
831 if (s->samples <= 0) { | |
832 *data_size = 0; | |
833 return buf_size; | |
834 } | |
835 | |
836 memset(s->decoded0, 0, sizeof(s->decoded0)); | |
837 memset(s->decoded1, 0, sizeof(s->decoded1)); | |
838 | |
839 /* Initialize the frame decoder */ | |
840 init_frame_decoder(s); | |
841 } | |
842 | |
843 if (!s->data) { | |
844 *data_size = 0; | |
845 return buf_size; | |
846 } | |
847 | |
848 nblocks = s->samples; | |
849 blockstodecode = FFMIN(BLOCKS_PER_LOOP, nblocks); | |
850 | |
6443
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
851 s->error=0; |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
852 |
5673 | 853 if ((s->channels == 1) || (s->frameflags & APE_FRAMECODE_PSEUDO_STEREO)) |
854 ape_unpack_mono(s, blockstodecode); | |
855 else | |
856 ape_unpack_stereo(s, blockstodecode); | |
10638
40ff9c7958da
100l trocadero: call emms_c() after doing decoding with SIMD in APE decoder
kostya
parents:
10632
diff
changeset
|
857 emms_c(); |
5673 | 858 |
6443
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
859 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
|
860 s->samples=0; |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
861 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
|
862 return -1; |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
863 } |
e3adb7e96812
Detect and prevent reading over the end of counts_*. We pass the error
michael
parents:
6442
diff
changeset
|
864 |
5673 | 865 for (i = 0; i < blockstodecode; i++) { |
866 *samples++ = s->decoded0[i]; | |
867 if(s->channels == 2) | |
868 *samples++ = s->decoded1[i]; | |
869 } | |
870 | |
871 s->samples -= blockstodecode; | |
872 | |
873 *data_size = blockstodecode * 2 * s->channels; | |
874 bytes_used = s->samples ? s->ptr - s->last_ptr : buf_size; | |
875 s->last_ptr = s->ptr; | |
876 return bytes_used; | |
877 } | |
878 | |
879 AVCodec ape_decoder = { | |
880 "ape", | |
881 CODEC_TYPE_AUDIO, | |
882 CODEC_ID_APE, | |
883 sizeof(APEContext), | |
884 ape_decode_init, | |
885 NULL, | |
886 ape_decode_close, | |
887 ape_decode_frame, | |
10181
b33c75c58ffe
Monkey's Audio uses subframes too, declare that in its capabilities
kostya
parents:
9428
diff
changeset
|
888 .capabilities = CODEC_CAP_SUBFRAMES, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6712
diff
changeset
|
889 .long_name = NULL_IF_CONFIG_SMALL("Monkey's Audio"), |
5673 | 890 }; |