Revert of https://codereview.chromium.org/113823003/
Reason for revert: need to update callsites in linux codecs
R=robertphillips@google.com
TBR=robertphillips@google.com
NOTREECHECKS=true
NOTRY=true
BUG=
Author: reed@google.com
Review URL: https://codereview.chromium.org/122283002
git-svn-id: http://skia.googlecode.com/svn/trunk@12841 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/include/core/Sk64.h b/include/core/Sk64.h
index c12a97c..0097449 100644
--- a/include/core/Sk64.h
+++ b/include/core/Sk64.h
@@ -1,3 +1,4 @@
+
/*
* Copyright 2006 The Android Open Source Project
*
@@ -5,6 +6,7 @@
* found in the LICENSE file.
*/
+
#ifndef Sk64_DEFINED
#define Sk64_DEFINED
@@ -26,11 +28,6 @@
int64_t as64() const { return ((int64_t)fHi << 32) | fLo; }
int64_t getLongLong() const { return this->as64(); }
- void set64(int64_t value) {
- fHi = (int32_t)(value >> 32);
- fLo = (uint32_t)value;
- }
-
/** Returns non-zero if the Sk64 can be represented as a signed 32 bit integer
*/
SkBool is32() const { return fHi == ((int32_t)fLo >> 31); }
diff --git a/include/core/SkBitmap.h b/include/core/SkBitmap.h
index 2b900be..c0e299a 100644
--- a/include/core/SkBitmap.h
+++ b/include/core/SkBitmap.h
@@ -1,3 +1,4 @@
+
/*
* Copyright 2006 The Android Open Source Project
*
@@ -5,19 +6,17 @@
* found in the LICENSE file.
*/
+
#ifndef SkBitmap_DEFINED
#define SkBitmap_DEFINED
+#include "Sk64.h"
#include "SkColor.h"
#include "SkColorTable.h"
#include "SkImageInfo.h"
#include "SkPoint.h"
#include "SkRefCnt.h"
-#ifdef SK_SUPPORT_LEGACY_SK64
- #include "Sk64.h"
-#endif
-
struct SkIRect;
struct SkRect;
class SkPaint;
@@ -150,37 +149,19 @@
*/
size_t getSafeSize() const ;
- /**
- * Return the full size of the bitmap, in bytes.
- */
- int64_t computeSize64() const {
- return sk_64_mul(fHeight, fRowBytes);
- }
-
- /**
- * Return the number of bytes from the pointer returned by getPixels()
- * to the end of the allocated space in the buffer. This may be smaller
- * than computeSize64() if there is any rowbytes padding beyond the width.
- */
- int64_t computeSafeSize64() const {
- return ComputeSafeSize64((Config)fConfig, fWidth, fHeight, fRowBytes);
- }
-
-#ifdef SK_SUPPORT_LEGACY_SK64
- SK_ATTR_DEPRECATED("use getSize64()")
+ /** Return the byte size of the pixels, based on the height and rowBytes.
+ This routine is slightly slower than getSize(), but does not truncate
+ the answer to 32bits.
+ */
Sk64 getSize64() const {
Sk64 size;
- size.set64(this->computeSize64());
+ size.setMul(fHeight, fRowBytes);
return size;
}
- SK_ATTR_DEPRECATED("use getSafeSize64()")
- Sk64 getSafeSize64() const {
- Sk64 size;
- size.set64(this->computeSafeSize64());
- return size;
- }
-#endif
+ /** Same as getSafeSize(), but does not truncate the answer to 32bits.
+ */
+ Sk64 getSafeSize64() const ;
/** Returns true if this bitmap is marked as immutable, meaning that the
contents of its pixels will not change for the lifetime of the bitmap.
@@ -236,7 +217,7 @@
return ComputeBytesPerPixel(c) >> 1;
}
- static int64_t ComputeSize64(Config, int width, int height);
+ static Sk64 ComputeSize64(Config, int width, int height);
static size_t ComputeSize(Config, int width, int height);
/**
@@ -697,10 +678,10 @@
/* Internal computations for safe size.
*/
- static int64_t ComputeSafeSize64(Config config,
- uint32_t width,
- uint32_t height,
- size_t rowBytes);
+ static Sk64 ComputeSafeSize64(Config config,
+ uint32_t width,
+ uint32_t height,
+ size_t rowBytes);
static size_t ComputeSafeSize(Config config,
uint32_t width,
uint32_t height,
diff --git a/include/core/SkMath.h b/include/core/SkMath.h
index ba6223e..affcada 100644
--- a/include/core/SkMath.h
+++ b/include/core/SkMath.h
@@ -35,32 +35,6 @@
*/
#define SkSqrt32(n) SkSqrtBits(n, 15)
-// 64bit -> 32bit utilities
-
-/**
- * Return true iff the 64bit value can exactly be represented in signed 32bits
- */
-static inline bool sk_64_isS32(int64_t value) {
- return (int32_t)value == value;
-}
-
-/**
- * Return the 64bit argument as signed 32bits, asserting in debug that the arg
- * exactly fits in signed 32bits. In the release build, no checks are preformed
- * and the return value if the arg does not fit is undefined.
- */
-static inline int32_t sk_64_asS32(int64_t value) {
- SkASSERT(sk_64_isS32(value));
- return (int32_t)value;
-}
-
-// Handy util that can be passed two ints, and will automatically promote to
-// 64bits before the multiply, so the caller doesn't have to remember to cast
-// e.g. (int64_t)a * b;
-static inline int64_t sk_64_mul(int64_t a, int64_t b) {
- return a * b;
-}
-
///////////////////////////////////////////////////////////////////////////////
//! Returns the number of leading zero bits (0...32)
diff --git a/include/core/SkTypes.h b/include/core/SkTypes.h
index 06c8583..c30a8a2 100644
--- a/include/core/SkTypes.h
+++ b/include/core/SkTypes.h
@@ -1,3 +1,4 @@
+
/*
* Copyright 2006 The Android Open Source Project
*
@@ -5,6 +6,7 @@
* found in the LICENSE file.
*/
+
#ifndef SkTypes_DEFINED
#define SkTypes_DEFINED
@@ -13,8 +15,6 @@
#include "SkPostConfig.h"
#include <stdint.h>
-//#define SK_SUPPORT_LEGACY_SK64
-
/** \file SkTypes.h
*/
diff --git a/include/utils/SkRandom.h b/include/utils/SkRandom.h
index 9191ec3..eeaa701 100644
--- a/include/utils/SkRandom.h
+++ b/include/utils/SkRandom.h
@@ -10,12 +10,9 @@
#ifndef SkRandom_DEFINED
#define SkRandom_DEFINED
+#include "Sk64.h"
#include "SkScalar.h"
-#ifdef SK_SUPPORT_LEGACY_SK64
- #include "Sk64.h"
-#endif
-
/** \class SkLCGRandom
Utility class that implements pseudo random 32bit numbers using a fast
@@ -126,21 +123,13 @@
return this->nextUScalar1() <= fractionTrue;
}
- /**
- * Return the next pseudo random number as a signed 64bit value.
- */
- int64_t next64() {
- int64_t hi = this->nextS();
- return (hi << 32) | this->nextU();
- }
-
-#ifdef SK_SUPPORT_LEGACY_SK64
- SK_ATTR_DEPRECATED("use next64()")
+ /** Return the next pseudo random number as a signed 64bit value.
+ */
void next64(Sk64* a) {
SkASSERT(a);
a->set(this->nextS(), this->nextU());
}
-#endif
+
/**
* Return the current seed. This allows the caller to later reset to the
* same seed (using setSeed) so it can generate the same sequence.
@@ -287,21 +276,12 @@
return this->nextUScalar1() <= fractionTrue;
}
- /**
- * Return the next pseudo random number as a signed 64bit value.
+ /** Return the next pseudo random number as a signed 64bit value.
*/
- int64_t next64() {
- int64_t hi = this->nextS();
- return (hi << 32) | this->nextU();
- }
-
-#ifdef SK_SUPPORT_LEGACY_SK64
- SK_ATTR_DEPRECATED("use next64()")
void next64(Sk64* a) {
SkASSERT(a);
a->set(this->nextS(), this->nextU());
}
-#endif
/** Reset the random object.
*/
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index 11c7cbd..d4c3a47 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -24,6 +24,10 @@
#include "SkPackBits.h"
#include <new>
+static bool isPos32Bits(const Sk64& value) {
+ return !value.isNeg() && value.is32();
+}
+
struct MipLevel {
void* fPixels;
uint32_t fRowBytes;
@@ -40,12 +44,14 @@
if (levelCount < 0) {
return NULL;
}
- int64_t size = (levelCount + 1) * sizeof(MipLevel);
- size += sizeof(MipMap) + pixelSize;
- if (!sk_64_isS32(size)) {
+ Sk64 size;
+ size.setMul(levelCount + 1, sizeof(MipLevel));
+ size.add(sizeof(MipMap));
+ size.add(SkToS32(pixelSize));
+ if (!isPos32Bits(size)) {
return NULL;
}
- MipMap* mm = (MipMap*)sk_malloc_throw(sk_64_asS32(size));
+ MipMap* mm = (MipMap*)sk_malloc_throw(size.get32());
mm->fRefCnt = 1;
mm->fLevelCount = levelCount;
return mm;
@@ -179,49 +185,58 @@
return 0;
}
- int64_t rowBytes = 0;
+ Sk64 rowBytes;
+ rowBytes.setZero();
switch (c) {
case kNo_Config:
break;
case kA8_Config:
case kIndex8_Config:
- rowBytes = width;
+ rowBytes.set(width);
break;
case kRGB_565_Config:
case kARGB_4444_Config:
- rowBytes = width << 1;
+ rowBytes.set(width);
+ rowBytes.shiftLeft(1);
break;
case kARGB_8888_Config:
- rowBytes = width << 2;
+ rowBytes.set(width);
+ rowBytes.shiftLeft(2);
break;
default:
SkDEBUGFAIL("unknown config");
break;
}
- return sk_64_isS32(rowBytes) ? sk_64_asS32(rowBytes) : 0;
+ return isPos32Bits(rowBytes) ? rowBytes.get32() : 0;
}
-int64_t SkBitmap::ComputeSize64(Config config, int width, int height) {
- int64_t rowBytes = sk_64_mul(ComputeBytesPerPixel(config), width);
- return rowBytes * height;
+Sk64 SkBitmap::ComputeSize64(Config c, int width, int height) {
+ Sk64 size;
+ size.setMul(SkToS32(SkBitmap::ComputeRowBytes(c, width)), height);
+ return size;
}
size_t SkBitmap::ComputeSize(Config c, int width, int height) {
- int64_t size = SkBitmap::ComputeSize64(c, width, height);
- return sk_64_isS32(size) ? sk_64_asS32(size) : 0;
+ Sk64 size = SkBitmap::ComputeSize64(c, width, height);
+ return isPos32Bits(size) ? size.get32() : 0;
}
-int64_t SkBitmap::ComputeSafeSize64(Config config,
- uint32_t width,
- uint32_t height,
- size_t rowBytes) {
- int64_t safeSize = 0;
+Sk64 SkBitmap::ComputeSafeSize64(Config config,
+ uint32_t width,
+ uint32_t height,
+ size_t rowBytes) {
+ Sk64 safeSize;
+ safeSize.setZero();
if (height > 0) {
- int64_t lastRow = sk_64_mul(ComputeBytesPerPixel(config), width);
- safeSize = sk_64_mul(height - 1, rowBytes) + lastRow;
+ // TODO: Handle the case where the return value from
+ // ComputeRowBytes is more than 31 bits.
+ safeSize.set(SkToS32(ComputeRowBytes(config, width)));
+ Sk64 sizeAllButLastRow;
+ sizeAllButLastRow.setMul(height - 1, SkToS32(rowBytes));
+ safeSize.add(sizeAllButLastRow);
}
- SkASSERT(safeSize >= 0);
+ SkASSERT(!safeSize.isNeg());
return safeSize;
}
@@ -229,13 +244,8 @@
uint32_t width,
uint32_t height,
size_t rowBytes) {
- int64_t safeSize = ComputeSafeSize64(config, width, height, rowBytes);
- int32_t safeSize32 = (int32_t)safeSize;
-
- if (safeSize32 != safeSize) {
- safeSize32 = 0;
- }
- return safeSize32;
+ Sk64 safeSize = ComputeSafeSize64(config, width, height, rowBytes);
+ return (safeSize.is32() ? safeSize.get32() : 0);
}
void SkBitmap::getBounds(SkRect* bounds) const {
@@ -548,6 +558,10 @@
ComputeRowBytes(this->config(), fWidth): 0);
}
+Sk64 SkBitmap::getSafeSize64() const {
+ return ComputeSafeSize64(this->config(), fWidth, fHeight, fRowBytes);
+}
+
bool SkBitmap::copyPixelsTo(void* const dst, size_t dstSize,
size_t dstRowBytes, bool preserveDstPad) const {
diff --git a/src/core/SkMallocPixelRef.cpp b/src/core/SkMallocPixelRef.cpp
index 9e2ea9c..b65197f 100644
--- a/src/core/SkMallocPixelRef.cpp
+++ b/src/core/SkMallocPixelRef.cpp
@@ -64,12 +64,13 @@
rowBytes = minRB;
}
- int64_t bigSize = (int64_t)info.fHeight * rowBytes;
- if (!sk_64_isS32(bigSize)) {
+ Sk64 bigSize;
+ bigSize.setMul(info.fHeight, rowBytes);
+ if (!bigSize.is32()) {
return NULL;
}
- size_t size = sk_64_asS32(bigSize);
+ size_t size = bigSize.get32();
void* addr = sk_malloc_flags(size, 0);
if (NULL == addr) {
return NULL;
diff --git a/src/core/SkMipMap.cpp b/src/core/SkMipMap.cpp
index ff62f4d..4888b57 100644
--- a/src/core/SkMipMap.cpp
+++ b/src/core/SkMipMap.cpp
@@ -109,15 +109,21 @@
*dst->getAddr16(x >> 1, y >> 1) = (uint16_t)collaps4444(c >> 2);
}
+static bool isPos32Bits(const Sk64& value) {
+ return !value.isNeg() && value.is32();
+}
+
SkMipMap::Level* SkMipMap::AllocLevels(int levelCount, size_t pixelSize) {
if (levelCount < 0) {
return NULL;
}
- int64_t size = sk_64_mul(levelCount + 1, sizeof(Level)) + pixelSize;
- if (!sk_64_isS32(size)) {
+ Sk64 size;
+ size.setMul(levelCount + 1, sizeof(Level));
+ size.add(SkToS32(pixelSize));
+ if (!isPos32Bits(size)) {
return NULL;
}
- return (Level*)sk_malloc_throw(sk_64_asS32(size));
+ return (Level*)sk_malloc_throw(size.get32());
}
SkMipMap* SkMipMap::Build(const SkBitmap& src) {
diff --git a/src/core/SkRegion_path.cpp b/src/core/SkRegion_path.cpp
index 95247f4..a20647c 100644
--- a/src/core/SkRegion_path.cpp
+++ b/src/core/SkRegion_path.cpp
@@ -107,6 +107,8 @@
return false;
}
+ Sk64 count, size;
+
if (pathIsInverse) {
// allow for additional X transitions to "invert" each scanline
// [ L' ... normal transitions ... R' ]
@@ -115,25 +117,25 @@
}
// compute the count with +1 and +3 slop for the working buffer
- int64_t count = sk_64_mul(maxHeight + 1, 3 + maxTransitions);
+ count.setMul(maxHeight + 1, 3 + maxTransitions);
if (pathIsInverse) {
// allow for two "empty" rows for the top and bottom
// [ Y, 1, L, R, S] == 5 (*2 for top and bottom)
- count += 10;
+ count.add(10);
}
- if (count < 0 || !sk_64_isS32(count)) {
+ if (!count.is32() || count.isNeg()) {
return false;
}
- fStorageCount = sk_64_asS32(count);
+ fStorageCount = count.get32();
- int64_t size = sk_64_mul(fStorageCount, sizeof(SkRegion::RunType));
- if (size < 0 || !sk_64_isS32(size)) {
+ size.setMul(fStorageCount, sizeof(SkRegion::RunType));
+ if (!size.is32() || size.isNeg()) {
return false;
}
- fStorage = (SkRegion::RunType*)sk_malloc_flags(sk_64_asS32(size), 0);
+ fStorage = (SkRegion::RunType*)sk_malloc_flags(size.get32(), 0);
if (NULL == fStorage) {
return false;
}
diff --git a/src/images/SkImageDecoder_libwebp.cpp b/src/images/SkImageDecoder_libwebp.cpp
index 05925d0..4a59510 100644
--- a/src/images/SkImageDecoder_libwebp.cpp
+++ b/src/images/SkImageDecoder_libwebp.cpp
@@ -80,12 +80,13 @@
// sanity check for image size that's about to be decoded.
{
- int64_t size = sk_64_mul(*width, *height);
- if (!sk_64_isS32(size)) {
+ Sk64 size;
+ size.setMul(*width, *height);
+ if (size.isNeg() || !size.is32()) {
return false;
}
// now check that if we are 4-bytes per pixel, we also don't overflow
- if (sk_64_asS32(size) > (0x7FFFFFFF >> 2)) {
+ if (size.get32() > (0x7FFFFFFF >> 2)) {
return false;
}
}
diff --git a/tests/BitmapCopyTest.cpp b/tests/BitmapCopyTest.cpp
index 455fc69..7a1d9ac 100644
--- a/tests/BitmapCopyTest.cpp
+++ b/tests/BitmapCopyTest.cpp
@@ -343,8 +343,8 @@
SkBitmap tstSafeSize;
tstSafeSize.setConfig(gPairs[i].fConfig, 100000000U,
100000000U);
- int64_t safeSize = tstSafeSize.computeSafeSize64();
- if (safeSize < 0) {
+ Sk64 safeSize = tstSafeSize.getSafeSize64();
+ if (safeSize.isNeg()) {
SkString str;
str.printf("getSafeSize64() negative: %s",
getSkConfigName(tstSafeSize));
@@ -358,20 +358,20 @@
case SkBitmap::kA8_Config:
case SkBitmap::kIndex8_Config:
- if (safeSize != 0x2386F26FC10000LL) {
+ if (safeSize.as64() != 0x2386F26FC10000LL) {
sizeFail = true;
}
break;
case SkBitmap::kRGB_565_Config:
case SkBitmap::kARGB_4444_Config:
- if (safeSize != 0x470DE4DF820000LL) {
+ if (safeSize.as64() != 0x470DE4DF820000LL) {
sizeFail = true;
}
break;
case SkBitmap::kARGB_8888_Config:
- if (safeSize != 0x8E1BC9BF040000LL) {
+ if (safeSize.as64() != 0x8E1BC9BF040000LL) {
sizeFail = true;
}
break;
@@ -381,7 +381,7 @@
}
if (sizeFail) {
SkString str;
- str.printf("computeSafeSize64() wrong size: %s",
+ str.printf("getSafeSize64() wrong size: %s",
getSkConfigName(tstSafeSize));
reporter->reportFailed(str);
}
diff --git a/tests/Sk64Test.cpp b/tests/Sk64Test.cpp
index d668e54..1777d24 100644
--- a/tests/Sk64Test.cpp
+++ b/tests/Sk64Test.cpp
@@ -7,7 +7,6 @@
#include "Test.h"
#include "TestClassDef.h"
-#include "Sk64.h"
#include "SkRandom.h"
#include <math.h>
@@ -93,8 +92,8 @@
}
for (i = 0; i < 1000; i++) {
- a.set64(rand.next64());
- b.set64(rand.next64());
+ rand.next64(&a); //a.fHi >>= 1; // avoid overflow
+ rand.next64(&b); //b.fHi >>= 1; // avoid overflow
if (!(i & 3)) // want to explicitly test these cases
{