diff options
Diffstat (limited to 'third_party/g7221/common/stl-files')
| -rw-r--r-- | third_party/g7221/common/stl-files/basop32.c | 957 | ||||
| -rw-r--r-- | third_party/g7221/common/stl-files/basop32.h | 53 | ||||
| -rw-r--r-- | third_party/g7221/common/stl-files/basop32_i.h | 730 | ||||
| -rw-r--r-- | third_party/g7221/common/stl-files/count.c | 303 | ||||
| -rw-r--r-- | third_party/g7221/common/stl-files/count.h | 68 |
5 files changed, 887 insertions, 1224 deletions
diff --git a/third_party/g7221/common/stl-files/basop32.c b/third_party/g7221/common/stl-files/basop32.c index 9eb4f380..efd5c204 100644 --- a/third_party/g7221/common/stl-files/basop32.c +++ b/third_party/g7221/common/stl-files/basop32.c @@ -79,134 +79,29 @@ extern int currCounter; /*___________________________________________________________________________ | | - | Local Functions | - |___________________________________________________________________________| -*/ -Word16 saturate (Word32 L_var1); - -/*___________________________________________________________________________ - | | | Constants and Globals | |___________________________________________________________________________| */ -Flag Overflow = 0; -Flag Carry = 0; - -/*___________________________________________________________________________ - | | - | Functions | - |___________________________________________________________________________| -*/ - -/*___________________________________________________________________________ - | | - | Function Name : saturate | - | | - | Purpose : | - | | - | Limit the 32 bit input to the range of a 16 bit word. | - | | - | Inputs : | - | | - | L_var1 | - | 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | var_out | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | - |___________________________________________________________________________| -*/ -Word16 saturate (Word32 L_var1) -{ - Word16 var_out; - - if (L_var1 > 0X00007fffL) - { - Overflow = 1; - var_out = MAX_16; - } - else if (L_var1 < (Word32) 0xffff8000L) - { - Overflow = 1; - var_out = MIN_16; - } - else - { - var_out = extract_l (L_var1); -#if (WMOPS) - multiCounter[currCounter].extract_l--; +#if INCLUDE_UNSAFE +Flag g7221_Overflow = 0; +Flag g7221_Carry = 0; #endif - } - - return (var_out); -} -/* ------------------------- End of saturate() ------------------------- */ - /*___________________________________________________________________________ | | - | Function Name : add | - | | - | Purpose : | - | | - | Performs the addition (var1+var2) with overflow control and saturation;| - | the 16 bit result is set at +32767 when overflow occurs or at -32768 | - | when underflow occurs. | - | | - | Complexity weight : 1 | - | | - | Inputs : | - | | - | var1 | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | - | | - | var2 | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | var_out | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | + | Functions | |___________________________________________________________________________| */ -Word16 add (Word16 var1, Word16 var2) -{ - Word16 var_out; - Word32 L_sum; - - L_sum = (Word32) var1 + var2; - var_out = saturate (L_sum); -#if (WMOPS) - multiCounter[currCounter].add++; -#endif - return (var_out); -} -/* ------------------------- End of add() ------------------------- */ - - /*___________________________________________________________________________ | | - | Function Name : sub | + | Function Name : shr | | | | Purpose : | | | - | Performs the subtraction (var1+var2) with overflow control and satu- | - | ration; the 16 bit result is set at +32767 when overflow occurs or at | - | -32768 when underflow occurs. | + | Arithmetically shift the 16 bit input var1 right var2 positions with | + | sign extension. If var2 is negative, arithmetically shift var1 left by | + | -var2 with sign extension. Saturate the result in case of underflows or | + | overflows. | | | | Complexity weight : 1 | | | @@ -231,73 +126,20 @@ Word16 add (Word16 var1, Word16 var2) | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | |___________________________________________________________________________| */ -Word16 sub (Word16 var1, Word16 var2) -{ - Word16 var_out; - Word32 L_diff; - - L_diff = (Word32) var1 - var2; - var_out = saturate (L_diff); -#if (WMOPS) - multiCounter[currCounter].sub++; -#endif - return (var_out); -} -/* ------------------------- End of sub() ------------------------- */ - - -/*___________________________________________________________________________ - | | - | Function Name : abs_s | - | | - | Purpose : | - | | - | Absolute value of var1; abs_s(-32768) = 32767. | - | | - | Complexity weight : 1 | - | | - | Inputs : | - | | - | var1 | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | var_out | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0x0000 0000 <= var_out <= 0x0000 7fff. | - |___________________________________________________________________________| -*/ -Word16 abs_s (Word16 var1) +Word16 shr (Word16 var1, Word16 var2) { - Word16 var_out; - - if (var1 == (Word16) 0X8000) + if (var2 < 0) { - var_out = MAX_16; + if (var2 < -16) + var2 = -16; + return shl_nocheck(var1, (Word16) -var2); } else { - if (var1 < 0) - { - var_out = -var1; - } - else - { - var_out = var1; - } + return shr_nocheck(var1, var2); } -#if (WMOPS) - multiCounter[currCounter].abs_s++; -#endif - return (var_out); } -/* ------------------------- End of abs_s() ------------------------- */ +/* ------------------------- End of shr() ------------------------- */ /*___________________________________________________________________________ @@ -336,116 +178,18 @@ Word16 abs_s (Word16 var1) */ Word16 shl (Word16 var1, Word16 var2) { - Word16 var_out; - Word32 result; - if (var2 < 0) { - if (var2 < -16) - var2 = -16; - var_out = shr (var1, (Word16) -var2); -#if (WMOPS) - multiCounter[currCounter].shr--; -#endif + return shr_nocheck(var1, (Word16) -var2); } else { - result = (Word32) var1 *((Word32) 1 << var2); - - if ((var2 > 15 && var1 != 0) || (result != (Word32) ((Word16) result))) - { - Overflow = 1; - var_out = (var1 > 0) ? MAX_16 : MIN_16; - } - else - { - var_out = extract_l (result); -#if (WMOPS) - multiCounter[currCounter].extract_l--; -#endif - } + return shl_nocheck(var1, var2); } -#if (WMOPS) - multiCounter[currCounter].shl++; -#endif - return (var_out); } /* ------------------------- End of shl() ------------------------- */ -/*___________________________________________________________________________ - | | - | Function Name : shr | - | | - | Purpose : | - | | - | Arithmetically shift the 16 bit input var1 right var2 positions with | - | sign extension. If var2 is negative, arithmetically shift var1 left by | - | -var2 with sign extension. Saturate the result in case of underflows or | - | overflows. | - | | - | Complexity weight : 1 | - | | - | Inputs : | - | | - | var1 | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | - | | - | var2 | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | var_out | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | - |___________________________________________________________________________| -*/ -Word16 shr (Word16 var1, Word16 var2) -{ - Word16 var_out; - - if (var2 < 0) - { - if (var2 < -16) - var2 = -16; - var_out = shl (var1, (Word16) -var2); -#if (WMOPS) - multiCounter[currCounter].shl--; -#endif - } - else - { - if (var2 >= 15) - { - var_out = (var1 < 0) ? -1 : 0; - } - else - { - if (var1 < 0) - { - var_out = ~((~var1) >> var2); - } - else - { - var_out = var1 >> var2; - } - } - } - -#if (WMOPS) - multiCounter[currCounter].shr++; -#endif - return (var_out); -} -/* ------------------------- End of shr() ------------------------- */ - /*___________________________________________________________________________ | | @@ -504,289 +248,6 @@ Word16 mult (Word16 var1, Word16 var2) /*___________________________________________________________________________ | | - | Function Name : L_mult | - | | - | Purpose : | - | | - | L_mult is the 32 bit result of the multiplication of var1 times var2 | - | with one shift left i.e.: | - | L_mult(var1,var2) = L_shl((var1 times var2),1) and | - | L_mult(-32768,-32768) = 2147483647. | - | | - | Complexity weight : 1 | - | | - | Inputs : | - | | - | var1 | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | - | | - | var2 | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | L_var_out | - | 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. | - |___________________________________________________________________________| -*/ -Word32 L_mult (Word16 var1, Word16 var2) -{ - Word32 L_var_out; - - L_var_out = (Word32) var1 *(Word32) var2; - - if (L_var_out != (Word32) 0x40000000L) - { - L_var_out *= 2; - } - else - { - Overflow = 1; - L_var_out = MAX_32; - } - -#if (WMOPS) - multiCounter[currCounter].L_mult++; -#endif - return (L_var_out); -} -/* ------------------------- End of L_mult() ------------------------- */ - - -/*___________________________________________________________________________ - | | - | Function Name : negate | - | | - | Purpose : | - | | - | Negate var1 with saturation, saturate in the case where input is -32768:| - | negate(var1) = sub(0,var1). | - | | - | Complexity weight : 1 | - | | - | Inputs : | - | | - | var1 | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | var_out | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | - |___________________________________________________________________________| -*/ -Word16 negate (Word16 var1) -{ - Word16 var_out; - - var_out = (var1 == MIN_16) ? MAX_16 : -var1; -#if (WMOPS) - multiCounter[currCounter].negate++; -#endif - return (var_out); -} -/* ------------------------- End of negate() ------------------------- */ - - -/*___________________________________________________________________________ - | | - | Function Name : extract_h | - | | - | Purpose : | - | | - | Return the 16 MSB of L_var1. | - | | - | Complexity weight : 1 | - | | - | Inputs : | - | | - | L_var1 | - | 32 bit long signed integer (Word32 ) whose value falls in the | - | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | var_out | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | - |___________________________________________________________________________| -*/ -Word16 extract_h (Word32 L_var1) -{ - Word16 var_out; - - var_out = (Word16) (L_var1 >> 16); -#if (WMOPS) - multiCounter[currCounter].extract_h++; -#endif - return (var_out); -} -/* ------------------------- End of extract_h() ------------------------- */ - - -/*___________________________________________________________________________ - | | - | Function Name : extract_l | - | | - | Purpose : | - | | - | Return the 16 LSB of L_var1. | - | | - | Complexity weight : 1 | - | | - | Inputs : | - | | - | L_var1 | - | 32 bit long signed integer (Word32 ) whose value falls in the | - | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | var_out | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | - |___________________________________________________________________________| -*/ -Word16 extract_l (Word32 L_var1) -{ - Word16 var_out; - - var_out = (Word16) L_var1; -#if (WMOPS) - multiCounter[currCounter].extract_l++; -#endif - return (var_out); -} -/* ------------------------- End of extract_l() ------------------------- */ - - -/*___________________________________________________________________________ - | | - | Function Name : round | - | | - | Purpose : | - | | - | Round the lower 16 bits of the 32 bit input number into the MS 16 bits | - | with saturation. Shift the resulting bits right by 16 and return the 16 | - | bit number: | - | round(L_var1) = extract_h(L_add(L_var1,32768)) | - | | - | Complexity weight : 1 | - | | - | Inputs : | - | | - | L_var1 | - | 32 bit long signed integer (Word32 ) whose value falls in the | - | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | var_out | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | - |___________________________________________________________________________| -*/ -Word16 itu_round (Word32 L_var1) -{ - Word16 var_out; - Word32 L_rounded; - - L_rounded = L_add (L_var1, (Word32) 0x00008000L); -#if (WMOPS) - multiCounter[currCounter].L_add--; -#endif - var_out = extract_h (L_rounded); -#if (WMOPS) - multiCounter[currCounter].extract_h--; - multiCounter[currCounter].round++; -#endif - return (var_out); -} -/* ------------------------- End of round() ------------------------- */ - - -/*___________________________________________________________________________ - | | - | Function Name : L_mac | - | | - | Purpose : | - | | - | Multiply var1 by var2 and shift the result left by 1. Add the 32 bit | - | result to L_var3 with saturation, return a 32 bit result: | - | L_mac(L_var3,var1,var2) = L_add(L_var3,L_mult(var1,var2)). | - | | - | Complexity weight : 1 | - | | - | Inputs : | - | | - | L_var3 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. | - | | - | var1 | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | - | | - | var2 | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | L_var_out | - | 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. | - |___________________________________________________________________________| -*/ -Word32 L_mac (Word32 L_var3, Word16 var1, Word16 var2) -{ - Word32 L_var_out; - Word32 L_product; - - L_product = L_mult (var1, var2); -#if (WMOPS) - multiCounter[currCounter].L_mult--; -#endif - L_var_out = L_add (L_var3, L_product); -#if (WMOPS) - multiCounter[currCounter].L_add--; - multiCounter[currCounter].L_mac++; -#endif - return (L_var_out); -} -/* ------------------------- End of L_mac() ------------------------- */ - - -/*___________________________________________________________________________ - | | | Function Name : L_msu | | | | Purpose : | @@ -839,7 +300,7 @@ Word32 L_msu (Word32 L_var3, Word16 var1, Word16 var2) } /* ------------------------- End of L_msu() ------------------------- */ - +#if INCLUDE_UNSAFE /*___________________________________________________________________________ | | | Function Name : L_macNs | @@ -897,9 +358,10 @@ Word32 L_macNs (Word32 L_var3, Word16 var1, Word16 var2) #endif return (L_var_out); } +#endif /* ------------------------- End of L_macNs() ------------------------- */ - +#if INCLUDE_UNSAFE /*___________________________________________________________________________ | | | Function Name : L_msuNs | @@ -957,115 +419,12 @@ Word32 L_msuNs (Word32 L_var3, Word16 var1, Word16 var2) #endif return (L_var_out); } -/* ------------------------- End of L_msuNs() ------------------------- */ - - -/*___________________________________________________________________________ - | | - | Function Name : L_add | - | | - | Purpose : | - | | - | 32 bits addition of the two 32 bits variables (L_var1+L_var2) with | - | overflow control and saturation; the result is set at +2147483647 when | - | overflow occurs or at -2147483648 when underflow occurs. | - | | - | Complexity weight : 2 | - | | - | Inputs : | - | | - | L_var1 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. | - | | - | L_var2 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | L_var_out | - | 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. | - |___________________________________________________________________________| -*/ -Word32 L_add (Word32 L_var1, Word32 L_var2) -{ - Word32 L_var_out; - - L_var_out = L_var1 + L_var2; - - if (((L_var1 ^ L_var2) & MIN_32) == 0) - { - if ((L_var_out ^ L_var1) & MIN_32) - { - L_var_out = (L_var1 < 0) ? MIN_32 : MAX_32; - Overflow = 1; - } - } -#if (WMOPS) - multiCounter[currCounter].L_add++; #endif - return (L_var_out); -} -/* ------------------------- End of L_add() ------------------------- */ - - -/*___________________________________________________________________________ - | | - | Function Name : L_sub | - | | - | Purpose : | - | | - | 32 bits subtraction of the two 32 bits variables (L_var1-L_var2) with | - | overflow control and saturation; the result is set at +2147483647 when | - | overflow occurs or at -2147483648 when underflow occurs. | - | | - | Complexity weight : 2 | - | | - | Inputs : | - | | - | L_var1 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. | - | | - | L_var2 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | L_var_out | - | 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. | - |___________________________________________________________________________| -*/ -Word32 L_sub (Word32 L_var1, Word32 L_var2) -{ - Word32 L_var_out; - L_var_out = L_var1 - L_var2; - - if (((L_var1 ^ L_var2) & MIN_32) != 0) - { - if ((L_var_out ^ L_var1) & MIN_32) - { - L_var_out = (L_var1 < 0L) ? MIN_32 : MAX_32; - Overflow = 1; - } - } -#if (WMOPS) - multiCounter[currCounter].L_sub++; -#endif - return (L_var_out); -} -/* ------------------------- End of L_sub() ------------------------- */ +/* ------------------------- End of L_msuNs() ------------------------- */ +#if INCLUDE_UNSAFE /*___________________________________________________________________________ | | | Function Name : L_add_c | @@ -1109,13 +468,13 @@ Word32 L_add_c (Word32 L_var1, Word32 L_var2) Word32 L_test; Flag carry_int = 0; - L_var_out = L_var1 + L_var2 + Carry; + L_var_out = L_var1 + L_var2 + GET_CARRY(); L_test = L_var1 + L_var2; if ((L_var1 > 0) && (L_var2 > 0) && (L_test < 0)) { - Overflow = 1; + SET_OVERFLOW(1); carry_int = 0; } else @@ -1124,12 +483,12 @@ Word32 L_add_c (Word32 L_var1, Word32 L_var2) { if (L_test >= 0) { - Overflow = 1; + SET_OVERFLOW(1); carry_int = 1; } else { - Overflow = 0; + SET_OVERFLOW(0); carry_int = 1; } } @@ -1137,39 +496,39 @@ Word32 L_add_c (Word32 L_var1, Word32 L_var2) { if (((L_var1 ^ L_var2) < 0) && (L_test >= 0)) { - Overflow = 0; + SET_OVERFLOW(0); carry_int = 1; } else { - Overflow = 0; + SET_OVERFLOW(0); carry_int = 0; } } } - if (Carry) + if (GET_CARRY()) { if (L_test == MAX_32) { - Overflow = 1; - Carry = carry_int; + SET_OVERFLOW(1); + SET_CARRY(carry_int); } else { if (L_test == (Word32) 0xFFFFFFFFL) { - Carry = 1; + SET_CARRY(1); } else { - Carry = carry_int; + SET_CARRY(carry_int); } } } else { - Carry = carry_int; + SET_CARRY(carry_int); } #if (WMOPS) @@ -1177,9 +536,11 @@ Word32 L_add_c (Word32 L_var1, Word32 L_var2) #endif return (L_var_out); } -/* ------------------------- End of L_add_c() ------------------------- */ +#endif +/* ------------------------- End of L_add_c() ------------------------- */ +#if INCLUDE_UNSAFE /*___________________________________________________________________________ | | | Function Name : L_sub_c | @@ -1223,9 +584,9 @@ Word32 L_sub_c (Word32 L_var1, Word32 L_var2) Word32 L_test; Flag carry_int = 0; - if (Carry) + if (GET_CARRY()) { - Carry = 0; + SET_CARRY(0); if (L_var2 != MIN_32) { L_var_out = L_add_c (L_var1, -L_var2); @@ -1238,8 +599,8 @@ Word32 L_sub_c (Word32 L_var1, Word32 L_var2) L_var_out = L_var1 - L_var2; if (L_var1 > 0L) { - Overflow = 1; - Carry = 0; + SET_OVERFLOW(1); + SET_CARRY(0); } } } @@ -1250,27 +611,27 @@ Word32 L_sub_c (Word32 L_var1, Word32 L_var2) if ((L_test < 0) && (L_var1 > 0) && (L_var2 < 0)) { - Overflow = 1; + SET_OVERFLOW(1); carry_int = 0; } else if ((L_test > 0) && (L_var1 < 0) && (L_var2 > 0)) { - Overflow = 1; + SET_OVERFLOW(1); carry_int = 1; } else if ((L_test > 0) && ((L_var1 ^ L_var2) > 0)) { - Overflow = 0; + SET_OVERFLOW(0); carry_int = 1; } if (L_test == MIN_32) { - Overflow = 1; - Carry = carry_int; + SET_OVERFLOW(1); + SET_CARRY(carry_int); } else { - Carry = carry_int; + SET_CARRY(carry_int); } } @@ -1279,6 +640,7 @@ Word32 L_sub_c (Word32 L_var1, Word32 L_var2) #endif return (L_var_out); } +#endif /* ------------------------- End of L_sub_c() ------------------------- */ @@ -1378,154 +740,6 @@ Word16 mult_r (Word16 var1, Word16 var2) /* ------------------------- End of mult_r() ------------------------- */ -/*___________________________________________________________________________ - | | - | Function Name : L_shl | - | | - | Purpose : | - | | - | Arithmetically shift the 32 bit input L_var1 left var2 positions. Zero | - | fill the var2 LSB of the result. If var2 is negative, arithmetically | - | shift L_var1 right by -var2 with sign extension. Saturate the result in | - | case of underflows or overflows. | - | | - | Complexity weight : 2 | - | | - | Inputs : | - | | - | L_var1 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. | - | | - | var2 | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | L_var_out | - | 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. | - |___________________________________________________________________________| -*/ -Word32 L_shl (Word32 L_var1, Word16 var2) -{ - Word32 L_var_out; - - if (var2 <= 0) - { - if (var2 < -32) - var2 = -32; - L_var_out = L_shr (L_var1, (Word16) -var2); -#if (WMOPS) - multiCounter[currCounter].L_shr--; -#endif - } - else - { - for (; var2 > 0; var2--) - { - if (L_var1 > (Word32) 0X3fffffffL) - { - Overflow = 1; - L_var_out = MAX_32; - break; - } - else - { - if (L_var1 < (Word32) 0xc0000000L) - { - Overflow = 1; - L_var_out = MIN_32; - break; - } - } - L_var1 *= 2; - L_var_out = L_var1; - } - } -#if (WMOPS) - multiCounter[currCounter].L_shl++; -#endif - return (L_var_out); -} -/* ------------------------- End of L_shl() ------------------------- */ - - -/*___________________________________________________________________________ - | | - | Function Name : L_shr | - | | - | Purpose : | - | | - | Arithmetically shift the 32 bit input L_var1 right var2 positions with | - | sign extension. If var2 is negative, arithmetically shift L_var1 left | - | by -var2 and zero fill the -var2 LSB of the result. Saturate the result | - | in case of underflows or overflows. | - | | - | Complexity weight : 2 | - | | - | Inputs : | - | | - | L_var1 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. | - | | - | var2 | - | 16 bit short signed integer (Word16) whose value falls in the | - | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | L_var_out | - | 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. | - |___________________________________________________________________________| -*/ -Word32 L_shr (Word32 L_var1, Word16 var2) -{ - Word32 L_var_out; - - if (var2 < 0) - { - if (var2 < -32) - var2 = -32; - L_var_out = L_shl (L_var1, (Word16) -var2); -#if (WMOPS) - multiCounter[currCounter].L_shl--; -#endif - } - else - { - if (var2 >= 31) - { - L_var_out = (L_var1 < 0L) ? -1 : 0; - } - else - { - if (L_var1 < 0) - { - L_var_out = ~((~L_var1) >> var2); - } - else - { - L_var_out = L_var1 >> var2; - } - } - } -#if (WMOPS) - multiCounter[currCounter].L_shr++; -#endif - return (L_var_out); -} -/* ------------------------- End of L_shr() ------------------------- */ - /*___________________________________________________________________________ | | @@ -1930,65 +1144,6 @@ Word32 L_abs (Word32 L_var1) /*___________________________________________________________________________ | | - | Function Name : L_sat | - | | - | Purpose : | - | | - | 32 bit L_var1 is set to 2147483647 if an overflow occured or to | - | -2147483648 if an underflow occured on the most recent L_add_c, | - | L_sub_c, L_macNs or L_msuNs operations. The carry and overflow values | - | are binary values which can be tested and assigned values. | - | | - | Complexity weight : 4 | - | | - | Inputs : | - | | - | L_var1 | - | 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= var1 <= 0x7fff ffff. | - | | - | Outputs : | - | | - | none | - | | - | Return Value : | - | | - | L_var_out | - | 32 bit long signed integer (Word32) whose value falls in the | - | range : 0x8000 0000 <= var_out <= 0x7fff ffff. | - |___________________________________________________________________________| -*/ -Word32 L_sat (Word32 L_var1) -{ - Word32 L_var_out; - - L_var_out = L_var1; - - if (Overflow) - { - - if (Carry) - { - L_var_out = MIN_32; - } - else - { - L_var_out = MAX_32; - } - - Carry = 0; - Overflow = 0; - } -#if (WMOPS) - multiCounter[currCounter].L_sat++; -#endif - return (L_var_out); -} -/* ------------------------- End of L_sat() ------------------------- */ - - -/*___________________________________________________________________________ - | | | Function Name : norm_s | | | | Purpose : | @@ -2275,7 +1430,7 @@ Word32 L_mls (Word32 Lv, Word16 v) Temp = Lv & (Word32) 0x0000ffff ; Temp = Temp * (Word32) v ; - Temp = L_shr( Temp, (Word16) 15 ) ; + Temp = L_shr_nocheck( Temp, (Word16) 15 ) ; Temp = L_mac( Temp, v, extract_h(Lv) ) ; #if (WMOPS) @@ -2357,14 +1512,14 @@ Word16 div_l (Word32 L_num, Word16 den) return MAX_16 ; } else { - L_num = L_shr(L_num, (Word16)1) ; - L_den = L_shr(L_den, (Word16)1); + L_num = L_shr_nocheck(L_num, (Word16)1) ; + L_den = L_shr_nocheck(L_den, (Word16)1); #if (WMOPS) multiCounter[currCounter].L_shr-=2; #endif for(iteration=(Word16)0; iteration< (Word16)15;iteration++) { - var_out = shl( var_out, (Word16)1); - L_num = L_shl( L_num, (Word16)1); + var_out = shl_nocheck( var_out, (Word16)1); + L_num = L_shl_nocheck( L_num, (Word16)1); #if (WMOPS) multiCounter[currCounter].shl--; multiCounter[currCounter].L_shl--; @@ -2628,7 +1783,7 @@ UWord32 LU_shl (UWord32 L_var1, Word16 var2) { if (L_var1 > (UWord32) 0X7fffffffL) { - Overflow = 1; + SET_OVERFLOW(1); L_var_out = UMAX_32; break; } @@ -2636,7 +1791,7 @@ UWord32 LU_shl (UWord32 L_var1, Word16 var2) { if (L_var1 < (UWord32) 0x00000001L) { - Overflow = 1; + SET_OVERFLOW(1); L_var_out = MIN_32; break; } diff --git a/third_party/g7221/common/stl-files/basop32.h b/third_party/g7221/common/stl-files/basop32.h index 308f8d32..14da776d 100644 --- a/third_party/g7221/common/stl-files/basop32.h +++ b/third_party/g7221/common/stl-files/basop32.h @@ -33,7 +33,7 @@ extern Flag Carry; #define MIN_32 (Word32)0x80000000L #define MAX_16 (Word16)0x7fff -#define MIN_16 (Word16)0x8000 +#define MIN_16 ((Word16)0x8000) #define UMAX_32 (Word32)0xffffffffL #define UMIN_32 (Word32)0x00000000L @@ -44,31 +44,33 @@ extern Flag Carry; |___________________________________________________________________________| */ -Word16 add (Word16 var1, Word16 var2); /* Short add, 1 */ -Word16 sub (Word16 var1, Word16 var2); /* Short sub, 1 */ -Word16 abs_s (Word16 var1); /* Short abs, 1 */ +PJ_INLINE(Word16) add (Word16 var1, Word16 var2); /* Short add, 1 */ +PJ_INLINE(Word16) sub (Word16 var1, Word16 var2); /* Short sub, 1 */ +PJ_INLINE(Word16) abs_s (Word16 var1); /* Short abs, 1 */ Word16 shl (Word16 var1, Word16 var2); /* Short shift left, 1 */ +PJ_INLINE(Word16) shl_nocheck(Word16 var1, Word16 var2); Word16 shr (Word16 var1, Word16 var2); /* Short shift right, 1 */ +PJ_INLINE(Word16) shr_nocheck(Word16 var1, Word16 var2); Word16 mult (Word16 var1, Word16 var2); /* Short mult, 1 */ -Word32 L_mult (Word16 var1, Word16 var2); /* Long mult, 1 */ -Word16 negate (Word16 var1); /* Short negate, 1 */ -Word16 extract_h (Word32 L_var1); /* Extract high, 1 */ -Word16 extract_l (Word32 L_var1); /* Extract low, 1 */ -Word16 itu_round (Word32 L_var1); /* Round, 1 */ -Word32 L_mac (Word32 L_var3, Word16 var1, Word16 var2); /* Mac, 1 */ +PJ_INLINE(Word32) L_mult (Word16 var1, Word16 var2); /* Long mult, 1 */ +PJ_INLINE(Word16) negate (Word16 var1); /* Short negate, 1 */ +PJ_INLINE(Word16) extract_h (Word32 L_var1); /* Extract high, 1 */ +PJ_INLINE(Word16) extract_l (Word32 L_var1); /* Extract low, 1 */ +PJ_INLINE(Word16) itu_round (Word32 L_var1); /* Round, 1 */ +PJ_INLINE(Word32) L_mac (Word32 L_var3, Word16 var1, Word16 var2); /* Mac, 1 */ Word32 L_msu (Word32 L_var3, Word16 var1, Word16 var2); /* Msu, 1 */ Word32 L_macNs (Word32 L_var3, Word16 var1, Word16 var2); /* Mac without sat, 1 */ Word32 L_msuNs (Word32 L_var3, Word16 var1, Word16 var2); /* Msu without sat, 1 */ -Word32 L_add (Word32 L_var1, Word32 L_var2); /* Long add, 2 */ -Word32 L_sub (Word32 L_var1, Word32 L_var2); /* Long sub, 2 */ +//PJ_INLINE(Word32) L_add (Word32 L_var1, Word32 L_var2); /* Long add, 2 */ +PJ_INLINE(Word32) L_sub (Word32 L_var1, Word32 L_var2); /* Long sub, 2 */ Word32 L_add_c (Word32 L_var1, Word32 L_var2); /* Long add with c, 2 */ Word32 L_sub_c (Word32 L_var1, Word32 L_var2); /* Long sub with c, 2 */ Word32 L_negate (Word32 L_var1); /* Long negate, 2 */ Word16 mult_r (Word16 var1, Word16 var2); /* Mult with round, 2 */ -Word32 L_shl (Word32 L_var1, Word16 var2); /* Long shift left, 2 */ -Word32 L_shr (Word32 L_var1, Word16 var2); /* Long shift right, 2*/ +PJ_INLINE(Word32) L_shl (Word32 L_var1, Word16 var2); /* Long shift left, 2 */ +PJ_INLINE(Word32) L_shr (Word32 L_var1, Word16 var2); /* Long shift right, 2*/ Word16 shr_r (Word16 var1, Word16 var2); /* Shift right with round, 2 */ Word16 mac_r (Word32 L_var3, Word16 var1, Word16 var2); /* Mac with @@ -105,6 +107,29 @@ Word32 L_msu0(Word32 L_v3, Word16 v1, Word16 v2); /* 32-bit Msu w/o shift 1 */ */ UWord32 LU_shl (UWord32 L_var1, Word16 var2); UWord32 LU_shr (UWord32 L_var1, Word16 var2); + +#define INCLUDE_UNSAFE 0 + +/* Local */ +PJ_INLINE(Word16) saturate (Word32 L_var1); + +#if INCLUDE_UNSAFE + extern Flag g7221_Overflow; + extern Flag g7221_Carry; +# define SET_OVERFLOW(n) g7221_Overflow = n +# define SET_CARRY(n) g7221_Carry = n + +#else +# define SET_OVERFLOW(n) +# define SET_CARRY(n) +# define GET_OVERFLOW() 0 +# define GET_CARRY() 0 +#endif + +#include "basop32_i.h" + + + #endif /* BASOP_H_DEFINED */ diff --git a/third_party/g7221/common/stl-files/basop32_i.h b/third_party/g7221/common/stl-files/basop32_i.h new file mode 100644 index 00000000..ca61ed0b --- /dev/null +++ b/third_party/g7221/common/stl-files/basop32_i.h @@ -0,0 +1,730 @@ +/*___________________________________________________________________________ + | | + | Function Name : extract_h | + | | + | Purpose : | + | | + | Return the 16 MSB of L_var1. | + | | + | Complexity weight : 1 | + | | + | Inputs : | + | | + | L_var1 | + | 32 bit long signed integer (Word32 ) whose value falls in the | + | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. | + | | + | Outputs : | + | | + | none | + | | + | Return Value : | + | | + | var_out | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | + |___________________________________________________________________________| +*/ +PJ_INLINE(Word16) extract_h (Word32 L_var1) +{ + return (Word16) (L_var1 >> 16); +} +/* ------------------------- End of extract_h() ------------------------- */ + + +/*___________________________________________________________________________ + | | + | Function Name : extract_l | + | | + | Purpose : | + | | + | Return the 16 LSB of L_var1. | + | | + | Complexity weight : 1 | + | | + | Inputs : | + | | + | L_var1 | + | 32 bit long signed integer (Word32 ) whose value falls in the | + | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. | + | | + | Outputs : | + | | + | none | + | | + | Return Value : | + | | + | var_out | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | + |___________________________________________________________________________| +*/ +PJ_INLINE(Word16) extract_l (Word32 L_var1) +{ + return (Word16) L_var1; +} + +/* ------------------------- End of extract_l() ------------------------- */ + + +/*___________________________________________________________________________ + | | + | Function Name : saturate | + | | + | Purpose : | + | | + | Limit the 32 bit input to the range of a 16 bit word. | + | | + | Inputs : | + | | + | L_var1 | + | 32 bit long signed integer (Word32) whose value falls in the | + | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. | + | | + | Outputs : | + | | + | none | + | | + | Return Value : | + | | + | var_out | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | + |___________________________________________________________________________| +*/ +PJ_INLINE(Word16) saturate (Word32 L_var1) +{ + Word16 val16 = (Word16) L_var1; + + if (val16 == L_var1) + return val16; + + if (val16 > MAX_16) + return MAX_16; + return MIN_16; +} +/* ------------------------- End of saturate() ------------------------- */ + + +#if PJ_HAS_INT64 +PJ_INLINE(Word32) L_saturate (pj_int64_t LL_var1) +{ + pj_int32_t L_var1 = (pj_int32_t)LL_var1; + if (LL_var1 == L_var1) + return L_var1; + else if (LL_var1 > MAX_32) + return MAX_32; + else + return MIN_32; +} +#endif + + +/*___________________________________________________________________________ + | | + | Function Name : add | + | | + | Purpose : | + | | + | Performs the addition (var1+var2) with overflow control and saturation;| + | the 16 bit result is set at +32767 when overflow occurs or at -32768 | + | when underflow occurs. | + | | + | Complexity weight : 1 | + | | + | Inputs : | + | | + | var1 | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | + | | + | var2 | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | + | | + | Outputs : | + | | + | none | + | | + | Return Value : | + | | + | var_out | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | + |___________________________________________________________________________| +*/ +PJ_INLINE(Word16) add (Word16 var1, Word16 var2) +{ + return saturate (var1 + var2); +} +/* ------------------------- End of add() ------------------------- */ + + +/*___________________________________________________________________________ + | | + | Function Name : sub | + | | + | Purpose : | + | | + | Performs the subtraction (var1+var2) with overflow control and satu- | + | ration; the 16 bit result is set at +32767 when overflow occurs or at | + | -32768 when underflow occurs. | + | | + | Complexity weight : 1 | + | | + | Inputs : | + | | + | var1 | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | + | | + | var2 | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | + | | + | Outputs : | + | | + | none | + | | + | Return Value : | + | | + | var_out | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | + |___________________________________________________________________________| +*/ +PJ_INLINE(Word16) sub (Word16 var1, Word16 var2) +{ + return saturate ((Word32) var1 - var2); +} +/* ------------------------- End of sub() ------------------------- */ + + +/*___________________________________________________________________________ + | | + | Function Name : negate | + | | + | Purpose : | + | | + | Negate var1 with saturation, saturate in the case where input is -32768:| + | negate(var1) = sub(0,var1). | + | | + | Complexity weight : 1 | + | | + | Inputs : | + | | + | var1 | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | + | | + | Outputs : | + | | + | none | + | | + | Return Value : | + | | + | var_out | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | + |___________________________________________________________________________| +*/ +PJ_INLINE(Word16) negate (Word16 var1) +{ + return (Word16)((var1 == MIN_16) ? MAX_16 : -var1); +} +/* ------------------------- End of negate() ------------------------- */ + + + + +/*___________________________________________________________________________ + | | + | Function Name : L_add | + | | + | Purpose : | + | | + | 32 bits addition of the two 32 bits variables (L_var1+L_var2) with | + | overflow control and saturation; the result is set at +2147483647 when | + | overflow occurs or at -2147483648 when underflow occurs. | + | | + | Complexity weight : 2 | + | | + | Inputs : | + | | + | L_var1 32 bit long signed integer (Word32) whose value falls in the | + | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. | + | | + | L_var2 32 bit long signed integer (Word32) whose value falls in the | + | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. | + | | + | Outputs : | + | | + | none | + | | + | Return Value : | + | | + | L_var_out | + | 32 bit long signed integer (Word32) whose value falls in the | + | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. | + |___________________________________________________________________________| +*/ +PJ_INLINE(Word32) L_add (Word32 L_var1, Word32 L_var2) +{ +#if PJ_HAS_INT64 + return L_saturate(((pj_int64_t)L_var1) + L_var2); +#else + Word32 L_var_out; + + L_var_out = L_var1 + L_var2; + + if (((L_var1 ^ L_var2) & MIN_32) == 0) + { + if ((L_var_out ^ L_var1) & MIN_32) + { + SET_OVERFLOW(1); + L_var_out = (L_var1 < 0) ? MIN_32 : MAX_32; + } + } + return (L_var_out); +#endif +} + +/* ------------------------- End of L_add() ------------------------- */ + + + + +/*___________________________________________________________________________ + | | + | Function Name : L_sub | + | | + | Purpose : | + | | + | 32 bits subtraction of the two 32 bits variables (L_var1-L_var2) with | + | overflow control and saturation; the result is set at +2147483647 when | + | overflow occurs or at -2147483648 when underflow occurs. | + | | + | Complexity weight : 2 | + | | + | Inputs : | + | | + | L_var1 32 bit long signed integer (Word32) whose value falls in the | + | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. | + | | + | L_var2 32 bit long signed integer (Word32) whose value falls in the | + | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. | + | | + | Outputs : | + | | + | none | + | | + | Return Value : | + | | + | L_var_out | + | 32 bit long signed integer (Word32) whose value falls in the | + | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. | + |___________________________________________________________________________| +*/ +PJ_INLINE(Word32) L_sub (Word32 L_var1, Word32 L_var2) +{ +#if PJ_HAS_INT64 + return L_saturate((pj_int64_t)L_var1 - L_var2); +#else + Word32 L_var_out; + + L_var_out = L_var1 - L_var2; + + if (((L_var1 ^ L_var2) & MIN_32) != 0) + { + if ((L_var_out ^ L_var1) & MIN_32) + { + L_var_out = (L_var1 < 0L) ? MIN_32 : MAX_32; + SET_OVERFLOW(1); + } + } + return (L_var_out); +#endif +} +/* ------------------------- End of L_sub() ------------------------- */ + +/*___________________________________________________________________________ + | | + | Function Name : L_mult | + | | + | Purpose : | + | | + | L_mult is the 32 bit result of the multiplication of var1 times var2 | + | with one shift left i.e.: | + | L_mult(var1,var2) = L_shl((var1 times var2),1) and | + | L_mult(-32768,-32768) = 2147483647. | + | | + | Complexity weight : 1 | + | | + | Inputs : | + | | + | var1 | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | + | | + | var2 | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | + | | + | Outputs : | + | | + | none | + | | + | Return Value : | + | | + | L_var_out | + | 32 bit long signed integer (Word32) whose value falls in the | + | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. | + |___________________________________________________________________________| +*/ +PJ_INLINE(Word32) L_mult (Word16 var1, Word16 var2) +{ + Word32 L_var_out; + + L_var_out = (Word32) var1 *(Word32) var2; + + if (L_var_out != (Word32) 0x40000000L) + { + return L_var_out << 1; + } + else + { + SET_OVERFLOW(1); + return MAX_32; + } +} +/* ------------------------- End of L_mult() ------------------------- */ + + +/*___________________________________________________________________________ + | | + | Function Name : L_mac | + | | + | Purpose : | + | | + | Multiply var1 by var2 and shift the result left by 1. Add the 32 bit | + | result to L_var3 with saturation, return a 32 bit result: | + | L_mac(L_var3,var1,var2) = L_add(L_var3,L_mult(var1,var2)). | + | | + | Complexity weight : 1 | + | | + | Inputs : | + | | + | L_var3 32 bit long signed integer (Word32) whose value falls in the | + | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. | + | | + | var1 | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | + | | + | var2 | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | + | | + | Outputs : | + | | + | none | + | | + | Return Value : | + | | + | L_var_out | + | 32 bit long signed integer (Word32) whose value falls in the | + | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. | + |___________________________________________________________________________| +*/ +PJ_INLINE(Word32) L_mac (Word32 L_var3, Word16 var1, Word16 var2) +{ + return L_add (L_var3, L_mult (var1, var2)); +} +/* ------------------------- End of L_mac() ------------------------- */ + + +/*___________________________________________________________________________ + | | + | Function Name : round | + | | + | Purpose : | + | | + | Round the lower 16 bits of the 32 bit input number into the MS 16 bits | + | with saturation. Shift the resulting bits right by 16 and return the 16 | + | bit number: | + | round(L_var1) = extract_h(L_add(L_var1,32768)) | + | | + | Complexity weight : 1 | + | | + | Inputs : | + | | + | L_var1 | + | 32 bit long signed integer (Word32 ) whose value falls in the | + | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. | + | | + | Outputs : | + | | + | none | + | | + | Return Value : | + | | + | var_out | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var_out <= 0x0000 7fff. | + |___________________________________________________________________________| +*/ +PJ_INLINE(Word16) itu_round (Word32 L_var1) +{ + return extract_h (L_add (L_var1, (Word32) 0x00008000L)); +} +/* ------------------------- End of round() ------------------------- */ + + +/*___________________________________________________________________________ + | | + | Function Name : L_shr | + | | + | Purpose : | + | | + | Arithmetically shift the 32 bit input L_var1 right var2 positions with | + | sign extension. If var2 is negative, arithmetically shift L_var1 left | + | by -var2 and zero fill the -var2 LSB of the result. Saturate the result | + | in case of underflows or overflows. | + | | + | Complexity weight : 2 | + | | + | Inputs : | + | | + | L_var1 32 bit long signed integer (Word32) whose value falls in the | + | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. | + | | + | var2 | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | + | | + | Outputs : | + | | + | none | + | | + | Return Value : | + | | + | L_var_out | + | 32 bit long signed integer (Word32) whose value falls in the | + | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. | + |___________________________________________________________________________| +*/ +PJ_INLINE(Word32) L_shr_nocheck(Word32 L_var1, Word16 var2) +{ +#if 1 + return L_var1 >> var2; +#else + if (var2 >= 31) + { + return (L_var1 < 0L) ? -1 : 0; + } + else + { + if (L_var1 < 0) + { + return ~((~L_var1) >> var2); + } + else + { + return L_var1 >> var2; + } + } +#endif +} + +PJ_INLINE(Word32) L_shl_nocheck (Word32 L_var1, Word16 var2) +{ +#if PJ_HAS_INT64 + return L_saturate( ((pj_int64_t)L_var1) << var2 ); +#else + for (; var2 > 0; var2--) + { + if (L_var1 > (Word32) 0X3fffffffL) + { + SET_OVERFLOW(1); + return MAX_32; + } + else + { + if (L_var1 < (Word32) 0xc0000000L) + { + SET_OVERFLOW(1); + return MIN_32; + } + } + L_var1 <<= 1; + } + return (L_var1); +#endif +} + +PJ_INLINE(Word32) L_shr (Word32 L_var1, Word16 var2) +{ + if (var2 < 0) + { + if (var2 < -32) + var2 = -32; + return L_shl_nocheck (L_var1, (Word16) -var2); + } + else + { + return L_shr_nocheck(L_var1, var2); + } +} +/* ------------------------- End of L_shr() ------------------------- */ + +/*___________________________________________________________________________ + | | + | Function Name : L_shl | + | | + | Purpose : | + | | + | Arithmetically shift the 32 bit input L_var1 left var2 positions. Zero | + | fill the var2 LSB of the result. If var2 is negative, arithmetically | + | shift L_var1 right by -var2 with sign extension. Saturate the result in | + | case of underflows or overflows. | + | | + | Complexity weight : 2 | + | | + | Inputs : | + | | + | L_var1 32 bit long signed integer (Word32) whose value falls in the | + | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. | + | | + | var2 | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | + | | + | Outputs : | + | | + | none | + | | + | Return Value : | + | | + | L_var_out | + | 32 bit long signed integer (Word32) whose value falls in the | + | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. | + |___________________________________________________________________________| +*/ +PJ_INLINE(Word32) L_shl (Word32 L_var1, Word16 var2) +{ + if (var2 <= 0) + { + if (var2 < -32) + var2 = -32; + return L_shr_nocheck(L_var1, (Word16) -var2); + } + else + { + return L_shl_nocheck(L_var1, var2); + } +} +/* ------------------------- End of L_shl() ------------------------- */ + + +/*___________________________________________________________________________ + | | + | Function Name : abs_s | + | | + | Purpose : | + | | + | Absolute value of var1; abs_s(-32768) = 32767. | + | | + | Complexity weight : 1 | + | | + | Inputs : | + | | + | var1 | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0xffff 8000 <= var1 <= 0x0000 7fff. | + | | + | Outputs : | + | | + | none | + | | + | Return Value : | + | | + | var_out | + | 16 bit short signed integer (Word16) whose value falls in the | + | range : 0x0000 0000 <= var_out <= 0x0000 7fff. | + |___________________________________________________________________________| +*/ +PJ_INLINE(Word16) abs_s (Word16 var1) +{ +#if 1 + if (var1 >= 0) + return var1; + else if (var1 == (Word16)0x8000) + return MAX_16; + else + return (Word16)-var1; +#else + if (var1 == (Word16) 0x8000) + { + return MAX_16; + } + else + { + if (var1 < 0) + { + return (Word16)-var1; + } + else + { + return var1; + } + } +#endif +} +/* ------------------------- End of abs_s() ------------------------- */ + + +PJ_INLINE(Word16) shl_nocheck(Word16 var1, Word16 var2) +{ +#if 1 + /* blp: this should be more optimized */ + return saturate (((Word32)var1) << var2); +#else + /* Original algorithm */ + Word32 result = (Word32) var1 *((Word32) 1 << var2); + + if ((var2 > 15 && var1 != 0) || (result != (Word32) ((Word16) result))) + { + SET_OVERFLOW(1); + return (Word16) ((var1 > 0) ? MAX_16 : MIN_16); + } + else + { + return extract_l (result); + } +#endif +} + +PJ_INLINE(Word16) shr_nocheck(Word16 var1, Word16 var2) +{ +#if 1 + /* blp: this should yield the same value */ + return (Word16) (var1 >> var2); +#else + /* Original algorithm */ + if (var2 >= 15) + { + return (Word16)((var1 < 0) ? -1 : 0); + } + else + { + if (var1 < 0) + { + return (Word16) (~((~var1) >> var2)); + } + else + { + return (Word16)(var1 >> var2); + } + } +#endif +} diff --git a/third_party/g7221/common/stl-files/count.c b/third_party/g7221/common/stl-files/count.c deleted file mode 100644 index 17ce4b32..00000000 --- a/third_party/g7221/common/stl-files/count.c +++ /dev/null @@ -1,303 +0,0 @@ -/* - *************************************************************************** - * - * This file contains functions for the automatic complexity calculation - * $Id $ - *************************************************************************** -*/ - -#include <stdlib.h> -#include <stdio.h> -#include <string.h> -#include "typedef.h" -#include "count.h" - -/* Global counter variable for calculation of complexity weight */ - -BASIC_OP multiCounter[MAXCOUNTERS]; -int currCounter=0; /* Zero equals global counter */ - -/*BASIC_OP counter;*/ -const BASIC_OP op_weight = -{ - /* G.729 & G.723.1 common operators */ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 3, 3, 3, 4, 15, 18, 30, 1, 2, 1, 2, 2, - /* G.723.1 exclusives */ - 6, 1, 1, - /* shiftless 32-bit operators */ - 1, 1, 1, - /* G.722.1 exclusives */ - 1, 1 -}; - -/* function prototypes */ -Word32 TotalWeightedOperation (void); -Word32 DeltaWeightedOperation (void); - -/* local variable */ -#if WMOPS - -/* Counters for separating counting for different objects */ -static int maxCounter=0; -static char* objectName[MAXCOUNTERS+1]; -static Word16 fwc_corr[MAXCOUNTERS+1]; - -#define NbFuncMax 1024 - -static Word16 funcid[MAXCOUNTERS], nbframe[MAXCOUNTERS]; -static Word32 glob_wc[MAXCOUNTERS], wc[MAXCOUNTERS][NbFuncMax]; -static float total_wmops[MAXCOUNTERS]; - -static Word32 LastWOper[MAXCOUNTERS]; - -static char* my_strdup(const char *s) -/* - * duplicates UNIX function strdup() which is not ANSI standard: - * -- malloc() memory area big enough to hold the string s - * -- copy string into new area - * -- return pointer to new area - * - * returns NULL if either s==NULL or malloc() fails - */ -{ - char *dup; - - if (s == NULL) - return NULL; - - /* allocate memory for copy of ID string (including string terminator) */ - /* NOTE: the ID strings will never be deallocated because there is no - way to "destroy" a counter that is not longer needed */ - if ((dup = (char *) malloc(strlen(s)+1)) == NULL) - return NULL; - - return strcpy(dup, s); -} - -#endif - -int getCounterId(char *objectNameArg) -{ -#if WMOPS - if(maxCounter>=MAXCOUNTERS-1) return 0; - objectName[++maxCounter]=my_strdup(objectNameArg); - return maxCounter; -#else - return 0; /* Dummy */ -#endif -} - -void setCounter(int counterId) -{ -#if WMOPS - if(counterId>maxCounter || counterId<0) - { - currCounter=0; - return; - } - currCounter=counterId; -#endif -} - -#if WMOPS -static Word32 WMOPS_frameStat() -/* calculate the WMOPS seen so far and update the global - per-frame maximum (glob_wc) - */ -{ - Word32 tot; - - tot = TotalWeightedOperation (); - if (tot > glob_wc[currCounter]) - glob_wc[currCounter] = tot; - - /* check if fwc() was forgotten at end of last frame */ - if (tot > LastWOper[currCounter]) { - if (!fwc_corr[currCounter]) { - fprintf(stderr, - "count: operations counted after last fwc() for '%s'; " - "-> fwc() called\n", - objectName[currCounter]?objectName[currCounter]:""); - } - fwc(); - } - - return tot; -} - -static void WMOPS_clearMultiCounter() -{ - Word16 i; - - Word32 *ptr = (Word32 *) &multiCounter[currCounter]; - for (i = 0; i < (sizeof (multiCounter[currCounter])/ sizeof (Word32)); i++) - { - *ptr++ = 0; - } -} -#endif - -Word32 TotalWeightedOperation () -{ -#if WMOPS - Word16 i; - Word32 tot, *ptr, *ptr2; - - tot = 0; - ptr = (Word32 *) &multiCounter[currCounter]; - ptr2 = (Word32 *) &op_weight; - for (i = 0; i < (sizeof (multiCounter[currCounter])/ sizeof (Word32)); i++) - { - tot += ((*ptr++) * (*ptr2++)); - } - - return ((Word32) tot); -#else - return 0; /* Dummy */ -#endif -} - -Word32 DeltaWeightedOperation () -{ -#if WMOPS - Word32 NewWOper, delta; - - NewWOper = TotalWeightedOperation (); - delta = NewWOper - LastWOper[currCounter]; - LastWOper[currCounter] = NewWOper; - return (delta); -#else - return 0; /* Dummy */ -#endif -} - -void move16 (void) -{ -#if WMOPS - multiCounter[currCounter].DataMove16++; -#endif -} - -void move32 (void) -{ -#if WMOPS - multiCounter[currCounter].DataMove32++; -#endif -} - -void test (void) -{ -#if WMOPS - multiCounter[currCounter].Test++; -#endif -} - -void logic16 (void) -{ -#if WMOPS - multiCounter[currCounter].Logic16++; -#endif -} - -void logic32 (void) -{ -#if WMOPS - multiCounter[currCounter].Logic32++; -#endif -} - -void Init_WMOPS_counter (void) -{ -#if WMOPS - Word16 i; - - /* reset function weight operation counter variable */ - - for (i = 0; i < NbFuncMax; i++) - wc[currCounter][i] = (Word32) 0; - glob_wc[currCounter] = 0; - nbframe[currCounter] = 0; - total_wmops[currCounter] = 0.0; - - /* initially clear all counters */ - WMOPS_clearMultiCounter(); - LastWOper[currCounter] = 0; - funcid[currCounter] = 0; -#endif -} - - -void Reset_WMOPS_counter (void) -{ -#if WMOPS - Word32 tot = WMOPS_frameStat(); - - /* increase the frame counter --> a frame is counted WHEN IT BEGINS */ - nbframe[currCounter]++; - /* add wmops used in last frame to count, then reset counter */ - /* (in first frame, this is a no-op */ - total_wmops[currCounter] += ((float) tot) * 0.00005; - - /* clear counter before new frame starts */ - WMOPS_clearMultiCounter(); - LastWOper[currCounter] = 0; - funcid[currCounter] = 0; /* new frame, set function id to zero */ -#endif -} - -Word32 fwc (void) /* function worst case */ -{ -#if WMOPS - Word32 tot; - - tot = DeltaWeightedOperation (); - if (tot > wc[currCounter][funcid[currCounter]]) - wc[currCounter][funcid[currCounter]] = tot; - - funcid[currCounter]++; - - return (tot); -#else - return 0; /* Dummy */ -#endif -} - -void WMOPS_output (Word16 dtx_mode) -{ -#if WMOPS - Word16 i; - Word32 tot, tot_wm, tot_wc; - - /* get operations since last reset (or init), - but do not update the counters (except the glob_wc[] maximum) - so output CAN be called in each frame without problems. - The frame counter is NOT updated! - */ - tot = WMOPS_frameStat(); - tot_wm = total_wmops[currCounter] + ((float) tot) * 0.00005; - - fprintf (stdout, "%10s:WMOPS=%.3f", - objectName[currCounter]?objectName[currCounter]:"", - ((float) tot) * 0.00005); - - if (nbframe[currCounter] != 0) - fprintf (stdout, " Average=%.3f", - tot_wm / (float) nbframe[currCounter]); - - fprintf (stdout, " WorstCase=%.3f", - ((float) glob_wc[currCounter]) * 0.00005); - - /* Worst worst case printed only when not in DTX mode */ - if (dtx_mode == 0) - { - tot_wc = 0L; - for (i = 0; i < funcid[currCounter]; i++) - tot_wc += wc[currCounter][i]; - fprintf (stdout, " WorstWC=%.3f", ((float) tot_wc) * 0.00005); - } - fprintf (stdout, " (%d frames)\n", nbframe[currCounter]); - -#endif -} diff --git a/third_party/g7221/common/stl-files/count.h b/third_party/g7221/common/stl-files/count.h index 5f2227ef..34c04610 100644 --- a/third_party/g7221/common/stl-files/count.h +++ b/third_party/g7221/common/stl-files/count.h @@ -35,6 +35,7 @@ operators L_mult0(), L_mac0(), L_msu0() =========================================================================== */ +#if 0 #ifndef COUNT_H #define COUNT_H "$Id $" @@ -71,7 +72,23 @@ void WMOPS_output (Word16 notPrintWorstWorstCase); * */ -Word32 fwc (void); +PJ_INLINE(Word32) fwc (void) +{ +#if WMOPS + Word32 tot; + + tot = DeltaWeightedOperation (); + if (tot > wc[currCounter][funcid[currCounter]]) + wc[currCounter][funcid[currCounter]] = tot; + + funcid[currCounter]++; + + return (tot); +#else + return 0; /* Dummy */ +#endif +} + /* * worst worst case counter. * @@ -82,12 +99,42 @@ Word32 fwc (void); * * The WMOPS_output function add together all parts and presents the sum. */ +PJ_INLINE(void) move16 (void) +{ +#if WMOPS + multiCounter[currCounter].DataMove16++; +#endif +} + +PJ_INLINE(void) move32 (void) +{ +#if WMOPS + multiCounter[currCounter].DataMove32++; +#endif +} + +PJ_INLINE(void )logic16 (void) +{ +#if WMOPS + multiCounter[currCounter].Logic16++; +#endif +} + +PJ_INLINE(void) logic32 (void) +{ +#if WMOPS + multiCounter[currCounter].Logic32++; +#endif +} + +PJ_INLINE(void) test (void) +{ +#if WMOPS + multiCounter[currCounter].Test++; +#endif +} + -void move16 (void); -void move32 (void); -void logic16 (void); -void logic32 (void); -void test (void); /* * The functions above increases the corresponding operation counter for * the current counter group. @@ -205,3 +252,12 @@ int main() #endif /* Example */ #endif /* COUNT_H */ +#else + +#define move16() +#define move32() +#define logic16() +#define logic32() +#define test() + +#endif |