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
 
 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) {
+    , fCacheId(0)
+    , fRowBytes(0)
+    , fAllocator(NULL) {
     SkASSERT(fDecodeProc != NULL);
+    SkASSERT(0 == SkImageCache::UNINITIALIZED_ID);  // for fCacheId
     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();
+    }
 
     // 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() {

[scroggo, 2013/10/23 23:38:33]

Now that we ref fAllocator, it needs to be unref'ed in the destructor.
(SkSafeUnref)

[hal.canary, 2013/10/24 14:21:55]

Done.

     SkASSERT(fData != NULL);
     fData->unref();
+    if (NULL == fImageCache) {
+        if (fCacheId != 0) {
+            SkScaledImageCache::Unlock((SkScaledImageCache::ID *)(fCacheId));
+        }
+        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);

[scroggo, 2013/10/23 23:38:33]

Maybe assert NULL == fImageCache as well?

[hal.canary, 2013/10/24 14:21:55]

Done.

+    SkBitmap bitmap;
+    if (fLazilyCachedInfo.fWidth > 0) {  // fInfo already populated
+        fCacheId = (intptr_t)(SkScaledImageCache::FindAndLock(
+                                       this->getGenerationID(),
+                                       fLazilyCachedInfo.fWidth,
+                                       fLazilyCachedInfo.fHeight,
+                                       &bitmap));
+        if (fCacheId != 0) {
+            SkAutoLockPixels autoLockPixels(bitmap);

[scroggo, 2013/10/23 23:38:33]

Maybe this is correct, but it seems odd to me:

- lockPixels() ensured that bitmap had pixels
- getPixels() returns a pointer to those pixels
- unlockPixels() makes it so we're no longer guaranteed that those pixels are
valid
- return potentially invalid pixels.

I guess we really know that the pixels are valid due to FindAndLock, which
guaranteed that they're valid until Unlock is called.

[hal.canary, 2013/10/24 14:21:55]

This is confusing enough that I will add comments explaining it.

            // 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.

+            void* pixels = bitmap.getPixels();
+            SkASSERT(NULL != pixels);
+            return pixels;
+        }  // else cache has been purged, must re-decode.
+    } else {  // first time through this code, must populate info
+        (void)this->getCachedInfo();
+        if (fErrorInDecoding) {
+            return NULL;
+        }
+    }
+    SkASSERT(fLazilyCachedInfo.fWidth > 0);
+    void * ptr = decode_into_bitmap(&fLazilyCachedInfo, fDecodeProc,
+                                    &fRowBytes, fData, fAllocator, &bitmap);
+    if (NULL == ptr) {
+        fErrorInDecoding = true;
+        return NULL;
+    }
+    fCacheId = (intptr_t)(SkScaledImageCache::AddAndLock(
+                                       this->getGenerationID(),
+                                       fLazilyCachedInfo.fWidth,
+                                       fLazilyCachedInfo.fHeight,
+                                       bitmap));
+    return ptr;
+}
+
 void* SkLazyPixelRef::onLockPixels(SkColorTable**) {
     if (fErrorInDecoding) {
         return NULL;
     }
+    if (NULL == fImageCache) {
+        return this->lockScaledImageCachePixels();
+    } else {
+        return this->lockImageCachePixels();
+    }
+}
+
+void* SkLazyPixelRef::lockImageCachePixels() {
+    SkASSERT(!fErrorInDecoding);

[scroggo, 2013/10/23 23:38:33]

Assert that fImageCache != NULL?

[hal.canary, 2013/10/24 14:21:55]

Done.

     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)) {
         return;
     }
-    if (fCacheId != SkImageCache::UNINITIALIZED_ID) {
+    if (NULL == fImageCache) {
+        SkScaledImageCache::Unlock((SkScaledImageCache::ID *)(fCacheId));
+        fCacheId = 0;
+        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);
+}