| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (C) 2006-2008 The Android Open Source Project | |
| 3 * | |
| 4 * Licensed under the Apache License, Version 2.0 (the "License"); | |
| 5 * you may not use this file except in compliance with the License. | |
| 6 * You may obtain a copy of the License at | |
| 7 * | |
| 8 * http://www.apache.org/licenses/LICENSE-2.0 | |
| 9 * | |
| 10 * Unless required by applicable law or agreed to in writing, software | |
| 11 * distributed under the License is distributed on an "AS IS" BASIS, | |
| 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 13 * See the License for the specific language governing permissions and | |
| 14 * limitations under the License. | |
| 15 */ | |
| 16 | |
| 17 #include "SkFloat.h" | |
| 18 #include "SkMath.h" | |
| 19 | |
| 20 #define EXP_BIAS (127+23) | |
| 21 | |
| 22 static int get_unsigned_exp(uint32_t packed) | |
| 23 { | |
| 24 return (packed << 1 >> 24); | |
| 25 } | |
| 26 | |
| 27 static unsigned get_unsigned_value(uint32_t packed) | |
| 28 { | |
| 29 return (packed << 9 >> 9) | (1 << 23); | |
| 30 } | |
| 31 | |
| 32 static int get_signed_value(int32_t packed) | |
| 33 { | |
| 34 return SkApplySign(get_unsigned_value(packed), SkExtractSign(packed)); | |
| 35 } | |
| 36 | |
| 37 ///////////////////////////////////////////////////////////////////////// | |
| 38 | |
| 39 int SkFloat::GetShift(int32_t packed, int shift) | |
| 40 { | |
| 41 if (packed == 0) | |
| 42 return 0; | |
| 43 | |
| 44 int exp = get_unsigned_exp(packed) - EXP_BIAS - shift; | |
| 45 int value = get_unsigned_value(packed); | |
| 46 | |
| 47 if (exp >= 0) | |
| 48 { | |
| 49 if (exp > 8) // overflow | |
| 50 value = SK_MaxS32; | |
| 51 else | |
| 52 value <<= exp; | |
| 53 } | |
| 54 else | |
| 55 { | |
| 56 exp = -exp; | |
| 57 if (exp > 23) // underflow | |
| 58 value = 0; | |
| 59 else | |
| 60 value >>= exp; | |
| 61 } | |
| 62 return SkApplySign(value, SkExtractSign(packed)); | |
| 63 } | |
| 64 | |
| 65 ////////////////////////////////////////////////////////////////////////////////
///// | |
| 66 | |
| 67 int32_t SkFloat::SetShift(int value, int shift) | |
| 68 { | |
| 69 if (value == 0) | |
| 70 return 0; | |
| 71 | |
| 72 // record the sign and make value positive | |
| 73 int sign = SkExtractSign(value); | |
| 74 value = SkApplySign(value, sign); | |
| 75 | |
| 76 if (value >> 24) // value is too big (has more than 24 bits set) | |
| 77 { | |
| 78 int bias = 8 - SkCLZ(value); | |
| 79 SkASSERT(bias > 0 && bias < 8); | |
| 80 value >>= bias; | |
| 81 shift += bias; | |
| 82 } | |
| 83 else | |
| 84 { | |
| 85 int zeros = SkCLZ(value << 8); | |
| 86 SkASSERT(zeros >= 0 && zeros <= 23); | |
| 87 value <<= zeros; | |
| 88 shift -= zeros; | |
| 89 } | |
| 90 // now value is left-aligned to 24 bits | |
| 91 SkASSERT((value >> 23) == 1); | |
| 92 | |
| 93 shift += EXP_BIAS; | |
| 94 if (shift < 0) // underflow | |
| 95 return 0; | |
| 96 else | |
| 97 { | |
| 98 if (shift > 255) // overflow | |
| 99 { | |
| 100 shift = 255; | |
| 101 value = 0x00FFFFFF; | |
| 102 } | |
| 103 int32_t packed = sign << 31; // set the sign-bit | |
| 104 packed |= shift << 23; // store the packed exponent | |
| 105 packed |= ((unsigned)(value << 9) >> 9); // clear 24th bit of value (
its implied) | |
| 106 | |
| 107 #ifdef SK_DEBUG | |
| 108 { | |
| 109 int n; | |
| 110 | |
| 111 n = SkExtractSign(packed); | |
| 112 SkASSERT(n == sign); | |
| 113 n = get_unsigned_exp(packed); | |
| 114 SkASSERT(n == shift); | |
| 115 n = get_unsigned_value(packed); | |
| 116 SkASSERT(n == value); | |
| 117 } | |
| 118 #endif | |
| 119 return packed; | |
| 120 } | |
| 121 } | |
| 122 | |
| 123 int32_t SkFloat::Neg(int32_t packed) | |
| 124 { | |
| 125 if (packed) | |
| 126 packed = packed ^ (1 << 31); | |
| 127 return packed; | |
| 128 } | |
| 129 | |
| 130 int32_t SkFloat::Add(int32_t packed_a, int32_t packed_b) | |
| 131 { | |
| 132 if (packed_a == 0) | |
| 133 return packed_b; | |
| 134 if (packed_b == 0) | |
| 135 return packed_a; | |
| 136 | |
| 137 int exp_a = get_unsigned_exp(packed_a); | |
| 138 int exp_b = get_unsigned_exp(packed_b); | |
| 139 int exp_diff = exp_a - exp_b; | |
| 140 | |
| 141 int shift_a = 0, shift_b = 0; | |
| 142 int exp; | |
| 143 | |
| 144 if (exp_diff >= 0) | |
| 145 { | |
| 146 if (exp_diff > 24) // B is too small to contribute | |
| 147 return packed_a; | |
| 148 shift_b = exp_diff; | |
| 149 exp = exp_a; | |
| 150 } | |
| 151 else | |
| 152 { | |
| 153 exp_diff = -exp_diff; | |
| 154 if (exp_diff > 24) // A is too small to contribute | |
| 155 return packed_b; | |
| 156 shift_a = exp_diff; | |
| 157 exp = exp_b; | |
| 158 } | |
| 159 | |
| 160 int value_a = get_signed_value(packed_a) >> shift_a; | |
| 161 int value_b = get_signed_value(packed_b) >> shift_b; | |
| 162 | |
| 163 return SkFloat::SetShift(value_a + value_b, exp - EXP_BIAS); | |
| 164 } | |
| 165 | |
| 166 #include "Sk64.h" | |
| 167 | |
| 168 static inline int32_t mul24(int32_t a, int32_t b) | |
| 169 { | |
| 170 Sk64 tmp; | |
| 171 | |
| 172 tmp.setMul(a, b); | |
| 173 tmp.roundRight(24); | |
| 174 return tmp.get32(); | |
| 175 } | |
| 176 | |
| 177 int32_t SkFloat::Mul(int32_t packed_a, int32_t packed_b) | |
| 178 { | |
| 179 if (packed_a == 0 || packed_b == 0) | |
| 180 return 0; | |
| 181 | |
| 182 int exp_a = get_unsigned_exp(packed_a); | |
| 183 int exp_b = get_unsigned_exp(packed_b); | |
| 184 | |
| 185 int value_a = get_signed_value(packed_a); | |
| 186 int value_b = get_signed_value(packed_b); | |
| 187 | |
| 188 return SkFloat::SetShift(mul24(value_a, value_b), exp_a + exp_b - 2*EXP_BIAS
+ 24); | |
| 189 } | |
| 190 | |
| 191 int32_t SkFloat::MulInt(int32_t packed, int n) | |
| 192 { | |
| 193 return Mul(packed, SetShift(n, 0)); | |
| 194 } | |
| 195 | |
| 196 int32_t SkFloat::Div(int32_t packed_n, int32_t packed_d) | |
| 197 { | |
| 198 SkASSERT(packed_d != 0); | |
| 199 | |
| 200 if (packed_n == 0) | |
| 201 return 0; | |
| 202 | |
| 203 int exp_n = get_unsigned_exp(packed_n); | |
| 204 int exp_d = get_unsigned_exp(packed_d); | |
| 205 | |
| 206 int value_n = get_signed_value(packed_n); | |
| 207 int value_d = get_signed_value(packed_d); | |
| 208 | |
| 209 return SkFloat::SetShift(SkDivBits(value_n, value_d, 24), exp_n - exp_d - 24
); | |
| 210 } | |
| 211 | |
| 212 int32_t SkFloat::DivInt(int32_t packed, int n) | |
| 213 { | |
| 214 return Div(packed, SetShift(n, 0)); | |
| 215 } | |
| 216 | |
| 217 int32_t SkFloat::Invert(int32_t packed) | |
| 218 { | |
| 219 return Div(packed, SetShift(1, 0)); | |
| 220 } | |
| 221 | |
| 222 int32_t SkFloat::Sqrt(int32_t packed) | |
| 223 { | |
| 224 if (packed < 0) | |
| 225 { | |
| 226 SkASSERT(!"can't sqrt a negative number"); | |
| 227 return 0; | |
| 228 } | |
| 229 | |
| 230 int exp = get_unsigned_exp(packed); | |
| 231 int value = get_unsigned_value(packed); | |
| 232 | |
| 233 int nexp = exp - EXP_BIAS; | |
| 234 int root = SkSqrtBits(value << (nexp & 1), 26); | |
| 235 nexp >>= 1; | |
| 236 return SkFloat::SetShift(root, nexp - 11); | |
| 237 } | |
| 238 | |
| 239 #if defined _WIN32 && _MSC_VER >= 1300 // disable warning : unreachable code | |
| 240 #pragma warning ( push ) | |
| 241 #pragma warning ( disable : 4702 ) | |
| 242 #endif | |
| 243 | |
| 244 int32_t SkFloat::CubeRoot(int32_t packed) | |
| 245 { | |
| 246 sk_throw(); | |
| 247 return 0; | |
| 248 } | |
| 249 | |
| 250 #if defined _WIN32 && _MSC_VER >= 1300 | |
| 251 #pragma warning ( pop ) | |
| 252 #endif | |
| 253 | |
| 254 static inline int32_t clear_high_bit(int32_t n) | |
| 255 { | |
| 256 return ((uint32_t)(n << 1)) >> 1; | |
| 257 } | |
| 258 | |
| 259 static inline int int_sign(int32_t a, int32_t b) | |
| 260 { | |
| 261 return a > b ? 1 : (a < b ? -1 : 0); | |
| 262 } | |
| 263 | |
| 264 int SkFloat::Cmp(int32_t packed_a, int32_t packed_b) | |
| 265 { | |
| 266 packed_a = SkApplySign(clear_high_bit(packed_a), SkExtractSign(packed_a)); | |
| 267 packed_b = SkApplySign(clear_high_bit(packed_b), SkExtractSign(packed_b)); | |
| 268 | |
| 269 return int_sign(packed_a, packed_b); | |
| 270 } | |
| 271 | |
| 272 ////////////////////////////////////////////////////////////////////////////////
///// | |
| 273 ////////////////////////////////////////////////////////////////////////////////
///// | |
| 274 | |
| 275 #ifdef SK_DEBUG | |
| 276 | |
| 277 #include "SkRandom.h" | |
| 278 #ifdef SK_CAN_USE_FLOAT | |
| 279 #include "SkFloatingPoint.h" | |
| 280 #endif | |
| 281 | |
| 282 void SkFloat::UnitTest() | |
| 283 { | |
| 284 #ifdef SK_SUPPORT_UNITTEST | |
| 285 SkFloat a, b, c, d; | |
| 286 int n; | |
| 287 | |
| 288 a.setZero(); | |
| 289 n = a.getInt(); | |
| 290 SkASSERT(n == 0); | |
| 291 | |
| 292 b.setInt(5); | |
| 293 n = b.getInt(); | |
| 294 SkASSERT(n == 5); | |
| 295 | |
| 296 c.setInt(-3); | |
| 297 n = c.getInt(); | |
| 298 SkASSERT(n == -3); | |
| 299 | |
| 300 d.setAdd(c, b); | |
| 301 SkDebugf("SkFloat: %d + %d = %d\n", c.getInt(), b.getInt(), d.getInt()); | |
| 302 | |
| 303 SkRandom rand; | |
| 304 | |
| 305 #ifdef SK_CAN_USE_FLOAT | |
| 306 int i; | |
| 307 for (i = 0; i < 1000; i++) | |
| 308 { | |
| 309 float fa, fb; | |
| 310 int aa = rand.nextS() >> 14; | |
| 311 int bb = rand.nextS() >> 14; | |
| 312 a.setInt(aa); | |
| 313 b.setInt(bb); | |
| 314 SkASSERT(a.getInt() == aa); | |
| 315 SkASSERT(b.getInt() == bb); | |
| 316 | |
| 317 c.setAdd(a, b); | |
| 318 int cc = c.getInt(); | |
| 319 SkASSERT(cc == aa + bb); | |
| 320 | |
| 321 c.setSub(a, b); | |
| 322 cc = c.getInt(); | |
| 323 SkASSERT(cc == aa - bb); | |
| 324 | |
| 325 aa >>= 5; | |
| 326 bb >>= 5; | |
| 327 a.setInt(aa); | |
| 328 b.setInt(bb); | |
| 329 c.setMul(a, b); | |
| 330 cc = c.getInt(); | |
| 331 SkASSERT(cc == aa * bb); | |
| 332 ///////////////////////////////////// | |
| 333 | |
| 334 aa = rand.nextS() >> 11; | |
| 335 a.setFixed(aa); | |
| 336 cc = a.getFixed(); | |
| 337 SkASSERT(aa == cc); | |
| 338 | |
| 339 bb = rand.nextS() >> 11; | |
| 340 b.setFixed(bb); | |
| 341 cc = b.getFixed(); | |
| 342 SkASSERT(bb == cc); | |
| 343 | |
| 344 cc = SkFixedMul(aa, bb); | |
| 345 c.setMul(a, b); | |
| 346 SkFixed dd = c.getFixed(); | |
| 347 int diff = cc - dd; | |
| 348 SkASSERT(SkAbs32(diff) <= 1); | |
| 349 | |
| 350 fa = (float)aa / 65536.0f; | |
| 351 fb = (float)bb / 65536.0f; | |
| 352 a.assertEquals(fa); | |
| 353 b.assertEquals(fb); | |
| 354 fa = a.getFloat(); | |
| 355 fb = b.getFloat(); | |
| 356 | |
| 357 c.assertEquals(fa * fb, 1); | |
| 358 | |
| 359 c.setDiv(a, b); | |
| 360 cc = SkFixedDiv(aa, bb); | |
| 361 dd = c.getFixed(); | |
| 362 diff = cc - dd; | |
| 363 SkASSERT(SkAbs32(diff) <= 3); | |
| 364 | |
| 365 c.assertEquals(fa / fb, 1); | |
| 366 | |
| 367 SkASSERT((aa == bb) == (a == b)); | |
| 368 SkASSERT((aa != bb) == (a != b)); | |
| 369 SkASSERT((aa < bb) == (a < b)); | |
| 370 SkASSERT((aa <= bb) == (a <= b)); | |
| 371 SkASSERT((aa > bb) == (a > b)); | |
| 372 SkASSERT((aa >= bb) == (a >= b)); | |
| 373 | |
| 374 if (aa < 0) | |
| 375 { | |
| 376 aa = -aa; | |
| 377 fa = -fa; | |
| 378 } | |
| 379 a.setFixed(aa); | |
| 380 c.setSqrt(a); | |
| 381 cc = SkFixedSqrt(aa); | |
| 382 dd = c.getFixed(); | |
| 383 SkASSERT(dd == cc); | |
| 384 | |
| 385 c.assertEquals(sk_float_sqrt(fa), 2); | |
| 386 | |
| 387 // cuberoot | |
| 388 #if 0 | |
| 389 a.setInt(1); | |
| 390 a.cubeRoot(); | |
| 391 a.assertEquals(1.0f, 0); | |
| 392 a.setInt(8); | |
| 393 a.cubeRoot(); | |
| 394 a.assertEquals(2.0f, 0); | |
| 395 a.setInt(27); | |
| 396 a.cubeRoot(); | |
| 397 a.assertEquals(3.0f, 0); | |
| 398 #endif | |
| 399 } | |
| 400 #endif | |
| 401 #endif | |
| 402 } | |
| 403 | |
| 404 #endif | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 113827:
Remove the remainder of the skia source code from the Chromium repo.... (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/