/*___________________________________________________________________________ | | | 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 (L_var1 > 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 }