1 /*___________________________________________________________________________
2 | |
3 | Function Name : extract_h |
4 | |
5 | Purpose : |
6 | |
7 | Return the 16 MSB of L_var1. |
8 | |
9 | Complexity weight : 1 |
10 | |
11 | Inputs : |
12 | |
13 | L_var1 |
14 | 32 bit long signed integer (Word32 ) whose value falls in the |
15 | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. |
16 | |
17 | Outputs : |
18 | |
19 | none |
20 | |
21 | Return Value : |
22 | |
23 | var_out |
24 | 16 bit short signed integer (Word16) whose value falls in the |
25 | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
26 |___________________________________________________________________________|
27 */
extract_h(Word32 L_var1)28 PJ_INLINE(Word16) extract_h (Word32 L_var1)
29 {
30 return (Word16) (L_var1 >> 16);
31 }
32 /* ------------------------- End of extract_h() ------------------------- */
33
34
35 /*___________________________________________________________________________
36 | |
37 | Function Name : extract_l |
38 | |
39 | Purpose : |
40 | |
41 | Return the 16 LSB of L_var1. |
42 | |
43 | Complexity weight : 1 |
44 | |
45 | Inputs : |
46 | |
47 | L_var1 |
48 | 32 bit long signed integer (Word32 ) whose value falls in the |
49 | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. |
50 | |
51 | Outputs : |
52 | |
53 | none |
54 | |
55 | Return Value : |
56 | |
57 | var_out |
58 | 16 bit short signed integer (Word16) whose value falls in the |
59 | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
60 |___________________________________________________________________________|
61 */
extract_l(Word32 L_var1)62 PJ_INLINE(Word16) extract_l (Word32 L_var1)
63 {
64 return (Word16) L_var1;
65 }
66
67 /* ------------------------- End of extract_l() ------------------------- */
68
69
70 /*___________________________________________________________________________
71 | |
72 | Function Name : saturate |
73 | |
74 | Purpose : |
75 | |
76 | Limit the 32 bit input to the range of a 16 bit word. |
77 | |
78 | Inputs : |
79 | |
80 | L_var1 |
81 | 32 bit long signed integer (Word32) whose value falls in the |
82 | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. |
83 | |
84 | Outputs : |
85 | |
86 | none |
87 | |
88 | Return Value : |
89 | |
90 | var_out |
91 | 16 bit short signed integer (Word16) whose value falls in the |
92 | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
93 |___________________________________________________________________________|
94 */
saturate(Word32 L_var1)95 PJ_INLINE(Word16) saturate (Word32 L_var1)
96 {
97 Word16 val16 = (Word16) L_var1;
98
99 if (val16 == L_var1)
100 return val16;
101
102 if (L_var1 > MAX_16)
103 return MAX_16;
104 return MIN_16;
105 }
106 /* ------------------------- End of saturate() ------------------------- */
107
108
109 #if PJ_HAS_INT64
L_saturate(pj_int64_t LL_var1)110 PJ_INLINE(Word32) L_saturate (pj_int64_t LL_var1)
111 {
112 pj_int32_t L_var1 = (pj_int32_t)LL_var1;
113 if (LL_var1 == L_var1)
114 return L_var1;
115 else if (LL_var1 > MAX_32)
116 return MAX_32;
117 else
118 return MIN_32;
119 }
120 #endif
121
122
123 /*___________________________________________________________________________
124 | |
125 | Function Name : add |
126 | |
127 | Purpose : |
128 | |
129 | Performs the addition (var1+var2) with overflow control and saturation;|
130 | the 16 bit result is set at +32767 when overflow occurs or at -32768 |
131 | when underflow occurs. |
132 | |
133 | Complexity weight : 1 |
134 | |
135 | Inputs : |
136 | |
137 | var1 |
138 | 16 bit short signed integer (Word16) whose value falls in the |
139 | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
140 | |
141 | var2 |
142 | 16 bit short signed integer (Word16) whose value falls in the |
143 | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
144 | |
145 | Outputs : |
146 | |
147 | none |
148 | |
149 | Return Value : |
150 | |
151 | var_out |
152 | 16 bit short signed integer (Word16) whose value falls in the |
153 | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
154 |___________________________________________________________________________|
155 */
add(Word16 var1,Word16 var2)156 PJ_INLINE(Word16) add (Word16 var1, Word16 var2)
157 {
158 return saturate (var1 + var2);
159 }
160 /* ------------------------- End of add() ------------------------- */
161
162
163 /*___________________________________________________________________________
164 | |
165 | Function Name : sub |
166 | |
167 | Purpose : |
168 | |
169 | Performs the subtraction (var1+var2) with overflow control and satu- |
170 | ration; the 16 bit result is set at +32767 when overflow occurs or at |
171 | -32768 when underflow occurs. |
172 | |
173 | Complexity weight : 1 |
174 | |
175 | Inputs : |
176 | |
177 | var1 |
178 | 16 bit short signed integer (Word16) whose value falls in the |
179 | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
180 | |
181 | var2 |
182 | 16 bit short signed integer (Word16) whose value falls in the |
183 | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
184 | |
185 | Outputs : |
186 | |
187 | none |
188 | |
189 | Return Value : |
190 | |
191 | var_out |
192 | 16 bit short signed integer (Word16) whose value falls in the |
193 | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
194 |___________________________________________________________________________|
195 */
sub(Word16 var1,Word16 var2)196 PJ_INLINE(Word16) sub (Word16 var1, Word16 var2)
197 {
198 return saturate ((Word32) var1 - var2);
199 }
200 /* ------------------------- End of sub() ------------------------- */
201
202
203 /*___________________________________________________________________________
204 | |
205 | Function Name : negate |
206 | |
207 | Purpose : |
208 | |
209 | Negate var1 with saturation, saturate in the case where input is -32768:|
210 | negate(var1) = sub(0,var1). |
211 | |
212 | Complexity weight : 1 |
213 | |
214 | Inputs : |
215 | |
216 | var1 |
217 | 16 bit short signed integer (Word16) whose value falls in the |
218 | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
219 | |
220 | Outputs : |
221 | |
222 | none |
223 | |
224 | Return Value : |
225 | |
226 | var_out |
227 | 16 bit short signed integer (Word16) whose value falls in the |
228 | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
229 |___________________________________________________________________________|
230 */
negate(Word16 var1)231 PJ_INLINE(Word16) negate (Word16 var1)
232 {
233 return (Word16)((var1 == MIN_16) ? MAX_16 : -var1);
234 }
235 /* ------------------------- End of negate() ------------------------- */
236
237
238
239
240 /*___________________________________________________________________________
241 | |
242 | Function Name : L_add |
243 | |
244 | Purpose : |
245 | |
246 | 32 bits addition of the two 32 bits variables (L_var1+L_var2) with |
247 | overflow control and saturation; the result is set at +2147483647 when |
248 | overflow occurs or at -2147483648 when underflow occurs. |
249 | |
250 | Complexity weight : 2 |
251 | |
252 | Inputs : |
253 | |
254 | L_var1 32 bit long signed integer (Word32) whose value falls in the |
255 | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
256 | |
257 | L_var2 32 bit long signed integer (Word32) whose value falls in the |
258 | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
259 | |
260 | Outputs : |
261 | |
262 | none |
263 | |
264 | Return Value : |
265 | |
266 | L_var_out |
267 | 32 bit long signed integer (Word32) whose value falls in the |
268 | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
269 |___________________________________________________________________________|
270 */
L_add(Word32 L_var1,Word32 L_var2)271 PJ_INLINE(Word32) L_add (Word32 L_var1, Word32 L_var2)
272 {
273 #if PJ_HAS_INT64
274 return L_saturate(((pj_int64_t)L_var1) + L_var2);
275 #else
276 Word32 L_var_out;
277
278 L_var_out = L_var1 + L_var2;
279
280 if (((L_var1 ^ L_var2) & MIN_32) == 0)
281 {
282 if ((L_var_out ^ L_var1) & MIN_32)
283 {
284 SET_OVERFLOW(1);
285 L_var_out = (L_var1 < 0) ? MIN_32 : MAX_32;
286 }
287 }
288 return (L_var_out);
289 #endif
290 }
291
292 /* ------------------------- End of L_add() ------------------------- */
293
294
295
296
297 /*___________________________________________________________________________
298 | |
299 | Function Name : L_sub |
300 | |
301 | Purpose : |
302 | |
303 | 32 bits subtraction of the two 32 bits variables (L_var1-L_var2) with |
304 | overflow control and saturation; the result is set at +2147483647 when |
305 | overflow occurs or at -2147483648 when underflow occurs. |
306 | |
307 | Complexity weight : 2 |
308 | |
309 | Inputs : |
310 | |
311 | L_var1 32 bit long signed integer (Word32) whose value falls in the |
312 | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
313 | |
314 | L_var2 32 bit long signed integer (Word32) whose value falls in the |
315 | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
316 | |
317 | Outputs : |
318 | |
319 | none |
320 | |
321 | Return Value : |
322 | |
323 | L_var_out |
324 | 32 bit long signed integer (Word32) whose value falls in the |
325 | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
326 |___________________________________________________________________________|
327 */
L_sub(Word32 L_var1,Word32 L_var2)328 PJ_INLINE(Word32) L_sub (Word32 L_var1, Word32 L_var2)
329 {
330 #if PJ_HAS_INT64
331 return L_saturate((pj_int64_t)L_var1 - L_var2);
332 #else
333 Word32 L_var_out;
334
335 L_var_out = L_var1 - L_var2;
336
337 if (((L_var1 ^ L_var2) & MIN_32) != 0)
338 {
339 if ((L_var_out ^ L_var1) & MIN_32)
340 {
341 L_var_out = (L_var1 < 0L) ? MIN_32 : MAX_32;
342 SET_OVERFLOW(1);
343 }
344 }
345 return (L_var_out);
346 #endif
347 }
348 /* ------------------------- End of L_sub() ------------------------- */
349
350 /*___________________________________________________________________________
351 | |
352 | Function Name : L_mult |
353 | |
354 | Purpose : |
355 | |
356 | L_mult is the 32 bit result of the multiplication of var1 times var2 |
357 | with one shift left i.e.: |
358 | L_mult(var1,var2) = L_shl((var1 times var2),1) and |
359 | L_mult(-32768,-32768) = 2147483647. |
360 | |
361 | Complexity weight : 1 |
362 | |
363 | Inputs : |
364 | |
365 | var1 |
366 | 16 bit short signed integer (Word16) whose value falls in the |
367 | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
368 | |
369 | var2 |
370 | 16 bit short signed integer (Word16) whose value falls in the |
371 | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
372 | |
373 | Outputs : |
374 | |
375 | none |
376 | |
377 | Return Value : |
378 | |
379 | L_var_out |
380 | 32 bit long signed integer (Word32) whose value falls in the |
381 | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
382 |___________________________________________________________________________|
383 */
L_mult(Word16 var1,Word16 var2)384 PJ_INLINE(Word32) L_mult (Word16 var1, Word16 var2)
385 {
386 Word32 L_var_out;
387
388 L_var_out = (Word32) var1 *(Word32) var2;
389
390 if (L_var_out != (Word32) 0x40000000L)
391 {
392 return L_var_out << 1;
393 }
394 else
395 {
396 SET_OVERFLOW(1);
397 return MAX_32;
398 }
399 }
400 /* ------------------------- End of L_mult() ------------------------- */
401
402
403 /*___________________________________________________________________________
404 | |
405 | Function Name : L_mac |
406 | |
407 | Purpose : |
408 | |
409 | Multiply var1 by var2 and shift the result left by 1. Add the 32 bit |
410 | result to L_var3 with saturation, return a 32 bit result: |
411 | L_mac(L_var3,var1,var2) = L_add(L_var3,L_mult(var1,var2)). |
412 | |
413 | Complexity weight : 1 |
414 | |
415 | Inputs : |
416 | |
417 | L_var3 32 bit long signed integer (Word32) whose value falls in the |
418 | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
419 | |
420 | var1 |
421 | 16 bit short signed integer (Word16) whose value falls in the |
422 | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
423 | |
424 | var2 |
425 | 16 bit short signed integer (Word16) whose value falls in the |
426 | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
427 | |
428 | Outputs : |
429 | |
430 | none |
431 | |
432 | Return Value : |
433 | |
434 | L_var_out |
435 | 32 bit long signed integer (Word32) whose value falls in the |
436 | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
437 |___________________________________________________________________________|
438 */
L_mac(Word32 L_var3,Word16 var1,Word16 var2)439 PJ_INLINE(Word32) L_mac (Word32 L_var3, Word16 var1, Word16 var2)
440 {
441 return L_add (L_var3, L_mult (var1, var2));
442 }
443 /* ------------------------- End of L_mac() ------------------------- */
444
445
446 /*___________________________________________________________________________
447 | |
448 | Function Name : round |
449 | |
450 | Purpose : |
451 | |
452 | Round the lower 16 bits of the 32 bit input number into the MS 16 bits |
453 | with saturation. Shift the resulting bits right by 16 and return the 16 |
454 | bit number: |
455 | round(L_var1) = extract_h(L_add(L_var1,32768)) |
456 | |
457 | Complexity weight : 1 |
458 | |
459 | Inputs : |
460 | |
461 | L_var1 |
462 | 32 bit long signed integer (Word32 ) whose value falls in the |
463 | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. |
464 | |
465 | Outputs : |
466 | |
467 | none |
468 | |
469 | Return Value : |
470 | |
471 | var_out |
472 | 16 bit short signed integer (Word16) whose value falls in the |
473 | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
474 |___________________________________________________________________________|
475 */
itu_round(Word32 L_var1)476 PJ_INLINE(Word16) itu_round (Word32 L_var1)
477 {
478 return extract_h (L_add (L_var1, (Word32) 0x00008000L));
479 }
480 /* ------------------------- End of round() ------------------------- */
481
482
483 /*___________________________________________________________________________
484 | |
485 | Function Name : L_shr |
486 | |
487 | Purpose : |
488 | |
489 | Arithmetically shift the 32 bit input L_var1 right var2 positions with |
490 | sign extension. If var2 is negative, arithmetically shift L_var1 left |
491 | by -var2 and zero fill the -var2 LSB of the result. Saturate the result |
492 | in case of underflows or overflows. |
493 | |
494 | Complexity weight : 2 |
495 | |
496 | Inputs : |
497 | |
498 | L_var1 32 bit long signed integer (Word32) whose value falls in the |
499 | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
500 | |
501 | var2 |
502 | 16 bit short signed integer (Word16) whose value falls in the |
503 | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
504 | |
505 | Outputs : |
506 | |
507 | none |
508 | |
509 | Return Value : |
510 | |
511 | L_var_out |
512 | 32 bit long signed integer (Word32) whose value falls in the |
513 | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
514 |___________________________________________________________________________|
515 */
L_shr_nocheck(Word32 L_var1,Word16 var2)516 PJ_INLINE(Word32) L_shr_nocheck(Word32 L_var1, Word16 var2)
517 {
518 #if 1
519 return L_var1 >> var2;
520 #else
521 if (var2 >= 31)
522 {
523 return (L_var1 < 0L) ? -1 : 0;
524 }
525 else
526 {
527 if (L_var1 < 0)
528 {
529 return ~((~L_var1) >> var2);
530 }
531 else
532 {
533 return L_var1 >> var2;
534 }
535 }
536 #endif
537 }
538
L_shl_nocheck(Word32 L_var1,Word16 var2)539 PJ_INLINE(Word32) L_shl_nocheck (Word32 L_var1, Word16 var2)
540 {
541 #if PJ_HAS_INT64
542 return L_saturate( ((pj_int64_t)L_var1) << var2 );
543 #else
544 for (; var2 > 0; var2--)
545 {
546 if (L_var1 > (Word32) 0X3fffffffL)
547 {
548 SET_OVERFLOW(1);
549 return MAX_32;
550 }
551 else
552 {
553 if (L_var1 < (Word32) 0xc0000000L)
554 {
555 SET_OVERFLOW(1);
556 return MIN_32;
557 }
558 }
559 L_var1 <<= 1;
560 }
561 return (L_var1);
562 #endif
563 }
564
L_shr(Word32 L_var1,Word16 var2)565 PJ_INLINE(Word32) L_shr (Word32 L_var1, Word16 var2)
566 {
567 if (var2 < 0)
568 {
569 if (var2 < -32)
570 var2 = -32;
571 return L_shl_nocheck (L_var1, (Word16) -var2);
572 }
573 else
574 {
575 return L_shr_nocheck(L_var1, var2);
576 }
577 }
578 /* ------------------------- End of L_shr() ------------------------- */
579
580 /*___________________________________________________________________________
581 | |
582 | Function Name : L_shl |
583 | |
584 | Purpose : |
585 | |
586 | Arithmetically shift the 32 bit input L_var1 left var2 positions. Zero |
587 | fill the var2 LSB of the result. If var2 is negative, arithmetically |
588 | shift L_var1 right by -var2 with sign extension. Saturate the result in |
589 | case of underflows or overflows. |
590 | |
591 | Complexity weight : 2 |
592 | |
593 | Inputs : |
594 | |
595 | L_var1 32 bit long signed integer (Word32) whose value falls in the |
596 | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
597 | |
598 | var2 |
599 | 16 bit short signed integer (Word16) whose value falls in the |
600 | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
601 | |
602 | Outputs : |
603 | |
604 | none |
605 | |
606 | Return Value : |
607 | |
608 | L_var_out |
609 | 32 bit long signed integer (Word32) whose value falls in the |
610 | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
611 |___________________________________________________________________________|
612 */
L_shl(Word32 L_var1,Word16 var2)613 PJ_INLINE(Word32) L_shl (Word32 L_var1, Word16 var2)
614 {
615 if (var2 <= 0)
616 {
617 if (var2 < -32)
618 var2 = -32;
619 return L_shr_nocheck(L_var1, (Word16) -var2);
620 }
621 else
622 {
623 return L_shl_nocheck(L_var1, var2);
624 }
625 }
626 /* ------------------------- End of L_shl() ------------------------- */
627
628
629 /*___________________________________________________________________________
630 | |
631 | Function Name : abs_s |
632 | |
633 | Purpose : |
634 | |
635 | Absolute value of var1; abs_s(-32768) = 32767. |
636 | |
637 | Complexity weight : 1 |
638 | |
639 | Inputs : |
640 | |
641 | var1 |
642 | 16 bit short signed integer (Word16) whose value falls in the |
643 | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
644 | |
645 | Outputs : |
646 | |
647 | none |
648 | |
649 | Return Value : |
650 | |
651 | var_out |
652 | 16 bit short signed integer (Word16) whose value falls in the |
653 | range : 0x0000 0000 <= var_out <= 0x0000 7fff. |
654 |___________________________________________________________________________|
655 */
abs_s(Word16 var1)656 PJ_INLINE(Word16) abs_s (Word16 var1)
657 {
658 #if 1
659 if (var1 >= 0)
660 return var1;
661 else if (var1 == MIN_16)
662 return MAX_16;
663 else
664 return (Word16)-var1;
665 #else
666 if (var1 == MIN_16)
667 {
668 return MAX_16;
669 }
670 else
671 {
672 if (var1 < 0)
673 {
674 return (Word16)-var1;
675 }
676 else
677 {
678 return var1;
679 }
680 }
681 #endif
682 }
683 /* ------------------------- End of abs_s() ------------------------- */
684
685
shl_nocheck(Word16 var1,Word16 var2)686 PJ_INLINE(Word16) shl_nocheck(Word16 var1, Word16 var2)
687 {
688 #if 1
689 /* blp: this should be more optimized */
690 return saturate (((Word32)var1) << var2);
691 #else
692 /* Original algorithm */
693 Word32 result = (Word32) var1 *((Word32) 1 << var2);
694
695 if ((var2 > 15 && var1 != 0) || (result != (Word32) ((Word16) result)))
696 {
697 SET_OVERFLOW(1);
698 return (Word16) ((var1 > 0) ? MAX_16 : MIN_16);
699 }
700 else
701 {
702 return extract_l (result);
703 }
704 #endif
705 }
706
shr_nocheck(Word16 var1,Word16 var2)707 PJ_INLINE(Word16) shr_nocheck(Word16 var1, Word16 var2)
708 {
709 #if 1
710 /* blp: this should yield the same value */
711 return (Word16) (var1 >> var2);
712 #else
713 /* Original algorithm */
714 if (var2 >= 15)
715 {
716 return (Word16)((var1 < 0) ? -1 : 0);
717 }
718 else
719 {
720 if (var1 < 0)
721 {
722 return (Word16) (~((~var1) >> var2));
723 }
724 else
725 {
726 return (Word16)(var1 >> var2);
727 }
728 }
729 #endif
730 }
731