Line data    Source code

       1             : /*
       2             :   ===========================================================================
       3             :    File: ENH1632.H                                       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             :    March 06   v2.1      Changed to improve portability.
      17             :                         Some counters incrementations were missing (s_and,
      18             :                         s_or, s_xor).
      19             :    30 Nov 09   v2.3     saturate() removed
      20             : 
      21             :   ============================================================================
      22             : */
      23             : 
      24             : 
      25             : #ifndef _ENH1632_H
      26             : #define _ENH1632_H
      27             : 
      28             : 
      29             : /*****************************************************************************
      30             :  *
      31             :  *  Constants and Globals
      32             :  *
      33             :  *****************************************************************************/
      34             : 
      35             : 
      36             : #include "stl.h"
      37             : 
      38             : /*****************************************************************************
      39             :  *
      40             :  *  Prototypes for enhanced 16/32 bit arithmetic operators
      41             :  *
      42             :  *****************************************************************************/
      43             : Word16 shl_ro( Word16 var1, Word16 var2, Flag *Overflow );
      44             : Word16 shl_r( Word16 var1, Word16 var2 );
      45             : Word32 L_shl_r( Word32 L_var1, Word16 var2 );
      46             : 
      47             : 
      48             : Word16 lshl( Word16 var1, Word16 var2 );
      49             : Word16 lshr( Word16 var1, Word16 var2 );
      50             : Word32 L_lshl( Word32 L_var1, Word16 var2 );
      51             : Word32 L_lshr( Word32 L_var1, Word16 var2 );
      52             : 
      53             : Word16 rotr( Word16 var1, Word16 var2, Word16 *var3 );
      54             : Word16 rotl( Word16 var1, Word16 var2, Word16 *var3 );
      55             : Word32 L_rotr( Word32 var1, Word16 var2, Word16 *var3 );
      56             : Word32 L_rotl( Word32 var1, Word16 var2, Word16 *var3 );
      57             : 
      58             : 
      59             : /*****************************************************************************
      60             :  *
      61             :  *  Functions
      62             :  *
      63             :  *****************************************************************************/
      64             : 
      65             : /*****************************************************************************
      66             :  *
      67             :  *  Function Name : s_max
      68             :  *
      69             :  *  Purpose :
      70             :  *
      71             :  *    Compares var1 and var2 and returns the maximum value.
      72             :  *
      73             :  *  Complexity weight : 1
      74             :  *
      75             :  *  Inputs :
      76             :  *
      77             :  *    var1        16 bit short signed integer (Word16) whose value falls in
      78             :  *                the range : 0x8000 <= var1 <= 0x7fff.
      79             :  *
      80             :  *    var2        16 bit short signed integer (Word16) whose value falls in
      81             :  *                the range : 0x8000 <= var2 <= 0x7fff.
      82             :  *
      83             :  *  Outputs :
      84             :  *
      85             :  *    none
      86             :  *
      87             :  *  Return Value :
      88             :  *
      89             :  *    var_out     16 bit short signed integer (Word16) whose value falls in
      90             :  *                the range : 0x8000 <= L_var_out <= 0x7fff.
      91             :  *
      92             :  *****************************************************************************/
      93 45061231301 : static __inline Word16 s_max( Word16 var1, Word16 var2 )
      94             : {
      95             :     Word16 var_out;
      96             : 
      97 45061231301 :     if ( var1 >= var2 )
      98 22357391774 :         var_out = var1;
      99             :     else
     100 22703839527 :         var_out = var2;
     101             : 
     102             : #ifdef WMOPS
     103             :     multiCounter[currCounter].s_max++;
     104             : #endif /* ifdef WMOPS */
     105             : 
     106 45061231301 :     return ( var_out );
     107             : }
     108             : 
     109             : 
     110             : /*****************************************************************************
     111             :  *
     112             :  *  Function Name : s_min
     113             :  *
     114             :  *  Purpose :
     115             :  *
     116             :  *    Compares var1 and var2 and returns the minimum value.
     117             :  *
     118             :  *  Complexity weight : 1
     119             :  *
     120             :  *  Inputs :
     121             :  *
     122             :  *    var1        16 bit short signed integer (Word16) whose value falls in
     123             :  *                the range : 0x8000  <= var1 <= 0x7fff.
     124             :  *
     125             :  *    var2        16 bit short signed integer (Word16) whose value falls in
     126             :  *                the range : 0x8000  <= var2 <= 0x7fff.
     127             :  *
     128             :  *  Outputs :
     129             :  *
     130             :  *    none
     131             :  *
     132             :  *  Return Value :
     133             :  *
     134             :  *    var_out     16 bit short signed integer (Word16) whose value falls in
     135             :  *                the range : 0x8000 <= var_out <= 0x7fff.
     136             :  *
     137             :  *****************************************************************************/
     138 67769516551 : static __inline Word16 s_min( Word16 var1, Word16 var2 )
     139             : {
     140             :     Word16 var_out;
     141             : 
     142 67769516551 :     if ( var1 <= var2 )
     143 48998641567 :         var_out = var1;
     144             :     else
     145 18770874984 :         var_out = var2;
     146             : 
     147             : #ifdef WMOPS
     148             :     multiCounter[currCounter].s_min++;
     149             : #endif /* ifdef WMOPS */
     150             : 
     151 67769516551 :     return ( var_out );
     152             : }
     153             : 
     154             : 
     155             : /*****************************************************************************
     156             :  *
     157             :  *  Function Name : L_max
     158             :  *
     159             :  *  Purpose :
     160             :  *
     161             :  *    Compares L_var1 and L_var2 and returns the maximum value.
     162             :  *
     163             :  *  Complexity weight : 1
     164             :  *
     165             :  *  Inputs :
     166             :  *
     167             :  *    L_var1      32 bit long signed integer (Word32) whose value falls in the
     168             :  *                range : 0x8000 0000  <= L_var1 <= 0x7fff ffff.
     169             :  *
     170             :  *    L_var2      32 bit long signed integer (Word32) whose value falls in the
     171             :  *                range : 0x8000 0000  <= L_var2 <= 0x7fff ffff.
     172             :  *
     173             :  *  Outputs :
     174             :  *
     175             :  *    none
     176             :  *
     177             :  *  Return Value :
     178             :  *
     179             :  *    L_var_out   32 bit long signed integer (Word32) whose value falls in the
     180             :  *                range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
     181             :  *
     182             :  *****************************************************************************/
     183 21186180176 : static __inline Word32 L_max( Word32 L_var1, Word32 L_var2 )
     184             : {
     185             :     Word32 L_var_out;
     186             : 
     187 21186180176 :     if ( L_var1 >= L_var2 )
     188 17380992872 :         L_var_out = L_var1;
     189             :     else
     190  3805187304 :         L_var_out = L_var2;
     191             : 
     192             : #ifdef WMOPS
     193             :     multiCounter[currCounter].L_max++;
     194             : #endif /* ifdef WMOPS */
     195             : 
     196 21186180176 :     return ( L_var_out );
     197             : }
     198             : 
     199             : 
     200             : /*****************************************************************************
     201             :  *
     202             :  *  Function Name : L_min
     203             :  *
     204             :  *  Purpose :
     205             :  *
     206             :  *    Compares L_var1 and L_var2 and returns the minimum value.
     207             :  *
     208             :  *  Complexity weight : 1
     209             :  *
     210             :  *  Inputs :
     211             :  *
     212             :  *    L_var1      32 bit long signed integer (Word32) whose value falls in the
     213             :  *                range : 0x8000 0000  <= L_var1 <= 0x7fff ffff.
     214             :  *
     215             :  *    L_var2      32 bit long signed integer (Word32) whose value falls in the
     216             :  *                range : 0x8000 0000  <= L_var2 <= 0x7fff ffff.
     217             :  *
     218             :  *  Outputs :
     219             :  *
     220             :  *    none
     221             :  *
     222             :  *  Return Value :
     223             :  *
     224             :  *    L_var_out   32 bit long signed integer (Word32) whose value falls in the
     225             :  *                range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
     226             :  *
     227             :  *****************************************************************************/
     228  8265563588 : static __inline Word32 L_min( Word32 L_var1, Word32 L_var2 )
     229             : {
     230             :     Word32 L_var_out;
     231             : 
     232  8265563588 :     if ( L_var1 <= L_var2 )
     233  7840008038 :         L_var_out = L_var1;
     234             :     else
     235   425555550 :         L_var_out = L_var2;
     236             : 
     237             : #ifdef WMOPS
     238             :     multiCounter[currCounter].L_min++;
     239             : #endif /* ifdef WMOPS */
     240             : 
     241  8265563588 :     return ( L_var_out );
     242             : }
     243             : 
     244             : 
     245             : /*****************************************************************************
     246             :  *
     247             :  *  Function Name : s_and
     248             :  *
     249             :  *  Purpose :
     250             :  *
     251             :  *    Performs logical AND of the two 16 bit input variables.
     252             :  *    var_out = var1 & var2
     253             :  *
     254             :  *  Complexity weight : 1
     255             :  *
     256             :  *  Inputs :
     257             :  *
     258             :  *    var1        16 bit short signed integer (Word16) whose value
     259             :  *                falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
     260             :  *
     261             :  *    var2        16 bit short signed integer (Word16) whose value
     262             :  *                falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
     263             :  *
     264             :  *  Outputs :
     265             :  *
     266             :  *    none
     267             :  *
     268             :  *  Return Value :
     269             :  *
     270             :  *    var_out     16 bit short signed integer (Word16) whose value
     271             :  *                falls in the range 0xffff 8000 <= var_out <= 0x0000 7fff.
     272             :  *
     273             :  *****************************************************************************/
     274  5413851806 : static __inline Word16 s_and( Word16 var1, Word16 var2 )
     275             : {
     276             :     Word16 var_out;
     277             : 
     278  5413851806 :     var_out = var1 & var2;
     279             : 
     280             : #ifdef WMOPS
     281             :     multiCounter[currCounter].s_and++;
     282             : #endif /* ifdef WMOPS */
     283             : 
     284  5413851806 :     return ( var_out );
     285             : }
     286             : 
     287             : 
     288             : /*****************************************************************************
     289             :  *
     290             :  *  Function Name : L_and
     291             :  *
     292             :  *  Purpose :
     293             :  *
     294             :  *    Performs logical AND of the two 32 bit input variables.
     295             :  *    L_var_out = L_var1 & L_var2
     296             :  *
     297             :  *  Complexity weight : 1
     298             :  *
     299             :  *  Inputs :
     300             :  *
     301             :  *    L_var1      32 bit long signed integer (Word32) whose value
     302             :  *                falls in the range 0x8000 0000 <= L_var1 <= 0x7fff ffff.
     303             :  *
     304             :  *    L_var2      32 bit long signed integer (Word32) whose value
     305             :  *                falls in the range 0x8000 0000 <= L_var2 <= 0x7fff ffff.
     306             :  *
     307             :  *  Outputs :
     308             :  *
     309             :  *    none
     310             :  *
     311             :  *  Return Value :
     312             :  *
     313             :  *    L_var_out   32 bit long signed integer (Word32) whose value
     314             :  *                falls in the range 0x8000 0000 <= L_var_out <= 0x7fff ffff.
     315             :  *
     316             :  *****************************************************************************/
     317  2635391291 : static __inline Word32 L_and( Word32 L_var1, Word32 L_var2 )
     318             : {
     319             :     Word32 L_var_out;
     320             : 
     321  2635391291 :     L_var_out = L_var1 & L_var2;
     322             : 
     323             : #ifdef WMOPS
     324             :     multiCounter[currCounter].L_and++;
     325             : #endif /* ifdef WMOPS */
     326             : 
     327  2635391291 :     return ( L_var_out );
     328             : }
     329             : 
     330             : 
     331             : /*****************************************************************************
     332             :  *
     333             :  *  Function Name : s_or
     334             :  *
     335             :  *  Purpose :
     336             :  *
     337             :  *    Performs logical OR of the two 16 bit input variables.
     338             :  *    var_out = var1 | var2
     339             :  *
     340             :  *  Complexity weight : 1
     341             :  *
     342             :  *  Inputs :
     343             :  *
     344             :  *    var1        16 bit short signed integer (Word16) whose value
     345             :  *                falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
     346             :  *
     347             :  *    var2        16 bit short signed integer (Word16) whose value
     348             :  *                falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
     349             :  *
     350             :  *  Outputs :
     351             :  *
     352             :  *    none
     353             :  *
     354             :  *  Return Value :
     355             :  *
     356             :  *    var_out     16 bit short signed integer (Word16) whose value
     357             :  *                falls in the range 0xffff 8000 <= var_out <= 0x0000 7fff.
     358             :  *
     359             :  *****************************************************************************/
     360   507919404 : static __inline Word16 s_or( Word16 var1, Word16 var2 )
     361             : {
     362             :     Word16 var_out;
     363             : 
     364   507919404 :     var_out = var1 | var2;
     365             : 
     366             : #ifdef WMOPS
     367             :     multiCounter[currCounter].s_or++;
     368             : #endif /* ifdef WMOPS */
     369             : 
     370   507919404 :     return ( var_out );
     371             : }
     372             : 
     373             : 
     374             : /*****************************************************************************
     375             :  *
     376             :  *  Function Name : L_or
     377             :  *
     378             :  *  Purpose :
     379             :  *
     380             :  *    Performs logical OR of the two 32 bit input variables.
     381             :  *    L_var_out = L_var1 | L_var2
     382             :  *
     383             :  *  Complexity weight : 1
     384             :  *
     385             :  *  Inputs :
     386             :  *
     387             :  *    L_var1      32 bit long signed integer (Word32) whose value
     388             :  *                falls in the range 0x8000 0000 <= L_var1 <= 0x7fff ffff.
     389             :  *
     390             :  *    L_var2      32 bit long signed integer (Word32) whose value
     391             :  *                falls in the range 0x8000 0000 <= L_var2 <= 0x7fff ffff.
     392             :  *
     393             :  *  Outputs :
     394             :  *
     395             :  *    none
     396             :  *
     397             :  *  Return Value :
     398             :  *
     399             :  *    L_var_out   32 bit long signed integer (Word32) whose value
     400             :  *                falls in the range 0x8000 0000 <= L_var_out <= 0x7fff ffff.
     401             :  *
     402             :  *****************************************************************************/
     403  4821700758 : static __inline Word32 L_or( Word32 L_var1, Word32 L_var2 )
     404             : {
     405             : 
     406             :     Word32 L_var_out;
     407             : 
     408  4821700758 :     L_var_out = L_var1 | L_var2;
     409             : 
     410             : #ifdef WMOPS
     411             :     multiCounter[currCounter].L_or++;
     412             : #endif /* ifdef WMOPS */
     413             : 
     414  4821700758 :     return ( L_var_out );
     415             : }
     416             : 
     417             : 
     418             : /*****************************************************************************
     419             :  *
     420             :  *  Function Name : s_xor
     421             :  *
     422             :  *  Purpose :
     423             :  *
     424             :  *    Performs logical XOR of the two 16 bit input variables.
     425             :  *    var_out = var1 ^ var2
     426             :  *
     427             :  *  Complexity weight : 1
     428             :  *
     429             :  *  Inputs :
     430             :  *
     431             :  *    var1        16 bit short signed integer (Word16) whose value
     432             :  *                falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
     433             :  *
     434             :  *    var2        16 bit short signed integer (Word16) whose value
     435             :  *                falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
     436             :  *
     437             :  *  Outputs :
     438             :  *
     439             :  *    none
     440             :  *
     441             :  *  Return Value :
     442             :  *
     443             :  *    var_out     16 bit short signed integer (Word16) whose value
     444             :  *                falls in the range 0xffff 8000 <= var_out <= 0x0000 7fff.
     445             :  *
     446             :  *****************************************************************************/
     447   601513982 : static __inline Word16 s_xor( Word16 var1, Word16 var2 )
     448             : {
     449             :     Word16 var_out;
     450             : 
     451   601513982 :     var_out = var1 ^ var2;
     452             : 
     453             : #ifdef WMOPS
     454             :     multiCounter[currCounter].s_xor++;
     455             : #endif /* ifdef WMOPS */
     456             : 
     457   601513982 :     return ( var_out );
     458             : }
     459             : 
     460             : 
     461             : /*****************************************************************************
     462             :  *
     463             :  *  Function Name : L_xor
     464             :  *
     465             :  *  Purpose :
     466             :  *
     467             :  *    Performs logical OR of the two 32 bit input variables.
     468             :  *    L_var_out = L_var1 ^ L_var2
     469             :  *
     470             :  *  Complexity weight : 1
     471             :  *
     472             :  *  Inputs :
     473             :  *
     474             :  *    L_var1      32 bit long signed integer (Word32) whose value
     475             :  *                falls in the range 0x8000 0000 <= L_var1 <= 0x7fff ffff.
     476             :  *
     477             :  *    L_var2      32 bit long signed integer (Word32) whose value
     478             :  *                falls in the range 0x8000 0000 <= L_var2 <= 0x7fff ffff.
     479             :  *
     480             :  *  Outputs :
     481             :  *
     482             :  *    none
     483             :  *
     484             :  *  Return Value :
     485             :  *
     486             :  *    L_var_out   32 bit long signed integer (Word32) whose value
     487             :  *                falls in the range 0x8000 0000 <= L_var_out <= 0x7fff ffff.
     488             :  *
     489             :  *****************************************************************************/
     490    92711496 : static __inline Word32 L_xor( Word32 L_var1, Word32 L_var2 )
     491             : {
     492             :     Word32 L_var_out;
     493             : 
     494    92711496 :     L_var_out = L_var1 ^ L_var2;
     495             : 
     496             : #ifdef WMOPS
     497             :     multiCounter[currCounter].L_xor++;
     498             : #endif /* ifdef WMOPS */
     499             : 
     500    92711496 :     return ( L_var_out );
     501             : }
     502             : 
     503             : 
     504             : #endif /*_ENH1632_H*/
     505             : 
     506             : /* end of file */