Allow SkLazyPixelRef to use SkScaledImageCache

src/lazy/SkLazyPixelRef.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Sk64.h"
 #include "SkLazyPixelRef.h"
 #include "SkColorTable.h"
 #include "SkData.h"
 #include "SkImageCache.h"
 #include "SkImagePriv.h"
+#include "SkScaledImageCache.h"
 
 #if LAZY_CACHE_STATS
 #include "SkThread.h"
 
 int32_t SkLazyPixelRef::gCacheHits;
 int32_t SkLazyPixelRef::gCacheMisses;
 #endif
 
+

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

unnecessary newline.

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

Done.

 SkLazyPixelRef::SkLazyPixelRef(SkData* data, SkBitmapFactory::DecodeProc proc, SkImageCache* cache)
     // Pass NULL for the Mutex so that the default (ring buffer) will be used.
     : INHERITED(NULL)
+    , fErrorInDecoding(false)
     , fDecodeProc(proc)
     , fImageCache(cache)
-    , fCacheId(SkImageCache::UNINITIALIZED_ID)
-    , fRowBytes(0) {
+    , fRowBytes(0)
+    , fAllocator(NULL) {
     SkASSERT(fDecodeProc != NULL);
     if (NULL == data) {
         fData = SkData::NewEmpty();
         fErrorInDecoding = true;
     } else {
         fData = data;
         fData->ref();
         fErrorInDecoding = data->size() == 0;
     }
-    SkASSERT(cache != NULL);
-    cache->ref();
+    if (fImageCache != NULL) {
+        fImageCache->ref();
+        fCacheId = SkImageCache::UNINITIALIZED_ID;
+    } else {
+        fScaledCacheId = NULL;
+    }
 
     // mark as uninitialized -- all fields are -1
     memset(&fLazilyCachedInfo, 0xFF, sizeof(fLazilyCachedInfo));
 
     // Since this pixel ref bases its data on encoded data, it should never change.
     this->setImmutable();
 }
 
 SkLazyPixelRef::~SkLazyPixelRef() {
     SkASSERT(fData != NULL);
     fData->unref();
+    SkSafeUnref(fAllocator);
+    if (NULL == fImageCache) {
+        if (fScaledCacheId != NULL) {
+            SkScaledImageCache::Unlock(fScaledCacheId);
+            // SkScaledImageCache needs a throwAwayCache(id) method.
+        }
+        return;
+    }
     SkASSERT(fImageCache);
     if (fCacheId != SkImageCache::UNINITIALIZED_ID) {
         fImageCache->throwAwayCache(fCacheId);
     }
     fImageCache->unref();
 }
 
 static size_t ComputeMinRowBytesAndSize(const SkImage::Info& info, size_t* rowBytes) {
     *rowBytes = SkImageMinRowBytes(info);
 
@@ skipping 11 matching lines @@
         SkImage::Info info;
         fErrorInDecoding = !fDecodeProc(fData->data(), fData->size(), &info, NULL);
         if (fErrorInDecoding) {
             return NULL;
         }
         fLazilyCachedInfo = info;
     }
     return &fLazilyCachedInfo;
 }
 
+/**
+   Returns bitmap->getPixels() on success; NULL on failure */
+static void* decode_into_bitmap(SkImage::Info* info,
+                                 SkBitmapFactory::DecodeProc decodeProc,
+                                 size_t* rowBytes,
+                                 SkData* data,
+                                 SkBitmap::Allocator* allocator,
+                                 SkBitmap* bm) {
+    SkASSERT(info && decodeProc && rowBytes && data && bm);
+    if (!(bm->setConfig(SkImageInfoToBitmapConfig(*info), info->fWidth,
+                        info->fHeight, *rowBytes, info->fAlphaType)
+          && bm->allocPixels(allocator, NULL))) {
+        return NULL;
+    }
+    SkBitmapFactory::Target target;
+    target.fAddr = bm->getPixels();
+    target.fRowBytes = bm->rowBytes();
+    *rowBytes = target.fRowBytes;
+    if (!decodeProc(data->data(), data->size(), info, &target)) {
+        return NULL;
+    }
+    return target.fAddr;
+}
+
+void* SkLazyPixelRef::lockScaledImageCachePixels() {
+    SkASSERT(!fErrorInDecoding);
+    SkASSERT(NULL == fImageCache);
+    SkBitmap bitmap;
+    if (fLazilyCachedInfo.fWidth > 0) {  // fInfo already populated

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

inline helper function?

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

changed

+        fScaledCacheId = SkScaledImageCache::FindAndLock(
+                                                     this->getGenerationID(),
+                                                     fLazilyCachedInfo.fWidth,
+                                                     fLazilyCachedInfo.fHeight,
+                                                     &bitmap);
+        if (fScaledCacheId != NULL) {
+            SkAutoLockPixels autoLockPixels(bitmap);
+            void* pixels = bitmap.getPixels();
+            SkASSERT(NULL != pixels);
+            // At this point, the autoLockPixels will unlockPixels()
+            // to remove bitmap's lock on the pixels.  We will then
+            // destroy bitmap.  The *only* guarantee that this pointer
+            // remains valid is the guarantee made by
+            // SkScaledImageCache that it will not destroy the *other*
+            // bitmap (SkScaledImageCache::Rec.fBitmap) that holds a
+            // reference to the concrete PixelRef while this record is
+            // locked.
+            return pixels;
+        }  // else cache has been purged, must re-decode.
+    } else {  // first time through this code, must populate info
+        (void)this->getCachedInfo();

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

The idea behind getCachedInfo returning an info pointer is that we never refer
directly to fLazilyCachedInfo (except inside getCachedInfo and the
initialization). One way we could preserve that model would be to write the
function as follows:
{
// Asserts
SkBitmap bitmap;

SkImage::Info* info = this->getCachedInfo();
if (NULL == info) {
    return NULL
}

fScaledCacheId = SkScaledImageCache::FindAndLock(...);
if (fScaledCacheId != NULL) {
    SkAutoLockPixels alp(bitmap);
    void* pixels = bitmap.getPixels();
    SkASSERT(NULL != pixels);
    // Explanation
    return pixels;
}

void* pixels = decode_into_bitmap(info, ...);
if (NULL == pixels) {
    fErrorInDecoding = true;
    return NULL;
}
fScaledCacheId = SkScaledImageCache::AddAndLock(...);
return pixels;
}

It's probably easier to follow, but it also means that we'll be calling
FindAndLock the first time, when we know it would fail. Just a thought. If we
end up initializing the SkPixelRef with the proper Info like we discussed, we'll
still have to come up with a solution to that problem, but perhaps it can wait
til then.

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

Done.

+        if (fErrorInDecoding) {
+            return NULL;
+        }
+    }
+    SkASSERT(fLazilyCachedInfo.fWidth > 0);
+    void* pixels = decode_into_bitmap(&fLazilyCachedInfo, fDecodeProc,
+                                      &fRowBytes, fData, fAllocator, &bitmap);
+    if (NULL == pixels) {
+        fErrorInDecoding = true;
+        return NULL;
+    }
+    fScaledCacheId = SkScaledImageCache::AddAndLock(this->getGenerationID(),
+                                                    fLazilyCachedInfo.fWidth,
+                                                    fLazilyCachedInfo.fHeight,
+                                                    bitmap);
+    return pixels;
+}
+
 void* SkLazyPixelRef::onLockPixels(SkColorTable**) {
     if (fErrorInDecoding) {
         return NULL;
     }
+    if (NULL == fImageCache) {
+        return this->lockScaledImageCachePixels();
+    } else {
+        return this->lockImageCachePixels();
+    }
+}
+
+void* SkLazyPixelRef::lockImageCachePixels() {
+    SkASSERT(fImageCache != NULL);
+    SkASSERT(!fErrorInDecoding);
     SkBitmapFactory::Target target;
     // Check to see if the pixels still exist in the cache.
     if (SkImageCache::UNINITIALIZED_ID == fCacheId) {
         target.fAddr = NULL;
     } else {
         SkImageCache::DataStatus status;
         target.fAddr = fImageCache->pinCache(fCacheId, &status);
         if (target.fAddr == NULL) {
             fCacheId = SkImageCache::UNINITIALIZED_ID;
         } else {
@@ skipping 41 matching lines @@
         fImageCache->throwAwayCache(fCacheId);
         fCacheId = SkImageCache::UNINITIALIZED_ID;
         return NULL;
     }
     // Upon success, store fRowBytes so it can be used in case pinCache later returns purged memory.
     fRowBytes = target.fRowBytes;
     return target.fAddr;
 }
 
 void SkLazyPixelRef::onUnlockPixels() {
-    if (fErrorInDecoding) {
+    if (fErrorInDecoding || (0 == fCacheId)) {

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

Maybe a comment here that 0 == fCacheId is the same as saying NULL ==
fScaledCacheId?

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

Cleaned up the code to make this clear.

         return;
     }
-    if (fCacheId != SkImageCache::UNINITIALIZED_ID) {
+    if (NULL == fImageCache) {
+        SkScaledImageCache::Unlock(fScaledCacheId);
+        fScaledCacheId = NULL;
+        return;
+    } else {  // use fImageCache
         fImageCache->releaseCache(fCacheId);
     }
 }
 
 SkData* SkLazyPixelRef::onRefEncodedData() {
     fData->ref();
     return fData;
 }
 
-#include "SkImagePriv.h"
-
 static bool init_from_info(SkBitmap* bm, const SkImage::Info& info,
                            size_t rowBytes) {
     SkBitmap::Config config = SkImageInfoToBitmapConfig(info);
     if (SkBitmap::kNo_Config == config) {
         return false;
     }
 
     return bm->setConfig(config, info.fWidth, info.fHeight, rowBytes, info.fAlphaType)
            &&
            bm->allocPixels();
@@ skipping 27 matching lines @@
 
     target.fAddr = tmp.getPixels();
     fErrorInDecoding = !fDecodeProc(fData->data(), fData->size(), &info, &target);
     if (fErrorInDecoding) {
         return false;
     }
 
     *bitmap = tmp;
     return true;
 }
+
+void SkLazyPixelRef::setAllocator(SkBitmap::Allocator* allocator) {
+    SkRefCnt_SafeAssign(fAllocator, allocator);
+}