add mipmaps to scaledimagecache

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 "SkPixelRef.h"
 #include "SkRect.h"
 
 #ifndef SK_DEFAULT_IMAGE_CACHE_LIMIT
     #define SK_DEFAULT_IMAGE_CACHE_LIMIT     (2 * 1024 * 1024)
 #endif
 
 #if 1
  // Implemented from en.wikipedia.org/wiki/MurmurHash.
 static uint32_t compute_hash(const uint32_t data[], int count) {
@@ skipping 84 matching lines @@
     uint32_t    fHash;
     uint32_t    fGenID;
     float       fScaleX;
     float       fScaleY;
     SkIRect     fBounds;
 };
 
 struct SkScaledImageCache::Rec {
     Rec(const Key& key, const SkBitmap& bm) : fKey(key), fBitmap(bm) {
         fLockCount = 1;
+        fMip = NULL;
     }
-
+    
+    Rec(const Key& key, const SkMipMap* mip) : fKey(key) {
+        fLockCount = 1;
+        fMip = mip;
+        mip->ref();
+    }
+    
+    ~Rec() {
+        SkSafeUnref(fMip);
+    }
+    
     size_t bytesUsed() const {
-        return fBitmap.getSize();
+        return fMip ? fMip->getSize() : fBitmap.getSize();
     }
 
     Rec*    fNext;
     Rec*    fPrev;
 
     // this guy wants to be 64bit aligned
     Key     fKey;
 
     int32_t fLockCount;
+    
+    // we use either fBitmap or fMip, but not both
     SkBitmap fBitmap;
+    const SkMipMap* fMip;
 };
 
 SkScaledImageCache::SkScaledImageCache(size_t byteLimit) {
     fHead = NULL;
     fTail = NULL;
     fBytesUsed = 0;
     fByteLimit = byteLimit;
     fCount = 0;
 }
 
 SkScaledImageCache::~SkScaledImageCache() {
     Rec* rec = fHead;
     while (rec) {
         Rec* next = rec->fNext;
         SkDELETE(rec);
         rec = next;
     }
 }
 
+SkScaledImageCache::Rec* SkScaledImageCache::findAndLock(const SkBitmap& orig,
+                                                        SkScalar scaleX,
+                                                        SkScalar scaleY) {
+    Key key;
+    if (!key.init(orig, scaleX, scaleY)) {
+        return NULL;
+    }
+    
+    Rec* rec = fHead;
+    while (rec != NULL) {
+        if (rec->fKey == key) {
+            this->moveToHead(rec);  // for our LRU
+            rec->fLockCount += 1;
+            return rec;
+        }
+        rec = rec->fNext;
+    }
+    return NULL;
+}
+
 SkScaledImageCache::ID* SkScaledImageCache::findAndLock(const SkBitmap& orig,
                                                         SkScalar scaleX,
                                                         SkScalar scaleY,
                                                         SkBitmap* scaled) {
-    Key key;
-    if (!key.init(orig, scaleX, scaleY)) {
+    if (0 == scaleX || 0 == scaleY) {
+        // degenerate, and the key we use for mipmaps
         return NULL;
     }
 
-    Rec* rec = fHead;
-    while (rec != NULL) {
-        if (rec->fKey == key) {
-            this->moveToHead(rec);  // for our LRU
-            rec->fLockCount += 1;
-            *scaled = rec->fBitmap;
-//            SkDebugf("Found: [%d %d] %d\n", rec->fBitmap.width(), rec->fBitmap.height(), rec->fLockCount);
-            return (ID*)rec;
-        }
-        rec = rec->fNext;
+    Rec* rec = this->findAndLock(orig, scaleX, scaleY);
+    if (rec) {
+        SkASSERT(NULL == rec->fMip);
+        SkASSERT(rec->fBitmap.pixelRef());
+        *scaled = rec->fBitmap;
     }
-    return NULL;
+    return (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;
 }
 
 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);
-
-//    SkDebugf("Added: [%d %d]\n", rec->fBitmap.width(), rec->fBitmap.height());
-
+    
     // We may (now) be overbudget, so see if we need to purge something.
     this->purgeAsNeeded();
     return (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);
+    
+    // We may (now) be overbudget, so see if we need to purge something.
+    this->purgeAsNeeded();
+    return (ID*)rec;
 }
 
 void SkScaledImageCache::unlock(SkScaledImageCache::ID* id) {
     SkASSERT(id);
 
 #ifdef SK_DEBUG
     {
         bool found = false;
         Rec* rec = fHead;
         while (rec != NULL) {
@@ skipping 171 matching lines @@
 }
 
 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) {
+    SkAutoMutexAcquire am(gMutex);
+    return get_cache()->findAndLockMip(orig, mip);
+}
+
 SkScaledImageCache::ID* SkScaledImageCache::AddAndLock(const SkBitmap& orig,
                                                        SkScalar scaleX,
                                                        SkScalar scaleY,
                                                        const SkBitmap& scaled) {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->addAndLock(orig, scaleX, scaleY, scaled);
 }
 
+SkScaledImageCache::ID* SkScaledImageCache::AddAndLockMip(const SkBitmap& orig,
+                                                          const SkMipMap* mip) {
+    SkAutoMutexAcquire am(gMutex);
+    return get_cache()->addAndLockMip(orig, mip);
+}
+
 void SkScaledImageCache::Unlock(SkScaledImageCache::ID* id) {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->unlock(id);
 }
 
 size_t SkScaledImageCache::GetBytesUsed() {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->getBytesUsed();
 }
 
@@ skipping 16 matching lines @@
 }
 
 size_t SkGraphics::GetImageCacheByteLimit() {
     return SkScaledImageCache::GetByteLimit();
 }
 
 size_t SkGraphics::SetImageCacheByteLimit(size_t newLimit) {
     return SkScaledImageCache::SetByteLimit(newLimit);
 }