Ignore:
Timestamp:
Apr 18, 2009 2:29:28 PM (11 years ago)
Author:
bennylp
Message:

More ticket #774: optimization for siren7/siren14 codecs

File:
1 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/third_party/g7221/common/stl-files/basop32.c

    r2601 r2616  
    8080/*___________________________________________________________________________ 
    8181 |                                                                           | 
    82  |   Local Functions                                                         | 
    83  |___________________________________________________________________________| 
    84 */ 
    85 Word16 saturate (Word32 L_var1); 
    86  
    87 /*___________________________________________________________________________ 
    88  |                                                                           | 
    8982 |   Constants and Globals                                                   | 
    9083 |___________________________________________________________________________| 
    9184*/ 
    92 Flag Overflow = 0; 
    93 Flag Carry = 0; 
     85#if INCLUDE_UNSAFE 
     86Flag g7221_Overflow = 0; 
     87Flag g7221_Carry = 0; 
     88#endif 
    9489 
    9590/*___________________________________________________________________________ 
     
    9893 |___________________________________________________________________________| 
    9994*/ 
    100  
    101 /*___________________________________________________________________________ 
    102  |                                                                           | 
    103  |   Function Name : saturate                                                | 
    104  |                                                                           | 
    105  |   Purpose :                                                               | 
    106  |                                                                           | 
    107  |    Limit the 32 bit input to the range of a 16 bit word.                  | 
    108  |                                                                           | 
    109  |   Inputs :                                                                | 
    110  |                                                                           | 
    111  |    L_var1                                                                 | 
    112  |             32 bit long signed integer (Word32) whose value falls in the  | 
    113  |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 | 
     95/*___________________________________________________________________________ 
     96 |                                                                           | 
     97 |   Function Name : shr                                                     | 
     98 |                                                                           | 
     99 |   Purpose :                                                               | 
     100 |                                                                           | 
     101 |   Arithmetically shift the 16 bit input var1 right var2 positions with    | 
     102 |   sign extension. If var2 is negative, arithmetically shift var1 left by  | 
     103 |   -var2 with sign extension. Saturate the result in case of underflows or | 
     104 |   overflows.                                                              | 
     105 |                                                                           | 
     106 |   Complexity weight : 1                                                   | 
     107 |                                                                           | 
     108 |   Inputs :                                                                | 
     109 |                                                                           | 
     110 |    var1                                                                   | 
     111 |             16 bit short signed integer (Word16) whose value falls in the | 
     112 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
     113 |                                                                           | 
     114 |    var2                                                                   | 
     115 |             16 bit short signed integer (Word16) whose value falls in the | 
     116 |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    114117 |                                                                           | 
    115118 |   Outputs :                                                               | 
     
    124127 |___________________________________________________________________________| 
    125128*/ 
    126 Word16 saturate (Word32 L_var1) 
    127 { 
    128     Word16 var_out; 
    129  
    130     if (L_var1 > 0X00007fffL) 
    131     { 
    132         Overflow = 1; 
    133         var_out = MAX_16; 
    134     } 
    135     else if (L_var1 < (Word32) 0xffff8000L) 
    136     { 
    137         Overflow = 1; 
    138         var_out = MIN_16; 
     129Word16 shr (Word16 var1, Word16 var2) 
     130{ 
     131    if (var2 < 0) 
     132    { 
     133        if (var2 < -16) 
     134            var2 = -16; 
     135        return shl_nocheck(var1, (Word16) -var2); 
    139136    } 
    140137    else 
    141138    { 
    142         var_out = extract_l (L_var1); 
    143 #if (WMOPS) 
    144         multiCounter[currCounter].extract_l--; 
    145 #endif 
    146     } 
    147  
    148     return (var_out); 
    149 } 
    150 /* ------------------------- End of saturate() ------------------------- */ 
    151  
    152  
    153 /*___________________________________________________________________________ 
    154  |                                                                           | 
    155  |   Function Name : add                                                     | 
    156  |                                                                           | 
    157  |   Purpose :                                                               | 
    158  |                                                                           | 
    159  |    Performs the addition (var1+var2) with overflow control and saturation;| 
    160  |    the 16 bit result is set at +32767 when overflow occurs or at -32768   | 
    161  |    when underflow occurs.                                                 | 
    162  |                                                                           | 
    163  |   Complexity weight : 1                                                   | 
    164  |                                                                           | 
    165  |   Inputs :                                                                | 
    166  |                                                                           | 
    167  |    var1                                                                   | 
    168  |             16 bit short signed integer (Word16) whose value falls in the | 
    169  |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    170  |                                                                           | 
    171  |    var2                                                                   | 
    172  |             16 bit short signed integer (Word16) whose value falls in the | 
    173  |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    174  |                                                                           | 
    175  |   Outputs :                                                               | 
    176  |                                                                           | 
    177  |    none                                                                   | 
    178  |                                                                           | 
    179  |   Return Value :                                                          | 
    180  |                                                                           | 
    181  |    var_out                                                                | 
    182  |             16 bit short signed integer (Word16) whose value falls in the | 
    183  |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                | 
    184  |___________________________________________________________________________| 
    185 */ 
    186 Word16 add (Word16 var1, Word16 var2) 
    187 { 
    188     Word16 var_out; 
    189     Word32 L_sum; 
    190  
    191     L_sum = (Word32) var1 + var2; 
    192     var_out = saturate (L_sum); 
    193 #if (WMOPS) 
    194     multiCounter[currCounter].add++; 
    195 #endif 
    196     return (var_out); 
    197 } 
    198 /* ------------------------- End of add() ------------------------- */ 
    199  
    200  
    201 /*___________________________________________________________________________ 
    202  |                                                                           | 
    203  |   Function Name : sub                                                     | 
    204  |                                                                           | 
    205  |   Purpose :                                                               | 
    206  |                                                                           | 
    207  |    Performs the subtraction (var1+var2) with overflow control and satu-   | 
    208  |    ration; the 16 bit result is set at +32767 when overflow occurs or at  | 
    209  |    -32768 when underflow occurs.                                          | 
    210  |                                                                           | 
    211  |   Complexity weight : 1                                                   | 
    212  |                                                                           | 
    213  |   Inputs :                                                                | 
    214  |                                                                           | 
    215  |    var1                                                                   | 
    216  |             16 bit short signed integer (Word16) whose value falls in the | 
    217  |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    218  |                                                                           | 
    219  |    var2                                                                   | 
    220  |             16 bit short signed integer (Word16) whose value falls in the | 
    221  |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    222  |                                                                           | 
    223  |   Outputs :                                                               | 
    224  |                                                                           | 
    225  |    none                                                                   | 
    226  |                                                                           | 
    227  |   Return Value :                                                          | 
    228  |                                                                           | 
    229  |    var_out                                                                | 
    230  |             16 bit short signed integer (Word16) whose value falls in the | 
    231  |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                | 
    232  |___________________________________________________________________________| 
    233 */ 
    234 Word16 sub (Word16 var1, Word16 var2) 
    235 { 
    236     Word16 var_out; 
    237     Word32 L_diff; 
    238  
    239     L_diff = (Word32) var1 - var2; 
    240     var_out = saturate (L_diff); 
    241 #if (WMOPS) 
    242     multiCounter[currCounter].sub++; 
    243 #endif 
    244     return (var_out); 
    245 } 
    246 /* ------------------------- End of sub() ------------------------- */ 
    247  
    248  
    249 /*___________________________________________________________________________ 
    250  |                                                                           | 
    251  |   Function Name : abs_s                                                   | 
    252  |                                                                           | 
    253  |   Purpose :                                                               | 
    254  |                                                                           | 
    255  |    Absolute value of var1; abs_s(-32768) = 32767.                         | 
    256  |                                                                           | 
    257  |   Complexity weight : 1                                                   | 
    258  |                                                                           | 
    259  |   Inputs :                                                                | 
    260  |                                                                           | 
    261  |    var1                                                                   | 
    262  |             16 bit short signed integer (Word16) whose value falls in the | 
    263  |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    264  |                                                                           | 
    265  |   Outputs :                                                               | 
    266  |                                                                           | 
    267  |    none                                                                   | 
    268  |                                                                           | 
    269  |   Return Value :                                                          | 
    270  |                                                                           | 
    271  |    var_out                                                                | 
    272  |             16 bit short signed integer (Word16) whose value falls in the | 
    273  |             range : 0x0000 0000 <= var_out <= 0x0000 7fff.                | 
    274  |___________________________________________________________________________| 
    275 */ 
    276 Word16 abs_s (Word16 var1) 
    277 { 
    278     Word16 var_out; 
    279  
    280     if (var1 == (Word16) 0X8000) 
    281     { 
    282         var_out = MAX_16; 
    283     } 
    284     else 
    285     { 
    286         if (var1 < 0) 
    287         { 
    288             var_out = -var1; 
    289         } 
    290         else 
    291         { 
    292             var_out = var1; 
    293         } 
    294     } 
    295 #if (WMOPS) 
    296     multiCounter[currCounter].abs_s++; 
    297 #endif 
    298     return (var_out); 
    299 } 
    300 /* ------------------------- End of abs_s() ------------------------- */ 
     139        return shr_nocheck(var1, var2); 
     140    } 
     141} 
     142/* ------------------------- End of shr() ------------------------- */ 
    301143 
    302144 
     
    337179Word16 shl (Word16 var1, Word16 var2) 
    338180{ 
    339     Word16 var_out; 
    340     Word32 result; 
    341  
    342181    if (var2 < 0) 
    343182    { 
    344         if (var2 < -16) 
    345             var2 = -16; 
    346         var_out = shr (var1, (Word16) -var2); 
    347 #if (WMOPS) 
    348         multiCounter[currCounter].shr--; 
    349 #endif 
     183        return shr_nocheck(var1, (Word16) -var2); 
    350184    } 
    351185    else 
    352186    { 
    353         result = (Word32) var1 *((Word32) 1 << var2); 
    354  
    355         if ((var2 > 15 && var1 != 0) || (result != (Word32) ((Word16) result))) 
    356         { 
    357             Overflow = 1; 
    358             var_out = (var1 > 0) ? MAX_16 : MIN_16; 
    359         } 
    360         else 
    361         { 
    362             var_out = extract_l (result); 
    363 #if (WMOPS) 
    364             multiCounter[currCounter].extract_l--; 
    365 #endif 
    366         } 
    367     } 
    368 #if (WMOPS) 
    369     multiCounter[currCounter].shl++; 
    370 #endif 
    371     return (var_out); 
     187        return shl_nocheck(var1, var2); 
     188    } 
    372189} 
    373190/* ------------------------- End of shl() ------------------------- */ 
    374191 
    375  
    376 /*___________________________________________________________________________ 
    377  |                                                                           | 
    378  |   Function Name : shr                                                     | 
    379  |                                                                           | 
    380  |   Purpose :                                                               | 
    381  |                                                                           | 
    382  |   Arithmetically shift the 16 bit input var1 right var2 positions with    | 
    383  |   sign extension. If var2 is negative, arithmetically shift var1 left by  | 
    384  |   -var2 with sign extension. Saturate the result in case of underflows or | 
    385  |   overflows.                                                              | 
    386  |                                                                           | 
    387  |   Complexity weight : 1                                                   | 
    388  |                                                                           | 
    389  |   Inputs :                                                                | 
    390  |                                                                           | 
    391  |    var1                                                                   | 
    392  |             16 bit short signed integer (Word16) whose value falls in the | 
    393  |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    394  |                                                                           | 
    395  |    var2                                                                   | 
    396  |             16 bit short signed integer (Word16) whose value falls in the | 
    397  |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    398  |                                                                           | 
    399  |   Outputs :                                                               | 
    400  |                                                                           | 
    401  |    none                                                                   | 
    402  |                                                                           | 
    403  |   Return Value :                                                          | 
    404  |                                                                           | 
    405  |    var_out                                                                | 
    406  |             16 bit short signed integer (Word16) whose value falls in the | 
    407  |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                | 
    408  |___________________________________________________________________________| 
    409 */ 
    410 Word16 shr (Word16 var1, Word16 var2) 
    411 { 
    412     Word16 var_out; 
    413  
    414     if (var2 < 0) 
    415     { 
    416         if (var2 < -16) 
    417             var2 = -16; 
    418         var_out = shl (var1, (Word16) -var2); 
    419 #if (WMOPS) 
    420         multiCounter[currCounter].shl--; 
    421 #endif 
    422     } 
    423     else 
    424     { 
    425         if (var2 >= 15) 
    426         { 
    427             var_out = (var1 < 0) ? -1 : 0; 
    428         } 
    429         else 
    430         { 
    431             if (var1 < 0) 
    432             { 
    433                 var_out = ~((~var1) >> var2); 
    434             } 
    435             else 
    436             { 
    437                 var_out = var1 >> var2; 
    438             } 
    439         } 
    440     } 
    441  
    442 #if (WMOPS) 
    443     multiCounter[currCounter].shr++; 
    444 #endif 
    445     return (var_out); 
    446 } 
    447 /* ------------------------- End of shr() ------------------------- */ 
    448192 
    449193 
     
    505249/*___________________________________________________________________________ 
    506250 |                                                                           | 
    507  |   Function Name : L_mult                                                  | 
    508  |                                                                           | 
    509  |   Purpose :                                                               | 
    510  |                                                                           | 
    511  |   L_mult is the 32 bit result of the multiplication of var1 times var2    | 
    512  |   with one shift left i.e.:                                               | 
    513  |        L_mult(var1,var2) = L_shl((var1 times var2),1) and                 | 
    514  |        L_mult(-32768,-32768) = 2147483647.                                | 
     251 |   Function Name : L_msu                                                   | 
     252 |                                                                           | 
     253 |   Purpose :                                                               | 
     254 |                                                                           | 
     255 |   Multiply var1 by var2 and shift the result left by 1. Subtract the 32   | 
     256 |   bit result to L_var3 with saturation, return a 32 bit result:           | 
     257 |        L_msu(L_var3,var1,var2) = L_sub(L_var3,L_mult(var1,var2)).         | 
    515258 |                                                                           | 
    516259 |   Complexity weight : 1                                                   | 
    517260 |                                                                           | 
    518261 |   Inputs :                                                                | 
     262 |                                                                           | 
     263 |    L_var3   32 bit long signed integer (Word32) whose value falls in the  | 
     264 |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 | 
    519265 |                                                                           | 
    520266 |    var1                                                                   | 
     
    537283 |___________________________________________________________________________| 
    538284*/ 
    539 Word32 L_mult (Word16 var1, Word16 var2) 
    540 { 
    541     Word32 L_var_out; 
    542  
    543     L_var_out = (Word32) var1 *(Word32) var2; 
    544  
    545     if (L_var_out != (Word32) 0x40000000L) 
    546     { 
    547         L_var_out *= 2; 
    548     } 
    549     else 
    550     { 
    551         Overflow = 1; 
    552         L_var_out = MAX_32; 
    553     } 
    554  
    555 #if (WMOPS) 
    556     multiCounter[currCounter].L_mult++; 
    557 #endif 
    558     return (L_var_out); 
    559 } 
    560 /* ------------------------- End of L_mult() ------------------------- */ 
    561  
    562  
    563 /*___________________________________________________________________________ 
    564  |                                                                           | 
    565  |   Function Name : negate                                                  | 
    566  |                                                                           | 
    567  |   Purpose :                                                               | 
    568  |                                                                           | 
    569  |   Negate var1 with saturation, saturate in the case where input is -32768:| 
    570  |                negate(var1) = sub(0,var1).                                | 
    571  |                                                                           | 
    572  |   Complexity weight : 1                                                   | 
    573  |                                                                           | 
    574  |   Inputs :                                                                | 
    575  |                                                                           | 
    576  |    var1                                                                   | 
    577  |             16 bit short signed integer (Word16) whose value falls in the | 
    578  |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    579  |                                                                           | 
    580  |   Outputs :                                                               | 
    581  |                                                                           | 
    582  |    none                                                                   | 
    583  |                                                                           | 
    584  |   Return Value :                                                          | 
    585  |                                                                           | 
    586  |    var_out                                                                | 
    587  |             16 bit short signed integer (Word16) whose value falls in the | 
    588  |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                | 
    589  |___________________________________________________________________________| 
    590 */ 
    591 Word16 negate (Word16 var1) 
    592 { 
    593     Word16 var_out; 
    594  
    595     var_out = (var1 == MIN_16) ? MAX_16 : -var1; 
    596 #if (WMOPS) 
    597     multiCounter[currCounter].negate++; 
    598 #endif 
    599     return (var_out); 
    600 } 
    601 /* ------------------------- End of negate() ------------------------- */ 
    602  
    603  
    604 /*___________________________________________________________________________ 
    605  |                                                                           | 
    606  |   Function Name : extract_h                                               | 
    607  |                                                                           | 
    608  |   Purpose :                                                               | 
    609  |                                                                           | 
    610  |   Return the 16 MSB of L_var1.                                            | 
    611  |                                                                           | 
    612  |   Complexity weight : 1                                                   | 
    613  |                                                                           | 
    614  |   Inputs :                                                                | 
    615  |                                                                           | 
    616  |    L_var1                                                                 | 
    617  |             32 bit long signed integer (Word32 ) whose value falls in the | 
    618  |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 | 
    619  |                                                                           | 
    620  |   Outputs :                                                               | 
    621  |                                                                           | 
    622  |    none                                                                   | 
    623  |                                                                           | 
    624  |   Return Value :                                                          | 
    625  |                                                                           | 
    626  |    var_out                                                                | 
    627  |             16 bit short signed integer (Word16) whose value falls in the | 
    628  |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                | 
    629  |___________________________________________________________________________| 
    630 */ 
    631 Word16 extract_h (Word32 L_var1) 
    632 { 
    633     Word16 var_out; 
    634  
    635     var_out = (Word16) (L_var1 >> 16); 
    636 #if (WMOPS) 
    637     multiCounter[currCounter].extract_h++; 
    638 #endif 
    639     return (var_out); 
    640 } 
    641 /* ------------------------- End of extract_h() ------------------------- */ 
    642  
    643  
    644 /*___________________________________________________________________________ 
    645  |                                                                           | 
    646  |   Function Name : extract_l                                               | 
    647  |                                                                           | 
    648  |   Purpose :                                                               | 
    649  |                                                                           | 
    650  |   Return the 16 LSB of L_var1.                                            | 
    651  |                                                                           | 
    652  |   Complexity weight : 1                                                   | 
    653  |                                                                           | 
    654  |   Inputs :                                                                | 
    655  |                                                                           | 
    656  |    L_var1                                                                 | 
    657  |             32 bit long signed integer (Word32 ) whose value falls in the | 
    658  |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 | 
    659  |                                                                           | 
    660  |   Outputs :                                                               | 
    661  |                                                                           | 
    662  |    none                                                                   | 
    663  |                                                                           | 
    664  |   Return Value :                                                          | 
    665  |                                                                           | 
    666  |    var_out                                                                | 
    667  |             16 bit short signed integer (Word16) whose value falls in the | 
    668  |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                | 
    669  |___________________________________________________________________________| 
    670 */ 
    671 Word16 extract_l (Word32 L_var1) 
    672 { 
    673     Word16 var_out; 
    674  
    675     var_out = (Word16) L_var1; 
    676 #if (WMOPS) 
    677     multiCounter[currCounter].extract_l++; 
    678 #endif 
    679     return (var_out); 
    680 } 
    681 /* ------------------------- End of extract_l() ------------------------- */ 
    682  
    683  
    684 /*___________________________________________________________________________ 
    685  |                                                                           | 
    686  |   Function Name : round                                                   | 
    687  |                                                                           | 
    688  |   Purpose :                                                               | 
    689  |                                                                           | 
    690  |   Round the lower 16 bits of the 32 bit input number into the MS 16 bits  | 
    691  |   with saturation. Shift the resulting bits right by 16 and return the 16 | 
    692  |   bit number:                                                             | 
    693  |               round(L_var1) = extract_h(L_add(L_var1,32768))              | 
    694  |                                                                           | 
    695  |   Complexity weight : 1                                                   | 
    696  |                                                                           | 
    697  |   Inputs :                                                                | 
    698  |                                                                           | 
    699  |    L_var1                                                                 | 
    700  |             32 bit long signed integer (Word32 ) whose value falls in the | 
    701  |             range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.                 | 
    702  |                                                                           | 
    703  |   Outputs :                                                               | 
    704  |                                                                           | 
    705  |    none                                                                   | 
    706  |                                                                           | 
    707  |   Return Value :                                                          | 
    708  |                                                                           | 
    709  |    var_out                                                                | 
    710  |             16 bit short signed integer (Word16) whose value falls in the | 
    711  |             range : 0xffff 8000 <= var_out <= 0x0000 7fff.                | 
    712  |___________________________________________________________________________| 
    713 */ 
    714 Word16 itu_round (Word32 L_var1) 
    715 { 
    716     Word16 var_out; 
    717     Word32 L_rounded; 
    718  
    719     L_rounded = L_add (L_var1, (Word32) 0x00008000L); 
    720 #if (WMOPS) 
    721     multiCounter[currCounter].L_add--; 
    722 #endif 
    723     var_out = extract_h (L_rounded); 
    724 #if (WMOPS) 
    725     multiCounter[currCounter].extract_h--; 
    726     multiCounter[currCounter].round++; 
    727 #endif 
    728     return (var_out); 
    729 } 
    730 /* ------------------------- End of round() ------------------------- */ 
    731  
    732  
    733 /*___________________________________________________________________________ 
    734  |                                                                           | 
    735  |   Function Name : L_mac                                                   | 
    736  |                                                                           | 
    737  |   Purpose :                                                               | 
    738  |                                                                           | 
    739  |   Multiply var1 by var2 and shift the result left by 1. Add the 32 bit    | 
    740  |   result to L_var3 with saturation, return a 32 bit result:               | 
    741  |        L_mac(L_var3,var1,var2) = L_add(L_var3,L_mult(var1,var2)).         | 
    742  |                                                                           | 
    743  |   Complexity weight : 1                                                   | 
    744  |                                                                           | 
    745  |   Inputs :                                                                | 
    746  |                                                                           | 
    747  |    L_var3   32 bit long signed integer (Word32) whose value falls in the  | 
    748  |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 | 
    749  |                                                                           | 
    750  |    var1                                                                   | 
    751  |             16 bit short signed integer (Word16) whose value falls in the | 
    752  |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    753  |                                                                           | 
    754  |    var2                                                                   | 
    755  |             16 bit short signed integer (Word16) whose value falls in the | 
    756  |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    757  |                                                                           | 
    758  |   Outputs :                                                               | 
    759  |                                                                           | 
    760  |    none                                                                   | 
    761  |                                                                           | 
    762  |   Return Value :                                                          | 
    763  |                                                                           | 
    764  |    L_var_out                                                              | 
    765  |             32 bit long signed integer (Word32) whose value falls in the  | 
    766  |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              | 
    767  |___________________________________________________________________________| 
    768 */ 
    769 Word32 L_mac (Word32 L_var3, Word16 var1, Word16 var2) 
     285Word32 L_msu (Word32 L_var3, Word16 var1, Word16 var2) 
    770286{ 
    771287    Word32 L_var_out; 
     
    776292    multiCounter[currCounter].L_mult--; 
    777293#endif 
    778     L_var_out = L_add (L_var3, L_product); 
    779 #if (WMOPS) 
    780     multiCounter[currCounter].L_add--; 
    781     multiCounter[currCounter].L_mac++; 
    782 #endif 
    783     return (L_var_out); 
    784 } 
    785 /* ------------------------- End of L_mac() ------------------------- */ 
    786  
    787  
    788 /*___________________________________________________________________________ 
    789  |                                                                           | 
    790  |   Function Name : L_msu                                                   | 
    791  |                                                                           | 
    792  |   Purpose :                                                               | 
    793  |                                                                           | 
    794  |   Multiply var1 by var2 and shift the result left by 1. Subtract the 32   | 
    795  |   bit result to L_var3 with saturation, return a 32 bit result:           | 
    796  |        L_msu(L_var3,var1,var2) = L_sub(L_var3,L_mult(var1,var2)).         | 
    797  |                                                                           | 
    798  |   Complexity weight : 1                                                   | 
    799  |                                                                           | 
    800  |   Inputs :                                                                | 
    801  |                                                                           | 
    802  |    L_var3   32 bit long signed integer (Word32) whose value falls in the  | 
    803  |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 | 
    804  |                                                                           | 
    805  |    var1                                                                   | 
    806  |             16 bit short signed integer (Word16) whose value falls in the | 
    807  |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    808  |                                                                           | 
    809  |    var2                                                                   | 
    810  |             16 bit short signed integer (Word16) whose value falls in the | 
    811  |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    812  |                                                                           | 
    813  |   Outputs :                                                               | 
    814  |                                                                           | 
    815  |    none                                                                   | 
    816  |                                                                           | 
    817  |   Return Value :                                                          | 
    818  |                                                                           | 
    819  |    L_var_out                                                              | 
    820  |             32 bit long signed integer (Word32) whose value falls in the  | 
    821  |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              | 
    822  |___________________________________________________________________________| 
    823 */ 
    824 Word32 L_msu (Word32 L_var3, Word16 var1, Word16 var2) 
    825 { 
    826     Word32 L_var_out; 
    827     Word32 L_product; 
    828  
    829     L_product = L_mult (var1, var2); 
    830 #if (WMOPS) 
    831     multiCounter[currCounter].L_mult--; 
    832 #endif 
    833294    L_var_out = L_sub (L_var3, L_product); 
    834295#if (WMOPS) 
     
    840301/* ------------------------- End of L_msu() ------------------------- */ 
    841302 
    842  
     303#if INCLUDE_UNSAFE 
    843304/*___________________________________________________________________________ 
    844305 |                                                                           | 
     
    898359    return (L_var_out); 
    899360} 
     361#endif 
    900362/* ------------------------- End of L_macNs() ------------------------- */ 
    901363 
    902  
     364#if INCLUDE_UNSAFE 
    903365/*___________________________________________________________________________ 
    904366 |                                                                           | 
     
    958420    return (L_var_out); 
    959421} 
     422#endif 
     423 
    960424/* ------------------------- End of L_msuNs() ------------------------- */ 
    961425 
    962426 
    963 /*___________________________________________________________________________ 
    964  |                                                                           | 
    965  |   Function Name : L_add                                                   | 
    966  |                                                                           | 
    967  |   Purpose :                                                               | 
    968  |                                                                           | 
    969  |   32 bits addition of the two 32 bits variables (L_var1+L_var2) with      | 
    970  |   overflow control and saturation; the result is set at +2147483647 when  | 
    971  |   overflow occurs or at -2147483648 when underflow occurs.                | 
    972  |                                                                           | 
    973  |   Complexity weight : 2                                                   | 
    974  |                                                                           | 
    975  |   Inputs :                                                                | 
    976  |                                                                           | 
    977  |    L_var1   32 bit long signed integer (Word32) whose value falls in the  | 
    978  |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 | 
    979  |                                                                           | 
    980  |    L_var2   32 bit long signed integer (Word32) whose value falls in the  | 
    981  |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 | 
    982  |                                                                           | 
    983  |   Outputs :                                                               | 
    984  |                                                                           | 
    985  |    none                                                                   | 
    986  |                                                                           | 
    987  |   Return Value :                                                          | 
    988  |                                                                           | 
    989  |    L_var_out                                                              | 
    990  |             32 bit long signed integer (Word32) whose value falls in the  | 
    991  |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              | 
    992  |___________________________________________________________________________| 
    993 */ 
    994 Word32 L_add (Word32 L_var1, Word32 L_var2) 
    995 { 
    996     Word32 L_var_out; 
    997  
    998     L_var_out = L_var1 + L_var2; 
    999  
    1000     if (((L_var1 ^ L_var2) & MIN_32) == 0) 
    1001     { 
    1002         if ((L_var_out ^ L_var1) & MIN_32) 
    1003         { 
    1004             L_var_out = (L_var1 < 0) ? MIN_32 : MAX_32; 
    1005             Overflow = 1; 
    1006         } 
    1007     } 
    1008 #if (WMOPS) 
    1009     multiCounter[currCounter].L_add++; 
    1010 #endif 
    1011     return (L_var_out); 
    1012 } 
    1013 /* ------------------------- End of L_add() ------------------------- */ 
    1014  
    1015  
    1016 /*___________________________________________________________________________ 
    1017  |                                                                           | 
    1018  |   Function Name : L_sub                                                   | 
    1019  |                                                                           | 
    1020  |   Purpose :                                                               | 
    1021  |                                                                           | 
    1022  |   32 bits subtraction of the two 32 bits variables (L_var1-L_var2) with   | 
    1023  |   overflow control and saturation; the result is set at +2147483647 when  | 
    1024  |   overflow occurs or at -2147483648 when underflow occurs.                | 
    1025  |                                                                           | 
    1026  |   Complexity weight : 2                                                   | 
    1027  |                                                                           | 
    1028  |   Inputs :                                                                | 
    1029  |                                                                           | 
    1030  |    L_var1   32 bit long signed integer (Word32) whose value falls in the  | 
    1031  |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 | 
    1032  |                                                                           | 
    1033  |    L_var2   32 bit long signed integer (Word32) whose value falls in the  | 
    1034  |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 | 
    1035  |                                                                           | 
    1036  |   Outputs :                                                               | 
    1037  |                                                                           | 
    1038  |    none                                                                   | 
    1039  |                                                                           | 
    1040  |   Return Value :                                                          | 
    1041  |                                                                           | 
    1042  |    L_var_out                                                              | 
    1043  |             32 bit long signed integer (Word32) whose value falls in the  | 
    1044  |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              | 
    1045  |___________________________________________________________________________| 
    1046 */ 
    1047 Word32 L_sub (Word32 L_var1, Word32 L_var2) 
    1048 { 
    1049     Word32 L_var_out; 
    1050  
    1051     L_var_out = L_var1 - L_var2; 
    1052  
    1053     if (((L_var1 ^ L_var2) & MIN_32) != 0) 
    1054     { 
    1055         if ((L_var_out ^ L_var1) & MIN_32) 
    1056         { 
    1057             L_var_out = (L_var1 < 0L) ? MIN_32 : MAX_32; 
    1058             Overflow = 1; 
    1059         } 
    1060     } 
    1061 #if (WMOPS) 
    1062     multiCounter[currCounter].L_sub++; 
    1063 #endif 
    1064     return (L_var_out); 
    1065 } 
    1066 /* ------------------------- End of L_sub() ------------------------- */ 
    1067  
    1068  
     427#if INCLUDE_UNSAFE 
    1069428/*___________________________________________________________________________ 
    1070429 |                                                                           | 
     
    1110469    Flag carry_int = 0; 
    1111470 
    1112     L_var_out = L_var1 + L_var2 + Carry; 
     471    L_var_out = L_var1 + L_var2 + GET_CARRY(); 
    1113472 
    1114473    L_test = L_var1 + L_var2; 
     
    1116475    if ((L_var1 > 0) && (L_var2 > 0) && (L_test < 0)) 
    1117476    { 
    1118         Overflow = 1; 
     477        SET_OVERFLOW(1); 
    1119478        carry_int = 0; 
    1120479    } 
     
    1125484            if (L_test >= 0) 
    1126485            { 
    1127                 Overflow = 1; 
     486                SET_OVERFLOW(1); 
    1128487                carry_int = 1; 
    1129488            } 
    1130489            else 
    1131490            { 
    1132                 Overflow = 0; 
     491                SET_OVERFLOW(0); 
    1133492                carry_int = 1; 
    1134493            } 
     
    1138497            if (((L_var1 ^ L_var2) < 0) && (L_test >= 0)) 
    1139498            { 
    1140                 Overflow = 0; 
     499                SET_OVERFLOW(0); 
    1141500                carry_int = 1; 
    1142501            } 
    1143502            else 
    1144503            { 
    1145                 Overflow = 0; 
     504                SET_OVERFLOW(0); 
    1146505                carry_int = 0; 
    1147506            } 
     
    1149508    } 
    1150509 
    1151     if (Carry) 
     510    if (GET_CARRY()) 
    1152511    { 
    1153512        if (L_test == MAX_32) 
    1154513        { 
    1155             Overflow = 1; 
    1156             Carry = carry_int; 
     514            SET_OVERFLOW(1); 
     515            SET_CARRY(carry_int); 
    1157516        } 
    1158517        else 
     
    1160519            if (L_test == (Word32) 0xFFFFFFFFL) 
    1161520            { 
    1162                 Carry = 1; 
     521                SET_CARRY(1); 
    1163522            } 
    1164523            else 
    1165524            { 
    1166                 Carry = carry_int; 
     525                SET_CARRY(carry_int); 
    1167526            } 
    1168527        } 
     
    1170529    else 
    1171530    { 
    1172         Carry = carry_int; 
     531        SET_CARRY(carry_int); 
    1173532    } 
    1174533 
     
    1178537    return (L_var_out); 
    1179538} 
     539#endif 
     540 
    1180541/* ------------------------- End of L_add_c() ------------------------- */ 
    1181542 
    1182  
     543#if INCLUDE_UNSAFE 
    1183544/*___________________________________________________________________________ 
    1184545 |                                                                           | 
     
    1224585    Flag carry_int = 0; 
    1225586 
    1226     if (Carry) 
    1227     { 
    1228         Carry = 0; 
     587    if (GET_CARRY()) 
     588    { 
     589        SET_CARRY(0); 
    1229590        if (L_var2 != MIN_32) 
    1230591        { 
     
    1239600            if (L_var1 > 0L) 
    1240601            { 
    1241                 Overflow = 1; 
    1242                 Carry = 0; 
     602                SET_OVERFLOW(1); 
     603                SET_CARRY(0); 
    1243604            } 
    1244605        } 
     
    1251612        if ((L_test < 0) && (L_var1 > 0) && (L_var2 < 0)) 
    1252613        { 
    1253             Overflow = 1; 
     614            SET_OVERFLOW(1); 
    1254615            carry_int = 0; 
    1255616        } 
    1256617        else if ((L_test > 0) && (L_var1 < 0) && (L_var2 > 0)) 
    1257618        { 
    1258             Overflow = 1; 
     619            SET_OVERFLOW(1); 
    1259620            carry_int = 1; 
    1260621        } 
    1261622        else if ((L_test > 0) && ((L_var1 ^ L_var2) > 0)) 
    1262623        { 
    1263             Overflow = 0; 
     624            SET_OVERFLOW(0); 
    1264625            carry_int = 1; 
    1265626        } 
    1266627        if (L_test == MIN_32) 
    1267628        { 
    1268             Overflow = 1; 
    1269             Carry = carry_int; 
     629            SET_OVERFLOW(1); 
     630            SET_CARRY(carry_int); 
    1270631        } 
    1271632        else 
    1272633        { 
    1273             Carry = carry_int; 
     634            SET_CARRY(carry_int); 
    1274635        } 
    1275636    } 
     
    1280641    return (L_var_out); 
    1281642} 
     643#endif 
    1282644/* ------------------------- End of L_sub_c() ------------------------- */ 
    1283645 
     
    1378740/* ------------------------- End of mult_r() ------------------------- */ 
    1379741 
    1380  
    1381 /*___________________________________________________________________________ 
    1382  |                                                                           | 
    1383  |   Function Name : L_shl                                                   | 
    1384  |                                                                           | 
    1385  |   Purpose :                                                               | 
    1386  |                                                                           | 
    1387  |   Arithmetically shift the 32 bit input L_var1 left var2 positions. Zero  | 
    1388  |   fill the var2 LSB of the result. If var2 is negative, arithmetically    | 
    1389  |   shift L_var1 right by -var2 with sign extension. Saturate the result in | 
    1390  |   case of underflows or overflows.                                        | 
    1391  |                                                                           | 
    1392  |   Complexity weight : 2                                                   | 
    1393  |                                                                           | 
    1394  |   Inputs :                                                                | 
    1395  |                                                                           | 
    1396  |    L_var1   32 bit long signed integer (Word32) whose value falls in the  | 
    1397  |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 | 
    1398  |                                                                           | 
    1399  |    var2                                                                   | 
    1400  |             16 bit short signed integer (Word16) whose value falls in the | 
    1401  |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    1402  |                                                                           | 
    1403  |   Outputs :                                                               | 
    1404  |                                                                           | 
    1405  |    none                                                                   | 
    1406  |                                                                           | 
    1407  |   Return Value :                                                          | 
    1408  |                                                                           | 
    1409  |    L_var_out                                                              | 
    1410  |             32 bit long signed integer (Word32) whose value falls in the  | 
    1411  |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              | 
    1412  |___________________________________________________________________________| 
    1413 */ 
    1414 Word32 L_shl (Word32 L_var1, Word16 var2) 
    1415 { 
    1416     Word32 L_var_out; 
    1417  
    1418     if (var2 <= 0) 
    1419     { 
    1420         if (var2 < -32) 
    1421             var2 = -32; 
    1422         L_var_out = L_shr (L_var1, (Word16) -var2); 
    1423 #if (WMOPS) 
    1424         multiCounter[currCounter].L_shr--; 
    1425 #endif 
    1426     } 
    1427     else 
    1428     { 
    1429         for (; var2 > 0; var2--) 
    1430         { 
    1431             if (L_var1 > (Word32) 0X3fffffffL) 
    1432             { 
    1433                 Overflow = 1; 
    1434                 L_var_out = MAX_32; 
    1435                 break; 
    1436             } 
    1437             else 
    1438             { 
    1439                 if (L_var1 < (Word32) 0xc0000000L) 
    1440                 { 
    1441                     Overflow = 1; 
    1442                     L_var_out = MIN_32; 
    1443                     break; 
    1444                 } 
    1445             } 
    1446             L_var1 *= 2; 
    1447             L_var_out = L_var1; 
    1448         } 
    1449     } 
    1450 #if (WMOPS) 
    1451     multiCounter[currCounter].L_shl++; 
    1452 #endif 
    1453     return (L_var_out); 
    1454 } 
    1455 /* ------------------------- End of L_shl() ------------------------- */ 
    1456  
    1457  
    1458 /*___________________________________________________________________________ 
    1459  |                                                                           | 
    1460  |   Function Name : L_shr                                                   | 
    1461  |                                                                           | 
    1462  |   Purpose :                                                               | 
    1463  |                                                                           | 
    1464  |   Arithmetically shift the 32 bit input L_var1 right var2 positions with  | 
    1465  |   sign extension. If var2 is negative, arithmetically shift L_var1 left   | 
    1466  |   by -var2 and zero fill the -var2 LSB of the result. Saturate the result | 
    1467  |   in case of underflows or overflows.                                     | 
    1468  |                                                                           | 
    1469  |   Complexity weight : 2                                                   | 
    1470  |                                                                           | 
    1471  |   Inputs :                                                                | 
    1472  |                                                                           | 
    1473  |    L_var1   32 bit long signed integer (Word32) whose value falls in the  | 
    1474  |             range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.                 | 
    1475  |                                                                           | 
    1476  |    var2                                                                   | 
    1477  |             16 bit short signed integer (Word16) whose value falls in the | 
    1478  |             range : 0xffff 8000 <= var1 <= 0x0000 7fff.                   | 
    1479  |                                                                           | 
    1480  |   Outputs :                                                               | 
    1481  |                                                                           | 
    1482  |    none                                                                   | 
    1483  |                                                                           | 
    1484  |   Return Value :                                                          | 
    1485  |                                                                           | 
    1486  |    L_var_out                                                              | 
    1487  |             32 bit long signed integer (Word32) whose value falls in the  | 
    1488  |             range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.              | 
    1489  |___________________________________________________________________________| 
    1490 */ 
    1491 Word32 L_shr (Word32 L_var1, Word16 var2) 
    1492 { 
    1493     Word32 L_var_out; 
    1494  
    1495     if (var2 < 0) 
    1496     { 
    1497         if (var2 < -32) 
    1498             var2 = -32; 
    1499         L_var_out = L_shl (L_var1, (Word16) -var2); 
    1500 #if (WMOPS) 
    1501         multiCounter[currCounter].L_shl--; 
    1502 #endif 
    1503     } 
    1504     else 
    1505     { 
    1506         if (var2 >= 31) 
    1507         { 
    1508             L_var_out = (L_var1 < 0L) ? -1 : 0; 
    1509         } 
    1510         else 
    1511         { 
    1512             if (L_var1 < 0) 
    1513             { 
    1514                 L_var_out = ~((~L_var1) >> var2); 
    1515             } 
    1516             else 
    1517             { 
    1518                 L_var_out = L_var1 >> var2; 
    1519             } 
    1520         } 
    1521     } 
    1522 #if (WMOPS) 
    1523     multiCounter[currCounter].L_shr++; 
    1524 #endif 
    1525     return (L_var_out); 
    1526 } 
    1527 /* ------------------------- End of L_shr() ------------------------- */ 
    1528742 
    1529743 
     
    19311145/*___________________________________________________________________________ 
    19321146 |                                                                           | 
    1933  |   Function Name : L_sat                                                   | 
    1934  |                                                                           | 
    1935  |   Purpose :                                                               | 
    1936  |                                                                           | 
    1937  |    32 bit L_var1 is set to 2147483647 if an overflow occured or to        | 
    1938  |    -2147483648 if an underflow occured on the most recent L_add_c,        | 
    1939  |    L_sub_c, L_macNs or L_msuNs operations. The carry and overflow values  | 
    1940  |    are binary values which can be tested and assigned values.             | 
    1941  |                                                                           | 
    1942  |   Complexity weight : 4                                                   | 
    1943  |                                                                           | 
    1944  |   Inputs :                                                                | 
    1945  |                                                                           | 
    1946  |    L_var1                                                                 | 
    1947  |             32 bit long signed integer (Word32) whose value falls in the  | 
    1948  |             range : 0x8000 0000 <= var1 <= 0x7fff ffff.                   | 
    1949  |                                                                           | 
    1950  |   Outputs :                                                               | 
    1951  |                                                                           | 
    1952  |    none                                                                   | 
    1953  |                                                                           | 
    1954  |   Return Value :                                                          | 
    1955  |                                                                           | 
    1956  |    L_var_out                                                              | 
    1957  |             32 bit long signed integer (Word32) whose value falls in the  | 
    1958  |             range : 0x8000 0000 <= var_out <= 0x7fff ffff.                | 
    1959  |___________________________________________________________________________| 
    1960 */ 
    1961 Word32 L_sat (Word32 L_var1) 
    1962 { 
    1963     Word32 L_var_out; 
    1964  
    1965     L_var_out = L_var1; 
    1966  
    1967     if (Overflow) 
    1968     { 
    1969  
    1970         if (Carry) 
    1971         { 
    1972             L_var_out = MIN_32; 
    1973         } 
    1974         else 
    1975         { 
    1976             L_var_out = MAX_32; 
    1977         } 
    1978  
    1979         Carry = 0; 
    1980         Overflow = 0; 
    1981     } 
    1982 #if (WMOPS) 
    1983     multiCounter[currCounter].L_sat++; 
    1984 #endif 
    1985     return (L_var_out); 
    1986 } 
    1987 /* ------------------------- End of L_sat() ------------------------- */ 
    1988  
    1989  
    1990 /*___________________________________________________________________________ 
    1991  |                                                                           | 
    19921147 |   Function Name : norm_s                                                  | 
    19931148 |                                                                           | 
     
    22761431   Temp = Lv & (Word32) 0x0000ffff ; 
    22771432   Temp = Temp * (Word32) v ; 
    2278    Temp = L_shr( Temp, (Word16) 15 ) ; 
     1433   Temp = L_shr_nocheck( Temp, (Word16) 15 ) ; 
    22791434   Temp = L_mac( Temp, v, extract_h(Lv) ) ; 
    22801435 
     
    23581513    } 
    23591514    else { 
    2360         L_num = L_shr(L_num, (Word16)1) ; 
    2361         L_den = L_shr(L_den, (Word16)1); 
     1515        L_num = L_shr_nocheck(L_num, (Word16)1) ; 
     1516        L_den = L_shr_nocheck(L_den, (Word16)1); 
    23621517#if (WMOPS) 
    23631518        multiCounter[currCounter].L_shr-=2; 
    23641519#endif 
    23651520        for(iteration=(Word16)0; iteration< (Word16)15;iteration++) { 
    2366             var_out = shl( var_out, (Word16)1); 
    2367             L_num   = L_shl( L_num, (Word16)1); 
     1521            var_out = shl_nocheck( var_out, (Word16)1); 
     1522            L_num   = L_shl_nocheck( L_num, (Word16)1); 
    23681523#if (WMOPS) 
    23691524            multiCounter[currCounter].shl--; 
     
    26291784            if (L_var1 > (UWord32) 0X7fffffffL) 
    26301785            { 
    2631                 Overflow = 1; 
     1786                SET_OVERFLOW(1); 
    26321787                L_var_out = UMAX_32; 
    26331788                break; 
     
    26371792                if (L_var1 < (UWord32) 0x00000001L) 
    26381793                { 
    2639                     Overflow = 1; 
     1794                    SET_OVERFLOW(1); 
    26401795                    L_var_out = MIN_32; 
    26411796                    break; 
Note: See TracChangeset for help on using the changeset viewer.