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