// Returns the square of the Euclidian distance to (dx,dy) in *result. static inline void getLengthSquared(SkScalar dx, SkScalar dy, Sk64 *result) { Sk64 dySqr; result->setMul(dx, dx); dySqr.setMul(dy, dy); result->add(dySqr); }
/** returns the product if it is positive and fits in 31 bits. Otherwise this returns 0. */ static int32_t safeMul32(int32_t a, int32_t b) { Sk64 size; size.setMul(a, b); if (size.is32() && size.isPos()) { return size.get32(); } return 0; }
SkMSec SkTime::GetMSecs() { UnsignedWide wide; Sk64 s; ::Microseconds(&wide); s.set(wide.hi, wide.lo); s.div(1000, Sk64::kRound_DivOption); return s.get32(); }
// Calculates the square of the Euclidian distance to (dx,dy) and stores it in // *lengthSquared. Returns true if the distance is judged to be "nearly zero". // // This logic is encapsulated in a helper method to make it explicit that we // always perform this check in the same manner, to avoid inconsistencies // (see http://code.google.com/p/skia/issues/detail?id=560 ). static inline bool isLengthNearlyZero(SkScalar dx, SkScalar dy, Sk64 *lengthSquared) { Sk64 tolSqr; getLengthSquared(dx, dy, lengthSquared); // we want nearlyzero^2, but to compute it fast we want to just do a // 32bit multiply, so we require that it not exceed 31bits. That is true // if nearlyzero is <= 0xB504, which should be trivial, since usually // nearlyzero is a very small fixed-point value. SkASSERT(SK_ScalarNearlyZero <= 0xB504); tolSqr.set(0, SK_ScalarNearlyZero * SK_ScalarNearlyZero); return *lengthSquared <= tolSqr; }
static MipMap* Alloc(int levelCount, size_t pixelSize) { if (levelCount < 0) { return NULL; } Sk64 size; size.setMul(levelCount + 1, sizeof(MipLevel)); size.add(sizeof(MipMap)); size.add(pixelSize); if (!isPos32Bits(size)) { return NULL; } MipMap* mm = (MipMap*)sk_malloc_throw(size.get32()); mm->fRefCnt = 1; mm->fLevelCount = levelCount; return mm; }
SkMallocPixelRef* SkMallocPixelRef::NewAllocate(const SkImageInfo& info, size_t requestedRowBytes, SkColorTable* ctable) { if (!is_valid(info, ctable)) { return NULL; } int32_t minRB = info.minRowBytes(); if (minRB < 0) { return NULL; // allocation will be too large } if (requestedRowBytes > 0 && (int32_t)requestedRowBytes < minRB) { return NULL; // cannot meet requested rowbytes } int32_t rowBytes; if (requestedRowBytes) { rowBytes = requestedRowBytes; } else { rowBytes = minRB; } Sk64 bigSize; bigSize.setMul(info.fHeight, rowBytes); if (!bigSize.is32()) { return NULL; } size_t size = bigSize.get32(); void* addr = sk_malloc_flags(size, 0); if (NULL == addr) { return NULL; } return SkNEW_ARGS(SkMallocPixelRef, (info, addr, rowBytes, ctable, true)); }
/** Trim A/B/C down so that they are all <= 32bits and then call SkFindUnitQuadRoots() */ static int Sk64FindFixedQuadRoots(const Sk64& A, const Sk64& B, const Sk64& C, SkFixed roots[2]) { int na = A.shiftToMake32(); int nb = B.shiftToMake32(); int nc = C.shiftToMake32(); int shift = SkMax32(na, SkMax32(nb, nc)); SkASSERT(shift >= 0); return SkFindUnitQuadRoots(A.getShiftRight(shift), B.getShiftRight(shift), C.getShiftRight(shift), roots); }
static bool isPos32Bits(const Sk64& value) { return !value.isNeg() && value.is32(); }
SkScalar SkPoint::Length(SkScalar dx, SkScalar dy) { Sk64 tmp; getLengthSquared(dx, dy, &tmp); return tmp.getSqrt(); }