More ticket #774: optimization for siren7/siren14 codecs
git-svn-id: https://svn.pjsip.org/repos/pjproject/trunk@2616 74dad513-b988-da41-8d7b-12977e46ad98
diff --git a/third_party/g7221/common/common.c b/third_party/g7221/common/common.c
index 66e32ad..94bcf79 100644
--- a/third_party/g7221/common/common.c
+++ b/third_party/g7221/common/common.c
@@ -94,7 +94,7 @@
{
number_of_available_bits = sub(number_of_available_bits,frame_size);
number_of_available_bits = extract_l(L_mult0(number_of_available_bits,5));
- number_of_available_bits = shr(number_of_available_bits,3);
+ number_of_available_bits = shr_nocheck(number_of_available_bits,3);
number_of_available_bits = add(number_of_available_bits,frame_size);
}
@@ -207,7 +207,7 @@
for (j=0; j<num_categorization_control_possibilities-1; j++)
{
min_plus_max = add(max,min);
- two_x_number_of_available_bits = shl(number_of_available_bits,1);
+ two_x_number_of_available_bits = shl_nocheck(number_of_available_bits,1);
temp = sub(min_plus_max,two_x_number_of_available_bits);
test();
@@ -222,7 +222,7 @@
test();
if (max_rate_categories[region] > 0)
{
- itemp0 = shl(max_rate_categories[region],1);
+ itemp0 = shl_nocheck(max_rate_categories[region],1);
itemp1 = sub(offset,rms_index[region]);
itemp0 = sub(itemp1,itemp0);
@@ -258,7 +258,7 @@
test();
if (temp < 0)
{
- itemp0 = shl(min_rate_categories[region],1);
+ itemp0 = shl_nocheck(min_rate_categories[region],1);
itemp1 = sub(offset,rms_index[region]);
itemp0 = sub(itemp1,itemp0);
@@ -356,7 +356,7 @@
for (region=0; region<number_of_regions; region++)
{
j = sub(test_offset,rms_index[region]);
- j = shr(j,1);
+ j = shr_nocheck(j,1);
/* Ensure j is between 0 and NUM_CAT-1 */
test();
@@ -391,7 +391,7 @@
answer = test_offset;
move16();
}
- delta = shr(delta,1);
+ delta = shr_nocheck(delta,1);
test(); /* for the while loop */
} while (delta > 0);
@@ -440,7 +440,7 @@
for (region=0; region<number_of_regions; region++)
{
j = sub(offset,rms_index[region]);
- j = shr(j,1);
+ j = shr_nocheck(j,1);
/* make sure j is between 0 and NUM_CAT-1 */
test();
diff --git a/third_party/g7221/common/stl-files/basop32.c b/third_party/g7221/common/stl-files/basop32.c
index 9eb4f38..efd5c20 100644
--- a/third_party/g7221/common/stl-files/basop32.c
+++ b/third_party/g7221/common/stl-files/basop32.c
@@ -79,86 +79,29 @@
/*___________________________________________________________________________
| |
- | Local Functions |
- |___________________________________________________________________________|
-*/
-Word16 saturate (Word32 L_var1);
-
-/*___________________________________________________________________________
- | |
| Constants and Globals |
|___________________________________________________________________________|
*/
-Flag Overflow = 0;
-Flag Carry = 0;
+#if INCLUDE_UNSAFE
+Flag g7221_Overflow = 0;
+Flag g7221_Carry = 0;
+#endif
/*___________________________________________________________________________
| |
| Functions |
|___________________________________________________________________________|
*/
-
/*___________________________________________________________________________
| |
- | Function Name : saturate |
+ | Function Name : shr |
| |
| 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--;
-#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. |
+ | 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 |
| |
@@ -183,121 +126,20 @@
| range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
|___________________________________________________________________________|
*/
-Word16 add (Word16 var1, Word16 var2)
+Word16 shr (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 |
- | |
- | 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. |
- |___________________________________________________________________________|
-*/
-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 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 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 @@
/*___________________________________________________________________________
| |
- | 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 @@
}
/* ------------------------- End of L_msu() ------------------------- */
-
+#if INCLUDE_UNSAFE
/*___________________________________________________________________________
| |
| Function Name : L_macNs |
@@ -897,9 +358,10 @@
#endif
return (L_var_out);
}
+#endif
/* ------------------------- End of L_macNs() ------------------------- */
-
+#if INCLUDE_UNSAFE
/*___________________________________________________________________________
| |
| Function Name : L_msuNs |
@@ -957,115 +419,12 @@
#endif
return (L_var_out);
}
+#endif
+
/* ------------------------- 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() ------------------------- */
-
-
+#if INCLUDE_UNSAFE
/*___________________________________________________________________________
| |
| Function Name : L_add_c |
@@ -1109,13 +468,13 @@
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 @@
{
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 @@
{
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 @@
#endif
return (L_var_out);
}
+#endif
+
/* ------------------------- End of L_add_c() ------------------------- */
-
+#if INCLUDE_UNSAFE
/*___________________________________________________________________________
| |
| Function Name : L_sub_c |
@@ -1223,9 +584,9 @@
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 @@
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 @@
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 @@
#endif
return (L_var_out);
}
+#endif
/* ------------------------- End of L_sub_c() ------------------------- */
@@ -1378,154 +740,6 @@
/* ------------------------- 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 @@
/*___________________________________________________________________________
| |
- | 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 @@
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 @@
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 @@
{
if (L_var1 > (UWord32) 0X7fffffffL)
{
- Overflow = 1;
+ SET_OVERFLOW(1);
L_var_out = UMAX_32;
break;
}
@@ -2636,7 +1791,7 @@
{
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 308f8d3..14da776 100644
--- a/third_party/g7221/common/stl-files/basop32.h
+++ b/third_party/g7221/common/stl-files/basop32.h
@@ -33,7 +33,7 @@
#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 @@
|___________________________________________________________________________|
*/
-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 @@
*/
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 0000000..ca61ed0
--- /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 17ce4b3..0000000
--- 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 5f2227e..34c0461 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 @@
*
*/
-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 @@
*
* The WMOPS_output function add together all parts and presents the sum.
*/
+PJ_INLINE(void) move16 (void)
+{
+#if WMOPS
+ multiCounter[currCounter].DataMove16++;
+#endif
+}
-void move16 (void);
-void move32 (void);
-void logic16 (void);
-void logic32 (void);
-void test (void);
+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
+}
+
+
/*
* The functions above increases the corresponding operation counter for
* the current counter group.
@@ -205,3 +252,12 @@
#endif /* Example */
#endif /* COUNT_H */
+#else
+
+#define move16()
+#define move32()
+#define logic16()
+#define logic32()
+#define test()
+
+#endif