1 /* 2 * The copyright in this software is being made available under the 2-clauses 3 * BSD License, included below. This software may be subject to other third 4 * party and contributor rights, including patent rights, and no such rights 5 * are granted under this license. 6 * 7 * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium 8 * Copyright (c) 2002-2014, Professor Benoit Macq 9 * Copyright (c) 2001-2003, David Janssens 10 * Copyright (c) 2002-2003, Yannick Verschueren 11 * Copyright (c) 2003-2007, Francois-Olivier Devaux 12 * Copyright (c) 2003-2014, Antonin Descampe 13 * Copyright (c) 2005, Herve Drolon, FreeImage Team 14 * All rights reserved. 15 * 16 * Redistribution and use in source and binary forms, with or without 17 * modification, are permitted provided that the following conditions 18 * are met: 19 * 1. Redistributions of source code must retain the above copyright 20 * notice, this list of conditions and the following disclaimer. 21 * 2. Redistributions in binary form must reproduce the above copyright 22 * notice, this list of conditions and the following disclaimer in the 23 * documentation and/or other materials provided with the distribution. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' 26 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 29 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 * POSSIBILITY OF SUCH DAMAGE. 36 */ 37 #ifndef OPJ_INTMATH_H 38 #define OPJ_INTMATH_H 39 /** 40 @file opj_intmath.h 41 @brief Implementation of operations on integers (INT) 42 43 The functions in OPJ_INTMATH.H have for goal to realize operations on integers. 44 */ 45 46 /** @defgroup OPJ_INTMATH OPJ_INTMATH - Implementation of operations on integers */ 47 /*@{*/ 48 49 /** @name Exported functions (see also openjpeg.h) */ 50 /*@{*/ 51 /* ----------------------------------------------------------------------- */ 52 /** 53 Get the minimum of two integers 54 @return Returns a if a < b else b 55 */ 56 static INLINE OPJ_INT32 opj_int_min(OPJ_INT32 a, OPJ_INT32 b) 57 { 58 return a < b ? a : b; 59 } 60 61 /** 62 Get the minimum of two integers 63 @return Returns a if a < b else b 64 */ 65 static INLINE OPJ_UINT32 opj_uint_min(OPJ_UINT32 a, OPJ_UINT32 b) 66 { 67 return a < b ? a : b; 68 } 69 70 /** 71 Get the maximum of two integers 72 @return Returns a if a > b else b 73 */ 74 static INLINE OPJ_INT32 opj_int_max(OPJ_INT32 a, OPJ_INT32 b) 75 { 76 return (a > b) ? a : b; 77 } 78 79 /** 80 Get the maximum of two integers 81 @return Returns a if a > b else b 82 */ 83 static INLINE OPJ_UINT32 opj_uint_max(OPJ_UINT32 a, OPJ_UINT32 b) 84 { 85 return (a > b) ? a : b; 86 } 87 88 /** 89 Get the saturated sum of two unsigned integers 90 @return Returns saturated sum of a+b 91 */ 92 static INLINE OPJ_UINT32 opj_uint_adds(OPJ_UINT32 a, OPJ_UINT32 b) 93 { 94 OPJ_UINT64 sum = (OPJ_UINT64)a + (OPJ_UINT64)b; 95 return (OPJ_UINT32)(-(OPJ_INT32)(sum >> 32)) | (OPJ_UINT32)sum; 96 } 97 98 /** 99 Get the saturated difference of two unsigned integers 100 @return Returns saturated sum of a-b 101 */ 102 static INLINE OPJ_UINT32 opj_uint_subs(OPJ_UINT32 a, OPJ_UINT32 b) 103 { 104 return (a >= b) ? a - b : 0; 105 } 106 107 /** 108 Clamp an integer inside an interval 109 @return 110 <ul> 111 <li>Returns a if (min < a < max) 112 <li>Returns max if (a > max) 113 <li>Returns min if (a < min) 114 </ul> 115 */ 116 static INLINE OPJ_INT32 opj_int_clamp(OPJ_INT32 a, OPJ_INT32 min, 117 OPJ_INT32 max) 118 { 119 if (a < min) { 120 return min; 121 } 122 if (a > max) { 123 return max; 124 } 125 return a; 126 } 127 128 /** 129 Clamp an integer inside an interval 130 @return 131 <ul> 132 <li>Returns a if (min < a < max) 133 <li>Returns max if (a > max) 134 <li>Returns min if (a < min) 135 </ul> 136 */ 137 static INLINE OPJ_INT64 opj_int64_clamp(OPJ_INT64 a, OPJ_INT64 min, 138 OPJ_INT64 max) 139 { 140 if (a < min) { 141 return min; 142 } 143 if (a > max) { 144 return max; 145 } 146 return a; 147 } 148 149 /** 150 @return Get absolute value of integer 151 */ 152 static INLINE OPJ_INT32 opj_int_abs(OPJ_INT32 a) 153 { 154 return a < 0 ? -a : a; 155 } 156 /** 157 Divide an integer and round upwards 158 @return Returns a divided by b 159 */ 160 static INLINE OPJ_INT32 opj_int_ceildiv(OPJ_INT32 a, OPJ_INT32 b) 161 { 162 assert(b); 163 return (OPJ_INT32)(((OPJ_INT64)a + b - 1) / b); 164 } 165 166 /** 167 Divide an integer and round upwards 168 @return Returns a divided by b 169 */ 170 static INLINE OPJ_UINT32 opj_uint_ceildiv(OPJ_UINT32 a, OPJ_UINT32 b) 171 { 172 assert(b); 173 return (a + b - 1) / b; 174 } 175 176 /** 177 Divide an integer by a power of 2 and round upwards 178 @return Returns a divided by 2^b 179 */ 180 static INLINE OPJ_INT32 opj_int_ceildivpow2(OPJ_INT32 a, OPJ_INT32 b) 181 { 182 return (OPJ_INT32)((a + ((OPJ_INT64)1 << b) - 1) >> b); 183 } 184 185 /** 186 Divide a 64bits integer by a power of 2 and round upwards 187 @return Returns a divided by 2^b 188 */ 189 static INLINE OPJ_INT32 opj_int64_ceildivpow2(OPJ_INT64 a, OPJ_INT32 b) 190 { 191 return (OPJ_INT32)((a + ((OPJ_INT64)1 << b) - 1) >> b); 192 } 193 194 /** 195 Divide an integer by a power of 2 and round upwards 196 @return Returns a divided by 2^b 197 */ 198 static INLINE OPJ_UINT32 opj_uint_ceildivpow2(OPJ_UINT32 a, OPJ_UINT32 b) 199 { 200 return (OPJ_UINT32)((a + ((OPJ_UINT64)1U << b) - 1U) >> b); 201 } 202 203 /** 204 Divide an integer by a power of 2 and round downwards 205 @return Returns a divided by 2^b 206 */ 207 static INLINE OPJ_INT32 opj_int_floordivpow2(OPJ_INT32 a, OPJ_INT32 b) 208 { 209 return a >> b; 210 } 211 /** 212 Get logarithm of an integer and round downwards 213 @return Returns log2(a) 214 */ 215 static INLINE OPJ_INT32 opj_int_floorlog2(OPJ_INT32 a) 216 { 217 OPJ_INT32 l; 218 for (l = 0; a > 1; l++) { 219 a >>= 1; 220 } 221 return l; 222 } 223 /** 224 Get logarithm of an integer and round downwards 225 @return Returns log2(a) 226 */ 227 static INLINE OPJ_UINT32 opj_uint_floorlog2(OPJ_UINT32 a) 228 { 229 OPJ_UINT32 l; 230 for (l = 0; a > 1; ++l) { 231 a >>= 1; 232 } 233 return l; 234 } 235 236 /** 237 Multiply two fixed-precision rational numbers. 238 @param a 239 @param b 240 @return Returns a * b 241 */ 242 static INLINE OPJ_INT32 opj_int_fix_mul(OPJ_INT32 a, OPJ_INT32 b) 243 { 244 #if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__INTEL_COMPILER) && defined(_M_IX86) 245 OPJ_INT64 temp = __emul(a, b); 246 #else 247 OPJ_INT64 temp = (OPJ_INT64) a * (OPJ_INT64) b ; 248 #endif 249 temp += 4096; 250 assert((temp >> 13) <= (OPJ_INT64)0x7FFFFFFF); 251 assert((temp >> 13) >= (-(OPJ_INT64)0x7FFFFFFF - (OPJ_INT64)1)); 252 return (OPJ_INT32)(temp >> 13); 253 } 254 255 static INLINE OPJ_INT32 opj_int_fix_mul_t1(OPJ_INT32 a, OPJ_INT32 b) 256 { 257 #if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__INTEL_COMPILER) && defined(_M_IX86) 258 OPJ_INT64 temp = __emul(a, b); 259 #else 260 OPJ_INT64 temp = (OPJ_INT64) a * (OPJ_INT64) b ; 261 #endif 262 temp += 4096; 263 assert((temp >> (13 + 11 - T1_NMSEDEC_FRACBITS)) <= (OPJ_INT64)0x7FFFFFFF); 264 assert((temp >> (13 + 11 - T1_NMSEDEC_FRACBITS)) >= (-(OPJ_INT64)0x7FFFFFFF - 265 (OPJ_INT64)1)); 266 return (OPJ_INT32)(temp >> (13 + 11 - T1_NMSEDEC_FRACBITS)) ; 267 } 268 269 /* ----------------------------------------------------------------------- */ 270 /*@}*/ 271 272 /*@}*/ 273 274 #endif /* OPJ_INTMATH_H */ 275
