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