Line data Source code
1 : /*
2 : ===========================================================================
3 : File: ENH1632.C v.2.3 - 30.Nov.2009
4 : ===========================================================================
5 :
6 : ITU-T STL BASIC OPERATORS
7 :
8 : ENHANCED 16-BIT & 32-BIT ARITHMETIC OPERATORS
9 :
10 : History:
11 : 07 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
12 : operators for the ITU-T Standard Tool Library as
13 : described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
14 : TD 11 document and subsequent discussions on the
15 : wp3audio@yahoogroups.com email reflector.
16 :
17 : ============================================================================
18 : */
19 :
20 :
21 : /*****************************************************************************
22 : *
23 : * Enhanced 16/32 bit operators :
24 : * s_max()
25 : * s_min()
26 : * L_max()
27 : * L_min()
28 : * shl_r()
29 : * L_shl_r()
30 : * L_mac0()
31 : * L_mult0()
32 : * L_msu0()
33 : * s_and()
34 : * s_or()
35 : * s_xor()
36 : * L_and()
37 : * L_or()
38 : * lshl()
39 : * lshr()
40 : * L_lshl()
41 : * L_lshr()
42 : * rotr()
43 : * rotl()
44 : * L_rotr()
45 : * L_rotl()
46 : *
47 : *****************************************************************************/
48 :
49 :
50 : /*****************************************************************************
51 : *
52 : * Include-Files
53 : *
54 : *****************************************************************************/
55 : #include <stdio.h>
56 : #include <stdlib.h>
57 : #include "stl.h"
58 :
59 : #define WMC_TOOL_SKIP
60 :
61 : /*****************************************************************************
62 : *
63 : * Constants and Globals
64 : *
65 : *****************************************************************************/
66 :
67 :
68 : /*****************************************************************************
69 : *
70 : * Functions
71 : *
72 : *****************************************************************************/
73 :
74 :
75 : /*****************************************************************************
76 : *
77 : * Function Name : lshl
78 : *
79 : * Purpose :
80 : *
81 : * Logically shifts left var1 by var2 positions.
82 : * - If var2 is negative, var1 is shifted to the LSBits by (-var2)
83 : * positions with insertion of 0 at the MSBit.
84 : * - If var2 is positive, var1 is shifted to the MSBits by (var2)
85 : * positions.
86 : *
87 : * Complexity weight : 1
88 : *
89 : * Inputs :
90 : *
91 : * var1 16 bit short signed integer (Word16) whose value falls in
92 : * the range 0xffff 8000 <= var1 <= 0x0000 7fff.
93 : *
94 : * var2 16 bit short signed integer (Word16) whose value falls in
95 : * the range 0xffff 8000 <= var2 <= 0x0000 7fff.
96 : *
97 : * Outputs :
98 : *
99 : * none
100 : *
101 : * Return Value:
102 : *
103 : * var_out 16 bit short signed integer (Word16) whose value falls in
104 : * the range 0xffff 8000 <= var_out <= 0x0000 7fff.
105 : *
106 : *****************************************************************************/
107 2684682195 : Word16 lshl( Word16 var1, Word16 var2 )
108 : {
109 2684682195 : Word16 var_out = 0;
110 :
111 2684682195 : if ( var2 < 0 )
112 : {
113 8206 : var2 = -var2;
114 8206 : var_out = lshr( var1, var2 );
115 :
116 : #ifdef WMOPS
117 : multiCounter[currCounter].lshr--;
118 : #endif /* ifdef WMOPS */
119 : }
120 : else
121 : {
122 2684673989 : if ( var2 == 0 || var1 == 0 )
123 : {
124 3115182 : var_out = var1;
125 : }
126 2681558807 : else if ( var2 >= 16 )
127 : {
128 0 : var_out = 0;
129 : }
130 : else
131 : {
132 2681558807 : var_out = var1 << var2;
133 : }
134 : }
135 : #ifdef WMOPS
136 : multiCounter[currCounter].lshl++;
137 : #endif /* ifdef WMOPS */
138 :
139 2684682195 : return ( var_out );
140 : }
141 :
142 : /*****************************************************************************
143 : *
144 : * Function Name : lshr
145 : *
146 : * Purpose :
147 : *
148 : * Logically shifts right var1 by var2 positions.
149 : * - If var2 is positive, var1 is shifted to the LSBits by (var2)
150 : * positions with insertion of 0 at the MSBit.
151 : * - If var2 is negative, var1 is shifted to the MSBits by (-var2)
152 : * positions.
153 : *
154 : * Complexity weight : 1
155 : *
156 : * Inputs :
157 : *
158 : * var1 16 bit short signed integer (Word16) whose value falls in
159 : * the range 0xffff 8000 <= var1 <= 0x0000 7fff.
160 : *
161 : * var2 16 bit short signed integer (Word16) whose value falls in
162 : * the range 0xffff 8000 <= var2 <= 0x0000 7fff.
163 : *
164 : * Outputs :
165 : *
166 : * none
167 : *
168 : * Return Value:
169 : *
170 : * var_out 16 bit short signed integer (Word16) whose value falls in
171 : * the range 0xffff 8000 <= var_out <= 0x0000 7fff.
172 : *
173 : *****************************************************************************/
174 5538636963 : Word16 lshr( Word16 var1, Word16 var2 )
175 : {
176 : Word16 var_out;
177 :
178 5538636963 : if ( var2 < 0 )
179 : {
180 0 : var2 = -var2;
181 0 : var_out = lshl( var1, var2 );
182 :
183 : #ifdef WMOPS
184 : multiCounter[currCounter].lshl--;
185 : #endif /* ifdef WMOPS */
186 : }
187 : else
188 : {
189 5538636963 : if ( var2 == 0 || var1 == 0 )
190 : {
191 265260425 : var_out = var1;
192 : }
193 5273376538 : else if ( var2 >= 16 )
194 : {
195 969811 : var_out = 0;
196 : }
197 : else
198 : {
199 5272406727 : var_out = var1 >> 1;
200 5272406727 : var_out = var_out & 0x7fff;
201 5272406727 : var_out = var_out >> ( var2 - 1 );
202 : }
203 : }
204 : #ifdef WMOPS
205 : multiCounter[currCounter].lshr++;
206 : #endif /* ifdef WMOPS */
207 :
208 5538636963 : return ( var_out );
209 : }
210 :
211 :
212 : /*****************************************************************************
213 : *
214 : * Function Name : L_lshl
215 : *
216 : * Purpose :
217 : *
218 : * Logically shifts left L_var1 by var2 positions.
219 : * - If var2 is negative, L_var1 is shifted to the LSBits by (-var2)
220 : * positions with insertion of 0 at the MSBit.
221 : * - If var2 is positive, L_var1 is shifted to the MSBits by (var2)
222 : * positions.
223 : *
224 : * Complexity weight : 1
225 : *
226 : * Inputs :
227 : *
228 : * L_var1 32 bit long signed integer (Word32) whose value falls in
229 : * the range 0x8000 0000 <= L_var1 <= 0x7fff ffff.
230 : *
231 : * var2 16 bit short signed integer (Word16) whose value falls in
232 : * the range 0xffff 8000 <= var2 <= 0x0000 7fff.
233 : *
234 : * Outputs :
235 : *
236 : * none
237 : *
238 : * Return Value:
239 : *
240 : * L_var_out 32 bit long signed integer (Word32) whose value falls in
241 : * the range 0x8000 0000 <= L_var_out <= 0x7fff ffff.
242 : *
243 : *****************************************************************************/
244 966652136 : Word32 L_lshl( Word32 L_var1, Word16 var2 )
245 : {
246 966652136 : Word32 L_var_out = 0;
247 :
248 966652136 : if ( var2 < 0 )
249 : {
250 8873896 : var2 = -var2;
251 8873896 : L_var_out = L_lshr( L_var1, var2 );
252 :
253 : #ifdef WMOPS
254 : multiCounter[currCounter].L_lshr--;
255 : #endif /* ifdef WMOPS */
256 : }
257 : else
258 : {
259 957778240 : if ( var2 == 0 || L_var1 == 0 )
260 : {
261 32780207 : L_var_out = L_var1;
262 : }
263 924998033 : else if ( var2 >= 32 )
264 : {
265 0 : L_var_out = 0;
266 : }
267 : else
268 : {
269 924998033 : L_var_out = L_var1 << var2;
270 : }
271 : }
272 : #ifdef WMOPS
273 : multiCounter[currCounter].L_lshl++;
274 : #endif /* ifdef WMOPS */
275 :
276 966652136 : return ( L_var_out );
277 : }
278 :
279 :
280 : /*****************************************************************************
281 : *
282 : * Function Name : L_lshr
283 : *
284 : * Purpose :
285 : *
286 : * Logically shifts right L_var1 by var2 positions.
287 : * - If var2 is positive, L_var1 is shifted to the LSBits by (var2)
288 : * positions with insertion of 0 at the MSBit.
289 : * - If var2 is negative, L_var1 is shifted to the MSBits by (-var2)
290 : * positions.
291 : *
292 : * Complexity weight : 1
293 : *
294 : * Inputs :
295 : *
296 : * L_var1 32 bit long signed integer (Word32) whose value falls in
297 : * the range 0x8000 0000 <= L_var1 <= 0x7fff ffff.
298 : *
299 : * var2 16 bit short signed integer (Word16) whose value falls in
300 : * the range 0xffff 8000 <= var2 <= 0x0000 7fff.
301 : *
302 : * Outputs :
303 : *
304 : * none
305 : *
306 : * Return Value:
307 : *
308 : * L_var_out 32 bit long signed integer (Word32) whose value falls in
309 : * the range 0x8000 0000 <= L_var_out <= 0x7fff ffff.
310 : *
311 : *****************************************************************************/
312 716535595 : Word32 L_lshr( Word32 L_var1, Word16 var2 )
313 : {
314 : Word32 L_var_out;
315 :
316 716535595 : if ( var2 < 0 )
317 : {
318 0 : var2 = -var2;
319 0 : L_var_out = L_lshl( L_var1, var2 );
320 :
321 : #ifdef WMOPS
322 : multiCounter[currCounter].L_lshl--;
323 : #endif /* ifdef WMOPS */
324 : }
325 : else
326 : {
327 716535595 : if ( var2 == 0 || L_var1 == 0 )
328 : {
329 38343385 : L_var_out = L_var1;
330 : }
331 678192210 : else if ( var2 >= 32 )
332 : {
333 3667 : L_var_out = 0;
334 : }
335 : else
336 : {
337 678188543 : L_var_out = L_var1 >> 1;
338 678188543 : L_var_out = L_var_out & 0x7fffffff;
339 678188543 : L_var_out = L_var_out >> ( var2 - 1 );
340 : }
341 : }
342 : #ifdef WMOPS
343 : multiCounter[currCounter].L_lshr++;
344 : #endif /* ifdef WMOPS */
345 :
346 716535595 : return ( L_var_out );
347 : }
348 :
349 :
350 : /*****************************************************************************
351 : *
352 : * Function Name : shl_r
353 : *
354 : * Purpose :
355 : *
356 : * Identical to shl( var1, var2) but with rounding. Saturates the result
357 : * in case of underflows or overflows.
358 : *
359 : * Complexity weight : 3
360 : *
361 : * Inputs :
362 : *
363 : * var1 16 bit short signed integer (Word16) whose value falls in
364 : * the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
365 : *
366 : * var2 16 bit short signed integer (Word16) whose value falls in
367 : * the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
368 : *
369 : * Outputs :
370 : *
371 : * none
372 : *
373 : * Return Value :
374 : *
375 : * var_out 16 bit short signed integer (Word16) whose value falls in
376 : * the range : 0xffff 8000 <= var_out <= 0x0000 7fff.
377 : *
378 : *****************************************************************************/
379 296010 : Word16 shl_ro( Word16 var1, Word16 var2, Flag *Overflow )
380 : {
381 : Word16 var_out;
382 :
383 296010 : if ( var2 >= 0 )
384 : {
385 105146 : var_out = shl_o( var1, var2, Overflow );
386 : #ifdef WMOPS
387 : multiCounter[currCounter].shl--;
388 : #endif /* ifdef WMOPS */
389 : }
390 : else
391 : {
392 190864 : var2 = -var2;
393 190864 : var_out = shr_ro( var1, var2, Overflow );
394 : #ifdef WMOPS
395 : multiCounter[currCounter].shr_r--;
396 : #endif /* ifdef WMOPS */
397 : }
398 :
399 : #ifdef WMOPS
400 : multiCounter[currCounter].shl_r++;
401 : #endif /* ifdef WMOPS */
402 :
403 296010 : return ( var_out );
404 : }
405 290066 : Word16 shl_r( Word16 var1, Word16 var2 )
406 : {
407 290066 : return shl_ro( var1, var2, NULL );
408 : }
409 : /*****************************************************************************
410 : *
411 : * Function Name : L_shl_r
412 : *
413 : * Purpose :
414 : *
415 : * Same as L_shl( var1, var2) but with rounding. Saturates the result in
416 : * case of underflows or overflows.
417 : *
418 : * Complexity weight : 3
419 : *
420 : * Inputs :
421 : *
422 : * L_var1 32 bit long signed integer (Word32) whose value falls in
423 : * the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
424 : *
425 : * var2 16 bit short signed integer (Word16) whose value falls in
426 : * the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
427 : *
428 : * Outputs :
429 : *
430 : * none
431 : *
432 : * Return Value :
433 : *
434 : * L_var_out 32 bit long signed integer (Word32) whose value falls in
435 : * the range : 0x8000 0000 <= var_out <= 0x7fff ffff.
436 : *
437 : *****************************************************************************/
438 4597082 : Word32 L_shl_r( Word32 L_var1, Word16 var2 )
439 : {
440 : Word32 var_out;
441 :
442 4597082 : if ( var2 >= 0 )
443 : {
444 4013068 : var_out = L_shl( L_var1, var2 );
445 :
446 : #ifdef WMOPS
447 : multiCounter[currCounter].L_shl--;
448 : #endif /* ifdef WMOPS */
449 : }
450 : else
451 : {
452 584014 : var2 = -var2;
453 584014 : var_out = L_shr_r( L_var1, var2 );
454 :
455 : #ifdef WMOPS
456 : multiCounter[currCounter].L_shr_r--;
457 : #endif /* ifdef WMOPS */
458 : }
459 :
460 : #ifdef WMOPS
461 : multiCounter[currCounter].L_shl_r++;
462 : #endif /* ifdef WMOPS */
463 :
464 4597082 : return ( var_out );
465 : }
466 :
467 :
468 : /*****************************************************************************
469 : *
470 : * Function Name : rotr
471 : *
472 : * Purpose :
473 : *
474 : * Performs a 16-bit logical rotation of var1 by 1 bit to the LSBits. The
475 : * MSBit is set to var2 bit 0. The LSBit of var1 is kept in *var3 bit 0.
476 : *
477 : * Complexity weight : 3
478 : *
479 : * Inputs :
480 : *
481 : * var1 16 bit short signed integer (Word16) whose value falls in
482 : * the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
483 : *
484 : * var2 16 bit short signed integer (Word16) whose value must be 0
485 : * or 1.
486 : *
487 : * Outputs :
488 : *
489 : * *var3 Points on a 16 bit short signed integer (Word16) whose
490 : * value will be 0 or 1.
491 : *
492 : * Return Value :
493 : *
494 : * var_out 16 bit short signed integer (Word16) whose value falls in
495 : * the range : 0xffff 8000 <= var_out <= 0x0000 7fff.
496 : *
497 : *****************************************************************************/
498 0 : Word16 rotr( Word16 var1, Word16 var2, Word16 *var3 )
499 : {
500 : Word16 var_out;
501 :
502 0 : *var3 = s_and( var1, 0x1 );
503 0 : var_out = s_or( lshr( var1, 1 ), lshl( var2, 15 ) );
504 :
505 : #ifdef WMOPS
506 : multiCounter[currCounter].s_and--;
507 : multiCounter[currCounter].lshl--;
508 : multiCounter[currCounter].lshr--;
509 : multiCounter[currCounter].s_or--;
510 : multiCounter[currCounter].rotr++;
511 : #endif /* ifdef WMOPS */
512 :
513 0 : return ( var_out );
514 : }
515 :
516 :
517 : /*****************************************************************************
518 : *
519 : * Function Name : rotl
520 : *
521 : * Purpose :
522 : *
523 : * Performs a 16-bit logical rotation of var1 by 1 bit to the MSBits. The
524 : * LSBit is set to var2 bit 0. The MSBit of var1 is kept in *var3 bit 0.
525 : *
526 : * Complexity weight : 3
527 : *
528 : * Inputs :
529 : *
530 : * var1 16 bit short signed integer (Word16) whose value falls in
531 : * the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
532 : *
533 : * var2 16 bit short signed integer (Word16) whose value must be 0
534 : * or 1.
535 : *
536 : * Outputs :
537 : *
538 : * *var3 Points on a 16 bit short signed integer (Word16) whose
539 : * value will be 0 or 1.
540 : *
541 : * Return Value :
542 : *
543 : * var_out 16 bit short signed integer (Word16) whose value falls in
544 : * the range : 0xffff 8000 <= var_out <= 0x0000 7fff.
545 : *
546 : *****************************************************************************/
547 0 : Word16 rotl( Word16 var1, Word16 var2, Word16 *var3 )
548 : {
549 : Word16 var_out;
550 :
551 0 : *var3 = lshr( var1, 15 );
552 :
553 0 : var_out = s_or( lshl( var1, 1 ), s_and( var2, 0x1 ) );
554 :
555 : #ifdef WMOPS
556 : multiCounter[currCounter].lshr--;
557 : multiCounter[currCounter].s_and--;
558 : multiCounter[currCounter].lshl--;
559 : multiCounter[currCounter].s_or--;
560 : multiCounter[currCounter].rotl++;
561 : #endif /* ifdef WMOPS */
562 :
563 0 : return ( var_out );
564 : }
565 :
566 :
567 : /*****************************************************************************
568 : *
569 : * Function Name : L_rotr
570 : *
571 : * Purpose :
572 : *
573 : * Performs a 32-bit logical rotation of L_var1 by 1 bit to the LSBits. The
574 : * MSBit is set to var2 bit 0. The LSBit of L_var1 is kept in *var3 bit 0.
575 : *
576 : * Complexity weight : 3
577 : *
578 : * Inputs :
579 : *
580 : * L_var1 32 bit long signed integer (Word32) whose value falls in
581 : * the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
582 : *
583 : * var2 16 bit short signed integer (Word16) whose value must be 0
584 : * or 1.
585 : *
586 : * Outputs :
587 : *
588 : * *var3 Points on a 16 bit short signed integer (Word16) whose
589 : * value will be 0 or 1.
590 : *
591 : * Return Value :
592 : *
593 : * L_var_out 32 bit long signed integer (Word32) whose value falls in
594 : * the range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
595 : *
596 : *****************************************************************************/
597 0 : Word32 L_rotr( Word32 L_var1, Word16 var2, Word16 *var3 )
598 : {
599 : Word32 L_var_out;
600 :
601 0 : *var3 = s_and( extract_l( L_var1 ), 0x1 );
602 :
603 0 : L_var_out = L_or( L_lshr( L_var1, 1 ), L_lshl( L_deposit_l( var2 ), 31 ) );
604 :
605 : #ifdef WMOPS
606 : multiCounter[currCounter].extract_l--;
607 : multiCounter[currCounter].s_and--;
608 : multiCounter[currCounter].L_deposit_l--;
609 : multiCounter[currCounter].L_lshl--;
610 : multiCounter[currCounter].L_lshr--;
611 : multiCounter[currCounter].L_or--;
612 : multiCounter[currCounter].L_rotr++;
613 : #endif /* ifdef WMOPS */
614 :
615 0 : return ( L_var_out );
616 : }
617 :
618 :
619 : /*****************************************************************************
620 : *
621 : * Function Name : L_rotl
622 : *
623 : * Purpose :
624 : *
625 : * Performs a 32-bit logical rotation of L_var1 by 1 bit to the MSBits. The
626 : * LSBit is set to var2 bit 0. The MSBit of L_var1 is kept in *var3 bit 0.
627 : *
628 : * Complexity weight : 3
629 : *
630 : * Inputs :
631 : *
632 : * L_var1 32 bit long signed integer (Word32) whose value falls in
633 : * the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
634 : *
635 : * var2 16 bit short signed integer (Word16) whose value must be 0
636 : * or 1.
637 : *
638 : * Outputs :
639 : *
640 : * *var3 Points on a 16 bit short signed integer (Word16) whose
641 : * value will be 0 or 1.
642 : *
643 : * Return Value :
644 : *
645 : * L_var_out 32 bit long signed integer (Word32) whose value falls in
646 : * the range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
647 : *
648 : *****************************************************************************/
649 0 : Word32 L_rotl( Word32 L_var1, Word16 var2, Word16 *var3 )
650 : {
651 : Word32 L_var_out;
652 :
653 0 : *var3 = extract_l( L_lshr( L_var1, 31 ) );
654 :
655 0 : L_var_out = L_or( L_lshl( L_var1, 1 ), L_deposit_l( s_and( var2, 0x1 ) ) );
656 :
657 : #ifdef WMOPS
658 : multiCounter[currCounter].L_lshr--;
659 : multiCounter[currCounter].extract_l--;
660 : multiCounter[currCounter].s_and--;
661 : multiCounter[currCounter].L_deposit_l--;
662 : multiCounter[currCounter].L_lshl--;
663 : multiCounter[currCounter].L_or--;
664 : multiCounter[currCounter].L_rotl++;
665 : #endif /* ifdef WMOPS */
666 :
667 0 : return ( L_var_out );
668 : }
669 :
670 : #undef WMC_TOOL_SKIP
671 :
672 : /* end of file */
|
