Remove the unused 16-bit gradient cache
BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2343863002
Review-Url: https://codereview.chromium.org/2343863002
diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp
index 14e6784..8f07419 100644
--- a/src/effects/gradients/SkGradientShader.cpp
+++ b/src/effects/gradients/SkGradientShader.cpp
@@ -306,69 +306,15 @@
, fCacheDither(dither)
, fShader(shader)
{
- // Only initialize the cache in getCache16/32.
- fCache16 = nullptr;
+ // Only initialize the cache in getCache32.
fCache32 = nullptr;
- fCache16Storage = nullptr;
fCache32PixelRef = nullptr;
}
SkGradientShaderBase::GradientShaderCache::~GradientShaderCache() {
- sk_free(fCache16Storage);
SkSafeUnref(fCache32PixelRef);
}
-#define Fixed_To_Dot8(x) (((x) + 0x80) >> 8)
-
-/** We take the original colors, not our premultiplied PMColors, since we can
- build a 16bit table as long as the original colors are opaque, even if the
- paint specifies a non-opaque alpha.
-*/
-void SkGradientShaderBase::GradientShaderCache::Build16bitCache(
- uint16_t cache[], SkColor c0, SkColor c1, int count, bool dither) {
- SkASSERT(count > 1);
- SkASSERT(SkColorGetA(c0) == 0xFF);
- SkASSERT(SkColorGetA(c1) == 0xFF);
-
- SkFixed r = SkColorGetR(c0);
- SkFixed g = SkColorGetG(c0);
- SkFixed b = SkColorGetB(c0);
-
- SkFixed dr = SkIntToFixed(SkColorGetR(c1) - r) / (count - 1);
- SkFixed dg = SkIntToFixed(SkColorGetG(c1) - g) / (count - 1);
- SkFixed db = SkIntToFixed(SkColorGetB(c1) - b) / (count - 1);
-
- r = SkIntToFixed(r) + 0x8000;
- g = SkIntToFixed(g) + 0x8000;
- b = SkIntToFixed(b) + 0x8000;
-
- if (dither) {
- do {
- unsigned rr = r >> 16;
- unsigned gg = g >> 16;
- unsigned bb = b >> 16;
- cache[0] = SkPackRGB16(SkR32ToR16(rr), SkG32ToG16(gg), SkB32ToB16(bb));
- cache[kCache16Count] = SkDitherPack888ToRGB16(rr, gg, bb);
- cache += 1;
- r += dr;
- g += dg;
- b += db;
- } while (--count != 0);
- } else {
- do {
- unsigned rr = r >> 16;
- unsigned gg = g >> 16;
- unsigned bb = b >> 16;
- cache[0] = SkPackRGB16(SkR32ToR16(rr), SkG32ToG16(gg), SkB32ToB16(bb));
- cache[kCache16Count] = cache[0];
- cache += 1;
- r += dr;
- g += dg;
- b += db;
- } while (--count != 0);
- }
-}
-
/*
* r,g,b used to be SkFixed, but on gcc (4.2.1 mac and 4.6.3 goobuntu) in
* release builds, we saw a compiler error where the 0xFF parameter in
@@ -525,39 +471,6 @@
return x - (x >> 16);
}
-const uint16_t* SkGradientShaderBase::GradientShaderCache::getCache16() {
- fCache16InitOnce(SkGradientShaderBase::GradientShaderCache::initCache16, this);
- SkASSERT(fCache16);
- return fCache16;
-}
-
-void SkGradientShaderBase::GradientShaderCache::initCache16(GradientShaderCache* cache) {
- // double the count for dither entries
- const int entryCount = kCache16Count * 2;
- const size_t allocSize = sizeof(uint16_t) * entryCount;
-
- SkASSERT(nullptr == cache->fCache16Storage);
- cache->fCache16Storage = (uint16_t*)sk_malloc_throw(allocSize);
- cache->fCache16 = cache->fCache16Storage;
- if (cache->fShader.fColorCount == 2) {
- Build16bitCache(cache->fCache16, cache->fShader.fOrigColors[0],
- cache->fShader.fOrigColors[1], kCache16Count, cache->fCacheDither);
- } else {
- Rec* rec = cache->fShader.fRecs;
- int prevIndex = 0;
- for (int i = 1; i < cache->fShader.fColorCount; i++) {
- int nextIndex = SkFixedToFFFF(rec[i].fPos) >> kCache16Shift;
- SkASSERT(nextIndex < kCache16Count);
-
- if (nextIndex > prevIndex)
- Build16bitCache(cache->fCache16 + prevIndex, cache->fShader.fOrigColors[i-1],
- cache->fShader.fOrigColors[i], nextIndex - prevIndex + 1,
- cache->fCacheDither);
- prevIndex = nextIndex;
- }
- }
-}
-
const SkPMColor* SkGradientShaderBase::GradientShaderCache::getCache32() {
fCache32InitOnce(SkGradientShaderBase::GradientShaderCache::initCache32, this);
SkASSERT(fCache32);
diff --git a/src/effects/gradients/SkGradientShaderPriv.h b/src/effects/gradients/SkGradientShaderPriv.h
index ec70929..2e35a47 100644
--- a/src/effects/gradients/SkGradientShaderPriv.h
+++ b/src/effects/gradients/SkGradientShaderPriv.h
@@ -117,13 +117,12 @@
SkGradientShaderBase(const Descriptor& desc, const SkMatrix& ptsToUnit);
virtual ~SkGradientShaderBase();
- // The cache is initialized on-demand when getCache16/32 is called.
+ // The cache is initialized on-demand when getCache32 is called.
class GradientShaderCache : public SkRefCnt {
public:
GradientShaderCache(U8CPU alpha, bool dither, const SkGradientShaderBase& shader);
~GradientShaderCache();
- const uint16_t* getCache16();
const SkPMColor* getCache32();
SkMallocPixelRef* getCache32PixelRef() const { return fCache32PixelRef; }
@@ -132,12 +131,9 @@
bool getDither() const { return fCacheDither; }
private:
- // Working pointers. If either is nullptr, we need to recompute the corresponding
- // cache values.
- uint16_t* fCache16;
+ // Working pointer. If it's nullptr, we need to recompute the cache values.
SkPMColor* fCache32;
- uint16_t* fCache16Storage; // Storage for fCache16, allocated on demand.
SkMallocPixelRef* fCache32PixelRef;
const unsigned fCacheAlpha; // The alpha value we used when we computed the cache.
// Larger than 8bits so we can store uninitialized
@@ -146,14 +142,11 @@
const SkGradientShaderBase& fShader;
- // Make sure we only initialize the caches once.
- SkOnce fCache16InitOnce,
- fCache32InitOnce;
+ // Make sure we only initialize the cache once.
+ SkOnce fCache32InitOnce;
- static void initCache16(GradientShaderCache* cache);
static void initCache32(GradientShaderCache* cache);
- static void Build16bitCache(uint16_t[], SkColor c0, SkColor c1, int count, bool dither);
static void Build32bitCache(SkPMColor[], SkColor c0, SkColor c1, int count,
U8CPU alpha, uint32_t gradFlags, bool dither);
};
@@ -184,13 +177,6 @@
enum {
/// Seems like enough for visual accuracy. TODO: if pos[] deserves
/// it, use a larger cache.
- kCache16Bits = 8,
- kCache16Count = (1 << kCache16Bits),
- kCache16Shift = 16 - kCache16Bits,
- kSqrt16Shift = 8 - kCache16Bits,
-
- /// Seems like enough for visual accuracy. TODO: if pos[] deserves
- /// it, use a larger cache.
kCache32Bits = 8,
kCache32Count = (1 << kCache32Bits),
kCache32Shift = 16 - kCache32Bits,
@@ -199,7 +185,6 @@
/// This value is used to *read* the dither cache; it may be 0
/// if dithering is disabled.
kDitherStride32 = kCache32Count,
- kDitherStride16 = kCache16Count,
};
uint32_t getGradFlags() const { return fGradFlags; }
@@ -276,14 +261,6 @@
return toggle ^ SkGradientShaderBase::kDitherStride32;
}
-static inline int init_dither_toggle16(int x, int y) {
- return ((x ^ y) & 1) * SkGradientShaderBase::kDitherStride16;
-}
-
-static inline int next_dither_toggle16(int toggle) {
- return toggle ^ SkGradientShaderBase::kDitherStride16;
-}
-
///////////////////////////////////////////////////////////////////////////////
#if SK_SUPPORT_GPU