Update SILK code using the CELT range coder
[opus.git] / src_SigProc_FIX / SKP_Silk_MacroCount.h
1 #ifndef _SIGPROCFIX_API_MACROCOUNT_H_\r
2 #define _SIGPROCFIX_API_MACROCOUNT_H_\r
3 #include <stdio.h>\r
4 \r
5 #ifdef  SKP_MACRO_COUNT\r
6 #define varDefine SKP_int64 ops_count = 0;\r
7 \r
8 extern SKP_int64 ops_count;\r
9 \r
10 SKP_INLINE SKP_int64 SKP_SaveCount(){\r
11         return(ops_count);\r
12 }\r
13 \r
14 SKP_INLINE SKP_int64 SKP_SaveResetCount(){\r
15         SKP_int64 ret;\r
16 \r
17         ret = ops_count;\r
18         ops_count = 0;\r
19         return(ret);\r
20 }\r
21 \r
22 SKP_INLINE SKP_PrintCount(){\r
23         printf("ops_count = %d \n ", (SKP_int32)ops_count);\r
24 }\r
25 \r
26 #undef SKP_MUL\r
27 SKP_INLINE SKP_int32 SKP_MUL(SKP_int32 a32, SKP_int32 b32){\r
28         SKP_int32 ret;\r
29         ops_count += 4;\r
30         ret = a32 * b32;\r
31         return ret;\r
32 }\r
33 \r
34 #undef SKP_MUL_uint\r
35 SKP_INLINE SKP_uint32 SKP_MUL_uint(SKP_uint32 a32, SKP_uint32 b32){\r
36         SKP_uint32 ret;\r
37         ops_count += 4;\r
38         ret = a32 * b32;\r
39         return ret;\r
40 }\r
41 #undef SKP_MLA\r
42 SKP_INLINE SKP_int32 SKP_MLA(SKP_int32 a32, SKP_int32 b32, SKP_int32 c32){\r
43         SKP_int32 ret;\r
44         ops_count += 4;\r
45         ret = a32 + b32 * c32;\r
46         return ret;\r
47 }\r
48 \r
49 #undef SKP_MLA_uint\r
50 SKP_INLINE SKP_int32 SKP_MLA_uint(SKP_uint32 a32, SKP_uint32 b32, SKP_uint32 c32){\r
51         SKP_uint32 ret;\r
52         ops_count += 4;\r
53         ret = a32 + b32 * c32;\r
54         return ret;\r
55 }\r
56 \r
57 #undef SKP_SMULWB\r
58 SKP_INLINE SKP_int32 SKP_SMULWB(SKP_int32 a32, SKP_int32 b32){  \r
59         SKP_int32 ret;\r
60         ops_count += 5;\r
61         ret = (a32 >> 16) * (SKP_int32)((SKP_int16)b32) + (((a32 & 0x0000FFFF) * (SKP_int32)((SKP_int16)b32)) >> 16);\r
62         return ret;\r
63 }\r
64 #undef  SKP_SMLAWB\r
65 SKP_INLINE SKP_int32 SKP_SMLAWB(SKP_int32 a32, SKP_int32 b32, SKP_int32 c32){   \r
66         SKP_int32 ret;\r
67         ops_count += 5;\r
68         ret = ((a32) + ((((b32) >> 16) * (SKP_int32)((SKP_int16)(c32))) + ((((b32) & 0x0000FFFF) * (SKP_int32)((SKP_int16)(c32))) >> 16)));\r
69         return ret;\r
70 }\r
71 \r
72 #undef SKP_SMULWT\r
73 SKP_INLINE SKP_int32 SKP_SMULWT(SKP_int32 a32, SKP_int32 b32){\r
74         SKP_int32 ret;\r
75         ops_count += 4;\r
76         ret = (a32 >> 16) * (b32 >> 16) + (((a32 & 0x0000FFFF) * (b32 >> 16)) >> 16);\r
77         return ret;\r
78 }\r
79 #undef SKP_SMLAWT\r
80 SKP_INLINE SKP_int32 SKP_SMLAWT(SKP_int32 a32, SKP_int32 b32, SKP_int32 c32){\r
81         SKP_int32 ret;\r
82         ops_count += 4;\r
83         ret = a32 + ((b32 >> 16) * (c32 >> 16)) + (((b32 & 0x0000FFFF) * ((c32 >> 16)) >> 16));\r
84         return ret;\r
85 }\r
86 \r
87 #undef SKP_SMULBB\r
88 SKP_INLINE SKP_int32 SKP_SMULBB(SKP_int32 a32, SKP_int32 b32){\r
89         SKP_int32 ret;\r
90         ops_count += 1;\r
91         ret = (SKP_int32)((SKP_int16)a32) * (SKP_int32)((SKP_int16)b32);\r
92         return ret;\r
93 }\r
94 #undef SKP_SMLABB\r
95 SKP_INLINE SKP_int32 SKP_SMLABB(SKP_int32 a32, SKP_int32 b32, SKP_int32 c32){\r
96         SKP_int32 ret;\r
97         ops_count += 1;\r
98         ret = a32 + (SKP_int32)((SKP_int16)b32) * (SKP_int32)((SKP_int16)c32);\r
99         return ret;\r
100 }\r
101 \r
102 #undef SKP_SMULBT\r
103 SKP_INLINE SKP_int32 SKP_SMULBT(SKP_int32 a32, SKP_int32 b32 ){\r
104         SKP_int32 ret;\r
105         ops_count += 4;\r
106         ret = ((SKP_int32)((SKP_int16)a32)) * (b32 >> 16);\r
107         return ret;\r
108 }\r
109 \r
110 #undef SKP_SMLABT\r
111 SKP_INLINE SKP_int32 SKP_SMLABT(SKP_int32 a32, SKP_int32 b32, SKP_int32 c32){\r
112         SKP_int32 ret;\r
113         ops_count += 1;\r
114         ret = a32 + ((SKP_int32)((SKP_int16)b32)) * (c32 >> 16);\r
115         return ret;\r
116 }\r
117 \r
118 #undef SKP_SMULTT\r
119 SKP_INLINE SKP_int32 SKP_SMULTT(SKP_int32 a32, SKP_int32 b32){\r
120         SKP_int32 ret;\r
121         ops_count += 1;\r
122         ret = (a32 >> 16) * (b32 >> 16);\r
123         return ret;\r
124 }\r
125 \r
126 #undef  SKP_SMLATT\r
127 SKP_INLINE SKP_int32 SKP_SMLATT(SKP_int32 a32, SKP_int32 b32, SKP_int32 c32){\r
128         SKP_int32 ret;\r
129         ops_count += 1;\r
130         ret = a32 + (b32 >> 16) * (c32 >> 16);\r
131         return ret;\r
132 }\r
133 \r
134 \r
135 // multiply-accumulate macros that allow overflow in the addition (ie, no asserts in debug mode)\r
136 #undef  SKP_MLA_ovflw\r
137 #define SKP_MLA_ovflw SKP_MLA\r
138 \r
139 #undef SKP_SMLABB_ovflw\r
140 #define SKP_SMLABB_ovflw SKP_SMLABB\r
141 \r
142 #undef SKP_SMLABT_ovflw\r
143 #define SKP_SMLABT_ovflw SKP_SMLABT\r
144 \r
145 #undef SKP_SMLATT_ovflw\r
146 #define SKP_SMLATT_ovflw SKP_SMLATT\r
147 \r
148 #undef SKP_SMLAWB_ovflw\r
149 #define SKP_SMLAWB_ovflw SKP_SMLAWB\r
150 \r
151 #undef SKP_SMLAWT_ovflw\r
152 #define SKP_SMLAWT_ovflw SKP_SMLAWT\r
153 \r
154 #undef SKP_SMULL\r
155 SKP_INLINE SKP_int64 SKP_SMULL(SKP_int32 a32, SKP_int32 b32){   \r
156         SKP_int64 ret;\r
157         ops_count += 8;\r
158         ret = ((SKP_int64)(a32) * /*(SKP_int64)*/(b32));\r
159         return ret;\r
160 }\r
161 \r
162 #undef  SKP_SMLAL\r
163 SKP_INLINE SKP_int64 SKP_SMLAL(SKP_int64 a64, SKP_int32 b32, SKP_int32 c32){    \r
164         SKP_int64 ret;\r
165         ops_count += 8;\r
166         ret = a64 + ((SKP_int64)(b32) * /*(SKP_int64)*/(c32));\r
167         return ret;\r
168 }\r
169 #undef  SKP_SMLALBB\r
170 SKP_INLINE SKP_int64 SKP_SMLALBB(SKP_int64 a64, SKP_int16 b16, SKP_int16 c16){  \r
171         SKP_int64 ret;\r
172         ops_count += 4;\r
173         ret = a64 + ((SKP_int64)(b16) * /*(SKP_int64)*/(c16));\r
174         return ret;\r
175 }\r
176 \r
177 #undef  SigProcFIX_CLZ16\r
178 SKP_INLINE SKP_int32 SigProcFIX_CLZ16(SKP_int16 in16)\r
179 {\r
180     SKP_int32 out32 = 0;\r
181         ops_count += 10;\r
182     if( in16 == 0 ) {\r
183         return 16;\r
184     }\r
185     /* test nibbles */\r
186     if( in16 & 0xFF00 ) {\r
187         if( in16 & 0xF000 ) {\r
188             in16 >>= 12;\r
189         } else {\r
190             out32 += 4;\r
191             in16 >>= 8;\r
192         }\r
193     } else {\r
194         if( in16 & 0xFFF0 ) {\r
195             out32 += 8;\r
196             in16 >>= 4;\r
197         } else {\r
198             out32 += 12;\r
199         }\r
200     }\r
201     /* test bits and return */\r
202     if( in16 & 0xC ) {\r
203         if( in16 & 0x8 )\r
204             return out32 + 0;\r
205         else\r
206             return out32 + 1;\r
207     } else {\r
208         if( in16 & 0xE )\r
209             return out32 + 2;\r
210         else\r
211             return out32 + 3;\r
212     }\r
213 }\r
214 \r
215 #undef SigProcFIX_CLZ32\r
216 SKP_INLINE SKP_int32 SigProcFIX_CLZ32(SKP_int32 in32)\r
217 {\r
218     /* test highest 16 bits and convert to SKP_int16 */\r
219         ops_count += 2;\r
220     if( in32 & 0xFFFF0000 ) {\r
221         return SigProcFIX_CLZ16((SKP_int16)(in32 >> 16));\r
222     } else {\r
223         return SigProcFIX_CLZ16((SKP_int16)in32) + 16;\r
224     }\r
225 }\r
226 \r
227 #undef SKP_DIV32\r
228 SKP_INLINE SKP_int32 SKP_DIV32(SKP_int32 a32, SKP_int32 b32){\r
229         ops_count += 64;\r
230         return a32 / b32;\r
231 }\r
232 \r
233 #undef SKP_DIV32_16\r
234 SKP_INLINE SKP_int32 SKP_DIV32_16(SKP_int32 a32, SKP_int32 b32){\r
235         ops_count += 32;\r
236         return a32 / b32;\r
237 }\r
238 \r
239 #undef SKP_SAT8\r
240 SKP_INLINE SKP_int8 SKP_SAT8(SKP_int64 a){\r
241         SKP_int8 tmp;\r
242         ops_count += 1;\r
243         tmp = (SKP_int8)((a) > SKP_int8_MAX ? SKP_int8_MAX  : \\r
244                     ((a) < SKP_int8_MIN ? SKP_int8_MIN  : (a)));\r
245         return(tmp);\r
246 }\r
247 \r
248 #undef SKP_SAT16\r
249 SKP_INLINE SKP_int16 SKP_SAT16(SKP_int64 a){\r
250         SKP_int16 tmp;\r
251         ops_count += 1;\r
252         tmp = (SKP_int16)((a) > SKP_int16_MAX ? SKP_int16_MAX  : \\r
253                      ((a) < SKP_int16_MIN ? SKP_int16_MIN  : (a)));\r
254         return(tmp);\r
255 }\r
256 #undef SKP_SAT32\r
257 SKP_INLINE SKP_int32 SKP_SAT32(SKP_int64 a){\r
258         SKP_int32 tmp;\r
259         ops_count += 1;\r
260         tmp = (SKP_int32)((a) > SKP_int32_MAX ? SKP_int32_MAX  : \\r
261                      ((a) < SKP_int32_MIN ? SKP_int32_MIN  : (a)));\r
262         return(tmp);\r
263 }\r
264 #undef SKP_POS_SAT32\r
265 SKP_INLINE SKP_int32 SKP_POS_SAT32(SKP_int64 a){\r
266         SKP_int32 tmp;\r
267         ops_count += 1;\r
268         tmp = (SKP_int32)((a) > SKP_int32_MAX ? SKP_int32_MAX : (a));\r
269         return(tmp);\r
270 }\r
271 \r
272 #undef SKP_ADD_POS_SAT8\r
273 SKP_INLINE SKP_int8 SKP_ADD_POS_SAT8(SKP_int64 a, SKP_int64 b){\r
274         SKP_int8 tmp;\r
275         ops_count += 1;\r
276         tmp = (SKP_int8)((((a)+(b)) & 0x80) ? SKP_int8_MAX  : ((a)+(b)));\r
277         return(tmp);\r
278 }\r
279 #undef SKP_ADD_POS_SAT16\r
280 SKP_INLINE SKP_int16 SKP_ADD_POS_SAT16(SKP_int64 a, SKP_int64 b){\r
281         SKP_int16 tmp;\r
282         ops_count += 1;\r
283         tmp = (SKP_int16)((((a)+(b)) & 0x8000) ? SKP_int16_MAX : ((a)+(b)));\r
284         return(tmp);\r
285 }\r
286 \r
287 #undef SKP_ADD_POS_SAT32\r
288 SKP_INLINE SKP_int32 SKP_ADD_POS_SAT32(SKP_int64 a, SKP_int64 b){\r
289         SKP_int32 tmp;\r
290         ops_count += 1;\r
291         tmp = (SKP_int32)((((a)+(b)) & 0x80000000) ? SKP_int32_MAX : ((a)+(b)));\r
292         return(tmp);\r
293 }\r
294 \r
295 #undef SKP_ADD_POS_SAT64\r
296 SKP_INLINE SKP_int64 SKP_ADD_POS_SAT64(SKP_int64 a, SKP_int64 b){\r
297         SKP_int64 tmp;\r
298         ops_count += 1;\r
299         tmp = ((((a)+(b)) & 0x8000000000000000LL) ? SKP_int64_MAX : ((a)+(b)));\r
300         return(tmp);\r
301 }\r
302 \r
303 #undef  SKP_LSHIFT8\r
304 SKP_INLINE SKP_int8 SKP_LSHIFT8(SKP_int8 a, SKP_int32 shift){\r
305         SKP_int8 ret;\r
306         ops_count += 1;\r
307         ret = a << shift;\r
308         return ret;\r
309 }\r
310 #undef  SKP_LSHIFT16\r
311 SKP_INLINE SKP_int16 SKP_LSHIFT16(SKP_int16 a, SKP_int32 shift){\r
312         SKP_int16 ret;\r
313         ops_count += 1;\r
314         ret = a << shift;\r
315         return ret;\r
316 }\r
317 #undef  SKP_LSHIFT32\r
318 SKP_INLINE SKP_int32 SKP_LSHIFT32(SKP_int32 a, SKP_int32 shift){\r
319         SKP_int32 ret;\r
320         ops_count += 1;\r
321         ret = a << shift;\r
322         return ret;\r
323 }\r
324 #undef  SKP_LSHIFT64\r
325 SKP_INLINE SKP_int64 SKP_LSHIFT64(SKP_int64 a, SKP_int shift){\r
326         ops_count += 1;\r
327         return a << shift;\r
328 }\r
329 \r
330 #undef  SKP_LSHIFT_ovflw\r
331 SKP_INLINE SKP_int32 SKP_LSHIFT_ovflw(SKP_int32 a, SKP_int32 shift){\r
332         ops_count += 1;\r
333         return a << shift;\r
334 }\r
335 \r
336 #undef  SKP_LSHIFT_uint\r
337 SKP_INLINE SKP_uint32 SKP_LSHIFT_uint(SKP_uint32 a, SKP_int32 shift){\r
338         SKP_uint32 ret;\r
339         ops_count += 1;\r
340         ret = a << shift;\r
341         return ret;\r
342 }\r
343 \r
344 #undef  SKP_RSHIFT8\r
345 SKP_INLINE SKP_int8 SKP_RSHIFT8(SKP_int8 a, SKP_int32 shift){\r
346         ops_count += 1;\r
347         return a >> shift;\r
348 }\r
349 #undef  SKP_RSHIFT16\r
350 SKP_INLINE SKP_int16 SKP_RSHIFT16(SKP_int16 a, SKP_int32 shift){\r
351         ops_count += 1;\r
352         return a >> shift;\r
353 }\r
354 #undef  SKP_RSHIFT32\r
355 SKP_INLINE SKP_int32 SKP_RSHIFT32(SKP_int32 a, SKP_int32 shift){\r
356         ops_count += 1;\r
357         return a >> shift;\r
358 }\r
359 #undef  SKP_RSHIFT64\r
360 SKP_INLINE SKP_int64 SKP_RSHIFT64(SKP_int64 a, SKP_int64 shift){\r
361         ops_count += 1;\r
362         return a >> shift;\r
363 }\r
364 \r
365 #undef  SKP_RSHIFT_uint\r
366 SKP_INLINE SKP_uint32 SKP_RSHIFT_uint(SKP_uint32 a, SKP_int32 shift){\r
367         ops_count += 1;\r
368         return a >> shift;\r
369 }\r
370 \r
371 #undef  SKP_ADD_LSHIFT\r
372 SKP_INLINE SKP_int32 SKP_ADD_LSHIFT(SKP_int32 a, SKP_int32 b, SKP_int32 shift){\r
373         SKP_int32 ret;\r
374         ops_count += 1;\r
375         ret = a + (b << shift);\r
376         return ret;                             // shift >= 0\r
377 }\r
378 #undef  SKP_ADD_LSHIFT32\r
379 SKP_INLINE SKP_int32 SKP_ADD_LSHIFT32(SKP_int32 a, SKP_int32 b, SKP_int32 shift){\r
380         SKP_int32 ret;\r
381         ops_count += 1;\r
382         ret = a + (b << shift);\r
383         return ret;                             // shift >= 0\r
384 }\r
385 #undef  SKP_ADD_LSHIFT_uint\r
386 SKP_INLINE SKP_uint32 SKP_ADD_LSHIFT_uint(SKP_uint32 a, SKP_uint32 b, SKP_int32 shift){\r
387         SKP_uint32 ret;\r
388         ops_count += 1;\r
389         ret = a + (b << shift);\r
390         return ret;                             // shift >= 0\r
391 }\r
392 #undef  SKP_ADD_RSHIFT\r
393 SKP_INLINE SKP_int32 SKP_ADD_RSHIFT(SKP_int32 a, SKP_int32 b, SKP_int32 shift){         \r
394         SKP_int32 ret;\r
395         ops_count += 1;\r
396         ret = a + (b >> shift);\r
397         return ret;                             // shift  > 0\r
398 }\r
399 #undef  SKP_ADD_RSHIFT32\r
400 SKP_INLINE SKP_int32 SKP_ADD_RSHIFT32(SKP_int32 a, SKP_int32 b, SKP_int32 shift){               \r
401         SKP_int32 ret;\r
402         ops_count += 1;\r
403         ret = a + (b >> shift);\r
404         return ret;                             // shift  > 0\r
405 }\r
406 #undef  SKP_ADD_RSHIFT_uint\r
407 SKP_INLINE SKP_uint32 SKP_ADD_RSHIFT_uint(SKP_uint32 a, SKP_uint32 b, SKP_int32 shift){         \r
408         SKP_uint32 ret;\r
409         ops_count += 1;\r
410         ret = a + (b >> shift);\r
411         return ret;                             // shift  > 0\r
412 }\r
413 #undef  SKP_SUB_LSHIFT32\r
414 SKP_INLINE SKP_int32 SKP_SUB_LSHIFT32(SKP_int32 a, SKP_int32 b, SKP_int32 shift){\r
415         SKP_int32 ret;\r
416         ops_count += 1;\r
417         ret = a - (b << shift);\r
418         return ret;                             // shift >= 0\r
419 }\r
420 #undef  SKP_SUB_RSHIFT32\r
421 SKP_INLINE SKP_int32 SKP_SUB_RSHIFT32(SKP_int32 a, SKP_int32 b, SKP_int32 shift){               \r
422         SKP_int32 ret;\r
423         ops_count += 1;\r
424         ret = a - (b >> shift);\r
425         return ret;                             // shift  > 0\r
426 }\r
427 \r
428 #undef  SKP_RSHIFT_ROUND\r
429 SKP_INLINE SKP_int32 SKP_RSHIFT_ROUND(SKP_int32 a, SKP_int32 shift){\r
430         SKP_int32 ret;\r
431         ops_count += 3;\r
432         ret = shift == 1 ? (a >> 1) + (a & 1) : ((a >> (shift - 1)) + 1) >> 1;\r
433         return ret;\r
434 }\r
435 \r
436 #undef  SKP_RSHIFT_ROUND64\r
437 SKP_INLINE SKP_int64 SKP_RSHIFT_ROUND64(SKP_int64 a, SKP_int32 shift){\r
438         SKP_int64 ret;\r
439         ops_count += 6;\r
440         ret = shift == 1 ? (a >> 1) + (a & 1) : ((a >> (shift - 1)) + 1) >> 1;\r
441         return ret;\r
442 }\r
443 \r
444 #undef  SKP_abs_int64\r
445 SKP_INLINE SKP_int64 SKP_abs_int64(SKP_int64 a){\r
446         ops_count += 1;\r
447         return (((a) >  0)  ? (a) : -(a));                      // Be careful, SKP_abs returns wrong when input equals to SKP_intXX_MIN\r
448 }\r
449 \r
450 #undef  SKP_abs_int32\r
451 SKP_INLINE SKP_int32 SKP_abs_int32(SKP_int32 a){\r
452         ops_count += 1;\r
453         return abs(a);\r
454 }\r
455 \r
456 \r
457 #undef SKP_min\r
458 static SKP_min(a, b){\r
459         ops_count += 1;\r
460         return (((a) < (b)) ? (a) :  (b));\r
461 }\r
462 #undef SKP_max\r
463 static SKP_max(a, b){\r
464         ops_count += 1;\r
465         return (((a) > (b)) ? (a) :  (b));\r
466 }\r
467 #undef SKP_sign\r
468 static SKP_sign(a){\r
469         ops_count += 1;\r
470         return ((a) > 0 ? 1 : ( (a) < 0 ? -1 : 0 ));\r
471 }\r
472 \r
473 #undef  SKP_ADD16\r
474 SKP_INLINE SKP_int16 SKP_ADD16(SKP_int16 a, SKP_int16 b){\r
475         SKP_int16 ret;\r
476         ops_count += 1;\r
477         ret = a + b;\r
478         return ret;\r
479 }\r
480 \r
481 #undef  SKP_ADD32\r
482 SKP_INLINE SKP_int32 SKP_ADD32(SKP_int32 a, SKP_int32 b){\r
483         SKP_int32 ret;\r
484         ops_count += 1;\r
485         ret = a + b;\r
486         return ret;\r
487 }\r
488 \r
489 #undef  SKP_ADD64\r
490 SKP_INLINE SKP_int64 SKP_ADD64(SKP_int64 a, SKP_int64 b){\r
491         SKP_int64 ret;\r
492         ops_count += 2;\r
493         ret = a + b;\r
494         return ret;\r
495 }\r
496 \r
497 #undef  SKP_SUB16\r
498 SKP_INLINE SKP_int16 SKP_SUB16(SKP_int16 a, SKP_int16 b){\r
499         SKP_int16 ret;\r
500         ops_count += 1;\r
501         ret = a - b;\r
502         return ret;\r
503 }\r
504 \r
505 #undef  SKP_SUB32\r
506 SKP_INLINE SKP_int32 SKP_SUB32(SKP_int32 a, SKP_int32 b){\r
507         SKP_int32 ret;\r
508         ops_count += 1;\r
509         ret = a - b;\r
510         return ret;\r
511 }\r
512 \r
513 #undef  SKP_SUB64\r
514 SKP_INLINE SKP_int64 SKP_SUB64(SKP_int64 a, SKP_int64 b){\r
515         SKP_int64 ret;\r
516         ops_count += 2;\r
517         ret = a - b;\r
518         return ret;\r
519 }\r
520 \r
521 #undef SKP_ADD_SAT16\r
522 SKP_INLINE SKP_int16 SKP_ADD_SAT16( SKP_int16 a16, SKP_int16 b16 ) {\r
523         SKP_int16 res;\r
524         // Nb will be counted in AKP_add32 and SKP_SAT16\r
525         res = (SKP_int16)SKP_SAT16( SKP_ADD32( (SKP_int32)(a16), (b16) ) );\r
526         return res;\r
527 }\r
528 \r
529 #undef SKP_ADD_SAT32\r
530 SKP_INLINE SKP_int32 SKP_ADD_SAT32(SKP_int32 a32, SKP_int32 b32){\r
531         SKP_int32 res;\r
532         ops_count += 1;\r
533         res =   ((((a32) + (b32)) & 0x80000000) == 0 ?                                                                  \\r
534                         ((((a32) & (b32)) & 0x80000000) != 0 ? SKP_int32_MIN : (a32)+(b32)) :   \\r
535                         ((((a32) | (b32)) & 0x80000000) == 0 ? SKP_int32_MAX : (a32)+(b32)) );\r
536         return res;\r
537 }\r
538 \r
539 #undef SKP_ADD_SAT64\r
540 SKP_INLINE SKP_int64 SKP_ADD_SAT64( SKP_int64 a64, SKP_int64 b64 ) {\r
541         SKP_int64 res;\r
542         ops_count += 1;\r
543         res =   ((((a64) + (b64)) & 0x8000000000000000LL) == 0 ?                                                                \\r
544                         ((((a64) & (b64)) & 0x8000000000000000LL) != 0 ? SKP_int64_MIN : (a64)+(b64)) : \\r
545                         ((((a64) | (b64)) & 0x8000000000000000LL) == 0 ? SKP_int64_MAX : (a64)+(b64)) );\r
546         return res;\r
547 }\r
548 \r
549 #undef SKP_SUB_SAT16\r
550 SKP_INLINE SKP_int16 SKP_SUB_SAT16( SKP_int16 a16, SKP_int16 b16 ) {\r
551         SKP_int16 res;\r
552         SKP_assert(0);\r
553         // Nb will be counted in sub-macros\r
554         res = (SKP_int16)SKP_SAT16( SKP_SUB32( (SKP_int32)(a16), (b16) ) );\r
555         return res;\r
556 }\r
557 \r
558 #undef SKP_SUB_SAT32\r
559 SKP_INLINE SKP_int32 SKP_SUB_SAT32( SKP_int32 a32, SKP_int32 b32 ) {\r
560         SKP_int32 res;\r
561         ops_count += 1;\r
562         res =   ((((a32)-(b32)) & 0x80000000) == 0 ?                                                                                    \\r
563                         (( (a32) & ((b32)^0x80000000) & 0x80000000) ? SKP_int32_MIN : (a32)-(b32)) :    \\r
564                         ((((a32)^0x80000000) & (b32)  & 0x80000000) ? SKP_int32_MAX : (a32)-(b32)) );\r
565         return res;\r
566 }\r
567 \r
568 #undef SKP_SUB_SAT64\r
569 SKP_INLINE SKP_int64 SKP_SUB_SAT64( SKP_int64 a64, SKP_int64 b64 ) {\r
570         SKP_int64 res;\r
571         ops_count += 1;\r
572         res =   ((((a64)-(b64)) & 0x8000000000000000LL) == 0 ?                                                                                                          \\r
573                         (( (a64) & ((b64)^0x8000000000000000LL) & 0x8000000000000000LL) ? SKP_int64_MIN : (a64)-(b64)) :        \\r
574                         ((((a64)^0x8000000000000000LL) & (b64)  & 0x8000000000000000LL) ? SKP_int64_MAX : (a64)-(b64)) );\r
575 \r
576         return res;\r
577 }\r
578 \r
579 #undef  SKP_SMULWW\r
580 SKP_INLINE SKP_int32 SKP_SMULWW(SKP_int32 a32, SKP_int32 b32){  \r
581         SKP_int32 ret;\r
582         // Nb will be counted in sub-macros\r
583         ret = SKP_MLA(SKP_SMULWB((a32), (b32)), (a32), SKP_RSHIFT_ROUND((b32), 16));\r
584         return ret;\r
585 }\r
586 \r
587 #undef  SKP_SMLAWW\r
588 SKP_INLINE SKP_int32 SKP_SMLAWW(SKP_int32 a32, SKP_int32 b32, SKP_int32 c32){   \r
589         SKP_int32 ret;\r
590         // Nb will be counted in sub-macros\r
591         ret = SKP_MLA(SKP_SMLAWB((a32), (b32), (c32)), (b32), SKP_RSHIFT_ROUND((c32), 16));\r
592         return ret;\r
593 }\r
594 \r
595 #undef  SKP_min_int\r
596 SKP_INLINE SKP_int SKP_min_int(SKP_int a, SKP_int b)\r
597 {\r
598         ops_count += 1;\r
599         return (((a) < (b)) ? (a) : (b));\r
600 }\r
601 \r
602 #undef  SKP_min_16\r
603 SKP_INLINE SKP_int16 SKP_min_16(SKP_int16 a, SKP_int16 b)\r
604 {\r
605         ops_count += 1;\r
606         return (((a) < (b)) ? (a) : (b));\r
607 }\r
608 #undef  SKP_min_32\r
609 SKP_INLINE SKP_int32 SKP_min_32(SKP_int32 a, SKP_int32 b)\r
610 {\r
611         ops_count += 1;\r
612         return (((a) < (b)) ? (a) : (b));\r
613 }\r
614 #undef  SKP_min_64\r
615 SKP_INLINE SKP_int64 SKP_min_64(SKP_int64 a, SKP_int64 b)\r
616 {\r
617         ops_count += 1;\r
618         return (((a) < (b)) ? (a) : (b));\r
619 }\r
620 \r
621 /* SKP_min() versions with typecast in the function call */\r
622 #undef  SKP_max_int\r
623 SKP_INLINE SKP_int SKP_max_int(SKP_int a, SKP_int b)\r
624 {\r
625         ops_count += 1;\r
626         return (((a) > (b)) ? (a) : (b));\r
627 }\r
628 #undef  SKP_max_16\r
629 SKP_INLINE SKP_int16 SKP_max_16(SKP_int16 a, SKP_int16 b)\r
630 {\r
631         ops_count += 1;\r
632         return (((a) > (b)) ? (a) : (b));\r
633 }\r
634 #undef  SKP_max_32\r
635 SKP_INLINE SKP_int32 SKP_max_32(SKP_int32 a, SKP_int32 b)\r
636 {\r
637     ops_count += 1;\r
638     return (((a) > (b)) ? (a) : (b));\r
639 }\r
640 \r
641 #undef  SKP_max_64\r
642 SKP_INLINE SKP_int64 SKP_max_64(SKP_int64 a, SKP_int64 b)\r
643 {\r
644     ops_count += 1;\r
645     return (((a) > (b)) ? (a) : (b));\r
646 }\r
647 \r
648 \r
649 #undef SKP_LIMIT_int\r
650 SKP_INLINE SKP_int SKP_LIMIT_int(SKP_int a, SKP_int limit1, SKP_int limit2)\r
651 {\r
652     SKP_int ret;\r
653     ops_count += 6;\r
654 \r
655     ret = ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \\r
656         : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))));\r
657 \r
658     return(ret);\r
659 }\r
660 \r
661 #undef SKP_LIMIT_16\r
662 SKP_INLINE SKP_int16 SKP_LIMIT_16(SKP_int16 a, SKP_int16 limit1, SKP_int16 limit2)\r
663 {\r
664     SKP_int16 ret;\r
665     ops_count += 6;\r
666 \r
667     ret = ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \\r
668         : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))));\r
669 \r
670 return(ret);\r
671 }\r
672 \r
673 \r
674 #undef SKP_LIMIT_32\r
675 SKP_INLINE SKP_int SKP_LIMIT_32(SKP_int32 a, SKP_int32 limit1, SKP_int32 limit2)\r
676 {\r
677     SKP_int32 ret;\r
678     ops_count += 6;\r
679 \r
680     ret = ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \\r
681         : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))));\r
682     return(ret);\r
683 }\r
684 \r
685 #else\r
686 #define exVarDefine\r
687 #define varDefine\r
688 #define SKP_SaveCount()\r
689 \r
690 #endif\r
691 #endif\r
692 \r