1fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/* 2fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * Copyright 2012 Google Inc. 3fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * 4fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * Use of this source code is governed by a BSD-style license that can be 5fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * found in the LICENSE file. 6fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot */ 7fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 8fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#ifndef SkMathPriv_DEFINED 9fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#define SkMathPriv_DEFINED 10fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 11fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#include "SkMath.h" 12fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 13fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#if defined(SK_BUILD_FOR_IOS) && (defined(SK_BUILD_FOR_ARM32) || defined(SK_BUILD_FOR_ARM64)) 14fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot// iOS on ARM starts processes with the Flush-To-Zero (FTZ) and 15fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot// Denormals-Are-Zero (DAZ) bits in the fpscr register set. 16fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot// Algorithms that rely on denormalized numbers need alternative implementations. 17fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot// This can also be controlled in SSE with the MXCSR register, 18fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot// x87 with FSTCW/FLDCW, and mips with FCSR. This should be detected at runtime, 19fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot// or the library built one way or the other more generally (by the build). 20fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#define SK_CPU_FLUSH_TO_ZERO 21fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#endif 22fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 23fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/** Returns -1 if n < 0, else returns 0 24fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot */ 25fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#define SkExtractSign(n) ((int32_t)(n) >> 31) 26fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 27fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/** If sign == -1, returns -n, else sign must be 0, and returns n. 28fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot Typically used in conjunction with SkExtractSign(). 29fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot */ 30fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotstatic inline int32_t SkApplySign(int32_t n, int32_t sign) { 31fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot SkASSERT(sign == 0 || sign == -1); 32fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return (n ^ sign) - sign; 33fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 34fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 35fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/** Return x with the sign of y */ 36fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotstatic inline int32_t SkCopySign32(int32_t x, int32_t y) { 37fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return SkApplySign(x, SkExtractSign(x ^ y)); 38fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 39fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 40fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/** Given a positive value and a positive max, return the value 41fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot pinned against max. 42fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot Note: only works as long as max - value doesn't wrap around 43fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot @return max if value >= max, else value 44fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot */ 45fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotstatic inline unsigned SkClampUMax(unsigned value, unsigned max) { 46fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot if (value > max) { 47fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot value = max; 48fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot } 49fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return value; 50fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 51fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 52fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot// If a signed int holds min_int (e.g. 0x80000000) it is undefined what happens when 53fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot// we negate it (even though we *know* we're 2's complement and we'll get the same 54fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot// value back). So we create this helper function that casts to size_t (unsigned) first, 55fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot// to avoid the complaint. 56fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotstatic inline size_t sk_negate_to_size_t(int32_t value) { 57fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#if defined(_MSC_VER) 58fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#pragma warning(push) 59fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#pragma warning(disable : 4146) // Thanks MSVC, we know what we're negating an unsigned 60fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#endif 61fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return -static_cast<size_t>(value); 62fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#if defined(_MSC_VER) 63fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#pragma warning(pop) 64fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#endif 65fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 66fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 67fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/////////////////////////////////////////////////////////////////////////////// 68fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 69fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/** Return a*b/255, truncating away any fractional bits. Only valid if both 70fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot a and b are 0..255 71fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot */ 72fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotstatic inline U8CPU SkMulDiv255Trunc(U8CPU a, U8CPU b) { 73fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot SkASSERT((uint8_t)a == a); 74fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot SkASSERT((uint8_t)b == b); 75fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot unsigned prod = a*b + 1; 76fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return (prod + (prod >> 8)) >> 8; 77fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 78fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 79fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/** Return (a*b)/255, taking the ceiling of any fractional bits. Only valid if 80fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot both a and b are 0..255. The expected result equals (a * b + 254) / 255. 81fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot */ 82fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotstatic inline U8CPU SkMulDiv255Ceiling(U8CPU a, U8CPU b) { 83fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot SkASSERT((uint8_t)a == a); 84fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot SkASSERT((uint8_t)b == b); 85fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot unsigned prod = a*b + 255; 86fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return (prod + (prod >> 8)) >> 8; 87fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 88fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 89fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/** Just the rounding step in SkDiv255Round: round(value / 255) 90fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot */ 91fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotstatic inline unsigned SkDiv255Round(unsigned prod) { 92fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot prod += 128; 93fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return (prod + (prod >> 8)) >> 8; 94fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 95fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 96fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotstatic inline float SkPinToUnitFloat(float x) { 97fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return SkTMin(SkTMax(x, 0.0f), 1.0f); 98fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 99fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 100fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/** 101fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * Swap byte order of a 4-byte value, e.g. 0xaarrggbb -> 0xbbggrraa. 102fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot */ 103fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#if defined(_MSC_VER) 104fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot #include <intrin.h> 105fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot static inline uint32_t SkBSwap32(uint32_t v) { return _byteswap_ulong(v); } 106fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#else 107fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot static inline uint32_t SkBSwap32(uint32_t v) { return __builtin_bswap32(v); } 108fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#endif 109fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 110fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot//! Returns the number of leading zero bits (0...32) 111fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotint SkCLZ_portable(uint32_t); 112fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 113fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#ifndef SkCLZ 114fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot #if defined(SK_BUILD_FOR_WIN) 115fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot #include <intrin.h> 116fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 117fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot static inline int SkCLZ(uint32_t mask) { 118fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot if (mask) { 119fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot unsigned long index; 120fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot _BitScanReverse(&index, mask); 121fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot // Suppress this bogus /analyze warning. The check for non-zero 122fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot // guarantees that _BitScanReverse will succeed. 123fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#pragma warning(suppress : 6102) // Using 'index' from failed function call 124fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return index ^ 0x1F; 125fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot } else { 126fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return 32; 127fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot } 128fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot } 129fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot #elif defined(SK_CPU_ARM32) || defined(__GNUC__) || defined(__clang__) 130fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot static inline int SkCLZ(uint32_t mask) { 131fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot // __builtin_clz(0) is undefined, so we have to detect that case. 132fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return mask ? __builtin_clz(mask) : 32; 133fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot } 134fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot #else 135fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot #define SkCLZ(x) SkCLZ_portable(x) 136fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot #endif 137fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#endif 138fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 139fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/** 140fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * Returns the smallest power-of-2 that is >= the specified value. If value 141fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * is already a power of 2, then it is returned unchanged. It is undefined 142fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * if value is <= 0. 143fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot */ 144fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotstatic inline int SkNextPow2(int value) { 145fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot SkASSERT(value > 0); 146fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return 1 << (32 - SkCLZ(value - 1)); 147fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 148fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 149fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/** 150fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot* Returns the largest power-of-2 that is <= the specified value. If value 151fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot* is already a power of 2, then it is returned unchanged. It is undefined 152fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot* if value is <= 0. 153fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot*/ 154fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotstatic inline int SkPrevPow2(int value) { 155fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot SkASSERT(value > 0); 156fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return 1 << (32 - SkCLZ(value >> 1)); 157fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 158fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 159fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/** 160fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * Returns the log2 of the specified value, were that value to be rounded up 161fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * to the next power of 2. It is undefined to pass 0. Examples: 162fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * SkNextLog2(1) -> 0 163fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * SkNextLog2(2) -> 1 164fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * SkNextLog2(3) -> 2 165fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * SkNextLog2(4) -> 2 166fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * SkNextLog2(5) -> 3 167fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot */ 168fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotstatic inline int SkNextLog2(uint32_t value) { 169fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot SkASSERT(value != 0); 170fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return 32 - SkCLZ(value - 1); 171fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 172fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 173fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/** 174fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot* Returns the log2 of the specified value, were that value to be rounded down 175fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot* to the previous power of 2. It is undefined to pass 0. Examples: 176fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot* SkPrevLog2(1) -> 0 177fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot* SkPrevLog2(2) -> 1 178fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot* SkPrevLog2(3) -> 1 179fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot* SkPrevLog2(4) -> 2 180fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot* SkPrevLog2(5) -> 2 181fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot*/ 182fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotstatic inline int SkPrevLog2(uint32_t value) { 183fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot SkASSERT(value != 0); 184fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return 32 - SkCLZ(value >> 1); 185fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 186fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 187fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/////////////////////////////////////////////////////////////////////////////// 188fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 189fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/** 190fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * Return the next power of 2 >= n. 191fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot */ 192fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotstatic inline uint32_t GrNextPow2(uint32_t n) { 193fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return n ? (1 << (32 - SkCLZ(n - 1))) : 1; 194fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 195fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 196fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot/** 197fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot * Returns the next power of 2 >= n or n if the next power of 2 can't be represented by size_t. 198fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot */ 199fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robotstatic inline size_t GrNextSizePow2(size_t n) { 200fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot constexpr int kNumSizeTBits = 8 * sizeof(size_t); 201fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot constexpr size_t kHighBitSet = size_t(1) << (kNumSizeTBits - 1); 202fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 203fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot if (!n) { 204fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return 1; 205fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot } else if (n >= kHighBitSet) { 206fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return n; 207fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot } 208fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 209fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot n--; 210fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot uint32_t shift = 1; 211fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot while (shift < kNumSizeTBits) { 212fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot n |= n >> shift; 213fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot shift <<= 1; 214fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot } 215fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return n + 1; 216fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 217fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 218fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot// conservative check. will return false for very large values that "could" fit 219fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robottemplate <typename T> static inline bool SkFitsInFixed(T x) { 220fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot return SkTAbs(x) <= 32767.0f; 221fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot} 222fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot 223fe17456d5e528078ce69b5f15cf7adf1fab963fandroid-build-team Robot#endif 224