diff options
Diffstat (limited to 'third_party/g7221/common/basic_op_i.h')
| -rw-r--r-- | third_party/g7221/common/basic_op_i.h | 730 |
1 files changed, 730 insertions, 0 deletions
diff --git a/third_party/g7221/common/basic_op_i.h b/third_party/g7221/common/basic_op_i.h new file mode 100644 index 00000000..8eba815e --- /dev/null +++ b/third_party/g7221/common/basic_op_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 == MIN_16) + return MAX_16; + else + return (Word16)-var1; +#else + if (var1 == MIN_16) + { + 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 +} |