Allow SkLazyPixelRef to use SkScaledImageCache

src/core/SkScaledImageCache.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkScaledImageCache.h"
 #include "SkMipMap.h"
+#include "SkOnce.h"
 #include "SkPixelRef.h"
 #include "SkRect.h"
 
 #ifndef SK_DEFAULT_IMAGE_CACHE_LIMIT
     #define SK_DEFAULT_IMAGE_CACHE_LIMIT     (2 * 1024 * 1024)
 #endif
 
+static inline SkScaledImageCache::ID* rec_to_id(SkScaledImageCache::Rec* rec) {
+    return reinterpret_cast<SkScaledImageCache::ID*>(rec);
+}
+
+static inline SkScaledImageCache::Rec* id_to_rec(SkScaledImageCache::ID* id) {
+    return reinterpret_cast<SkScaledImageCache::Rec*>(id);
+}
 
  // Implemented from en.wikipedia.org/wiki/MurmurHash.
 static uint32_t compute_hash(const uint32_t data[], int count) {
     uint32_t hash = 0;
 
     for (int i = 0; i < count; ++i) {
         uint32_t k = data[i];
         k *= 0xcc9e2d51;
         k = (k << 15) | (k >> 17);
         k *= 0x1b873593;
@@ skipping 20 matching lines @@
         if (!pr) {
             return false;
         }
 
         size_t x, y;
         SkTDivMod(bm.pixelRefOffset(), bm.rowBytes(), &y, &x);
         x >>= 2;
 
         fGenID = pr->getGenerationID();
         fBounds.set(x, y, x + bm.width(), y + bm.height());
-        fScaleX = scaleX;
-        fScaleY = scaleY;
+        fScaleX = SkScalarToFloat(scaleX);
+        fScaleY = SkScalarToFloat(scaleY);
 
         fHash = compute_hash(&fGenID, 7);
         return true;
     }
+    void init(uint32_t genID,
+              SkScalar scaleX,

[reed1, 2013/10/24 21:07:04]

do we *always* pass in 1.0 for these today? If so, and so it matches more
closely the external API, lets not have these two parameters, and just hard-code
1.0 into fScale[X,Y]. We already make other assumptions for this entry-point
(e.g. that our offset is 0,0).

[hal.canary, 2013/10/25 16:37:10]

I have just cleaned this code up a lot.  Now there is a single initialization
function.

+              SkScalar scaleY,
+              int32_t width,
+              int32_t height) {
+        fGenID = genID;
+        fScaleX = SkScalarToFloat(scaleX);
+        fScaleY = SkScalarToFloat(scaleY);
+        fBounds.set(0, 0, width, height);
+        fHash = compute_hash(&fGenID, 7);
+    }
 
     bool operator<(const Key& other) const {
         const uint32_t* a = &fGenID;
         const uint32_t* b = &other.fGenID;
         for (int i = 0; i < 7; ++i) {
             if (a[i] < b[i]) {
                 return true;
             }
             if (a[i] > b[i]) {
                 return false;
@@ skipping 94 matching lines @@
 SkScaledImageCache::~SkScaledImageCache() {
     Rec* rec = fHead;
     while (rec) {
         Rec* next = rec->fNext;
         SkDELETE(rec);
         rec = next;
     }
     delete fHash;
 }
 
+static inline SkScaledImageCache::Rec* find_rec_in_list(
+        SkScaledImageCache::Rec* head, const Key & key) {
+    SkScaledImageCache::Rec* rec = head;
+    while ((rec != NULL) && !(rec->fKey == key)) {

[reed1, 2013/10/24 21:07:04]

!(a == b)   ?

seems like we should have != operator... MUCH easier to read from afar

[hal.canary, 2013/10/25 16:37:10]

Done.

+        rec = rec->fNext;
+    }
+    return rec;
+}
+
 SkScaledImageCache::Rec* SkScaledImageCache::findAndLock(const SkBitmap& orig,
                                                         SkScalar scaleX,
                                                         SkScalar scaleY) {
     Key key;
     if (!key.init(orig, scaleX, scaleY)) {
         return NULL;
     }
 
 #ifdef USE_HASH
     Rec* rec = fHash->find(key);

[scroggo, 2013/10/24 20:41:39]

Can this whole #if #else be a helper function?

Rec* findRec(Key key) {
#ifdef USE_HASH
    return fHash->find(key)
#else
    return find_rec_in_list(fHead, key);
#endif
}

[hal.canary, 2013/10/25 16:37:10]

I have move some things around to remove this repetition.

 #else
-    Rec* rec = fHead;
-    while (rec != NULL) {
-        if (rec->fKey == key) {
-            break;
-        }
-        rec = rec->fNext;
-    }
+    Rec* rec = find_rec_in_list(fHead, key);
 #endif
-
     if (rec) {
         this->moveToHead(rec);  // for our LRU
         rec->fLockCount += 1;
     }
     return rec;
 }
 
+
+SkScaledImageCache::ID* SkScaledImageCache::findAndLock(
+                                uint32_t pixelGenerationID,
+                                int32_t width,
+                                int32_t height,
+                                SkBitmap* scaled) {
+    Key key;
+    key.init(pixelGenerationID, SK_Scalar1, SK_Scalar1, width, height);
+#ifdef USE_HASH
+    Rec* rec = fHash->find(key);
+#else
+    Rec* rec = find_rec_in_list(fHead, key);
+#endif
+    if (rec) {
+        this->moveToHead(rec);  // for our LRU
+        rec->fLockCount += 1;
+        SkASSERT(NULL == rec->fMip);
+        SkASSERT(rec->fBitmap.pixelRef());
+        *scaled = rec->fBitmap;
+    }
+    return rec_to_id(rec);
+}
+
 SkScaledImageCache::ID* SkScaledImageCache::findAndLock(const SkBitmap& orig,
                                                         SkScalar scaleX,
                                                         SkScalar scaleY,
                                                         SkBitmap* scaled) {
     if (0 == scaleX || 0 == scaleY) {
         // degenerate, and the key we use for mipmaps
         return NULL;
     }
 
     Rec* rec = this->findAndLock(orig, scaleX, scaleY);
     if (rec) {
         SkASSERT(NULL == rec->fMip);
         SkASSERT(rec->fBitmap.pixelRef());
         *scaled = rec->fBitmap;
     }
-    return (ID*)rec;
+    return rec_to_id(rec);
 }
 
 SkScaledImageCache::ID* SkScaledImageCache::findAndLockMip(const SkBitmap& orig,
                                                            SkMipMap const ** mip) {
     Rec* rec = this->findAndLock(orig, 0, 0);
     if (rec) {
         SkASSERT(rec->fMip);
         SkASSERT(NULL == rec->fBitmap.pixelRef());
         *mip = rec->fMip;
     }
-    return (ID*)rec;
+    return rec_to_id(rec);
+}
+
+SkScaledImageCache::ID* SkScaledImageCache::addAndLock(
+                               uint32_t pixelGenerationID,
+                               int32_t width,
+                               int32_t height,
+                               const SkBitmap& scaled) {
+    Key key;
+    key.init(pixelGenerationID, SK_Scalar1, SK_Scalar1, width, height);
+    Rec* rec = SkNEW_ARGS(Rec, (key, scaled));
+    this->addToHead(rec);
+    SkASSERT(1 == rec->fLockCount);
+
+#ifdef USE_HASH
+    fHash->add(rec);
+#endif
+
+    // We may (now) be overbudget, so see if we need to purge something.
+    this->purgeAsNeeded();
+    return rec_to_id(rec);
 }
 
 SkScaledImageCache::ID* SkScaledImageCache::addAndLock(const SkBitmap& orig,
                                                        SkScalar scaleX,
                                                        SkScalar scaleY,
                                                        const SkBitmap& scaled) {
     if (0 == scaleX || 0 == scaleY) {
         // degenerate, and the key we use for mipmaps
         return NULL;
     }
 
     Key key;
     if (!key.init(orig, scaleX, scaleY)) {
         return NULL;
     }
 
     Rec* rec = SkNEW_ARGS(Rec, (key, scaled));
     this->addToHead(rec);
     SkASSERT(1 == rec->fLockCount);
 
 #ifdef USE_HASH
     fHash->add(rec);
 #endif
 
     // We may (now) be overbudget, so see if we need to purge something.
     this->purgeAsNeeded();
-    return (ID*)rec;
+    return rec_to_id(rec);
 }
 
 SkScaledImageCache::ID* SkScaledImageCache::addAndLockMip(const SkBitmap& orig,
                                                           const SkMipMap* mip) {
     Key key;
     if (!key.init(orig, 0, 0)) {
         return NULL;
     }
 
     Rec* rec = SkNEW_ARGS(Rec, (key, mip));
     this->addToHead(rec);
     SkASSERT(1 == rec->fLockCount);
 
 #ifdef USE_HASH
     fHash->add(rec);
 #endif
 
     // We may (now) be overbudget, so see if we need to purge something.
     this->purgeAsNeeded();
-    return (ID*)rec;
+    return rec_to_id(rec);
 }
 
 void SkScaledImageCache::unlock(SkScaledImageCache::ID* id) {
     SkASSERT(id);
 
 #ifdef SK_DEBUG
     {
         bool found = false;
         Rec* rec = fHead;
         while (rec != NULL) {
-            if ((ID*)rec == id) {
+            if (rec == id_to_rec(id)) {
                 found = true;
                 break;
             }
             rec = rec->fNext;
         }
         SkASSERT(found);
     }
 #endif
-    Rec* rec = (Rec*)id;
+    Rec* rec = id_to_rec(id);
     SkASSERT(rec->fLockCount > 0);
     rec->fLockCount -= 1;
 
     // we may have been over-budget, but now have released something, so check
     // if we should purge.
     if (0 == rec->fLockCount) {
         this->purgeAsNeeded();
     }
 }
 
@@ skipping 136 matching lines @@
     SkASSERT(0 == used);
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkThread.h"
 
 SK_DECLARE_STATIC_MUTEX(gMutex);
 
+static void create_cache(SkScaledImageCache** cache) {
+    *cache = SkNEW_ARGS(SkScaledImageCache, (SK_DEFAULT_IMAGE_CACHE_LIMIT));
+}
+
 static SkScaledImageCache* get_cache() {
-    static SkScaledImageCache* gCache;
-    if (!gCache) {
-        gCache = SkNEW_ARGS(SkScaledImageCache, (SK_DEFAULT_IMAGE_CACHE_LIMIT));
-    }
+    static SkScaledImageCache* gCache(NULL);
+    SK_DECLARE_STATIC_ONCE(create_cache_once);
+    SkOnce<SkScaledImageCache**>(&create_cache_once, create_cache, &gCache);
+    SkASSERT(NULL != gCache);
     return gCache;
 }
 
+
+SkScaledImageCache::ID* SkScaledImageCache::FindAndLock(
+                                uint32_t pixelGenerationID,
+                                int32_t width,
+                                int32_t height,
+                                SkBitmap* scaled) {
+    SkAutoMutexAcquire am(gMutex);
+    return get_cache()->findAndLock(pixelGenerationID, width, height, scaled);
+}
+
+SkScaledImageCache::ID* SkScaledImageCache::AddAndLock(
+                               uint32_t pixelGenerationID,
+                               int32_t width,
+                               int32_t height,
+                               const SkBitmap& scaled) {
+    SkAutoMutexAcquire am(gMutex);
+    return get_cache()->addAndLock(pixelGenerationID, width, height, scaled);
+}
+
+
 SkScaledImageCache::ID* SkScaledImageCache::FindAndLock(const SkBitmap& orig,
                                                         SkScalar scaleX,
                                                         SkScalar scaleY,
                                                         SkBitmap* scaled) {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->findAndLock(orig, scaleX, scaleY, scaled);
 }
 
 SkScaledImageCache::ID* SkScaledImageCache::FindAndLockMip(const SkBitmap& orig,
                                                        SkMipMap const ** mip) {
@@ skipping 43 matching lines @@
     return SkScaledImageCache::GetBytesUsed();
 }
 
 size_t SkGraphics::GetImageCacheByteLimit() {
     return SkScaledImageCache::GetByteLimit();
 }
 
 size_t SkGraphics::SetImageCacheByteLimit(size_t newLimit) {
     return SkScaledImageCache::SetByteLimit(newLimit);
 }