Expand pixelref to return SkImageInfo and rowbytes

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)
+SkLazyPixelRef::SkLazyPixelRef(const SkImageInfo& info, SkData* data,
+                               SkBitmapFactory::DecodeProc proc,
+                               SkImageCache* cache)
     // Pass NULL for the Mutex so that the default (ring buffer) will be used.
-    : INHERITED(NULL)
+    : INHERITED(info)
     , fErrorInDecoding(false)
     , fDecodeProc(proc)
     , fImageCache(cache)
-    , fRowBytes(0) {
+    , fRowBytes(0)
+{
     SkASSERT(fDecodeProc != NULL);
     if (NULL == data) {
         fData = SkData::NewEmpty();
         fErrorInDecoding = true;
     } else {
         fData = data;
         fData->ref();
         fErrorInDecoding = data->size() == 0;
     }
     if (fImageCache != NULL) {
@@ skipping 71 matching lines @@
     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() {
+bool SkLazyPixelRef::lockScaledImageCachePixels(LockRec* rec) {
     SkASSERT(!fErrorInDecoding);
     SkASSERT(NULL == fImageCache);
     SkBitmap bitmap;
     const SkImageInfo* info = this->getCachedInfo();
-    if (info == NULL) {
-        return NULL;
+    if (NULL == info) {
+        return false;
     }
+
     // If this is the first time though, this is guaranteed to fail.
     // Maybe we should have a flag that says "don't even bother looking"
     fScaledCacheId = SkScaledImageCache::FindAndLock(this->getGenerationID(),
                                                      info->fWidth,
                                                      info->fHeight,
                                                      &bitmap);
+    void* pixels;
     if (fScaledCacheId != NULL) {
         SkAutoLockPixels autoLockPixels(bitmap);
-        void* pixels = bitmap.getPixels();
+        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.
-        void* pixels = decode_into_bitmap(const_cast<SkImageInfo*>(info),
-                                          fDecodeProc, &fRowBytes, fData,
-                                          &bitmap);
+        pixels = decode_into_bitmap(const_cast<SkImageInfo*>(info), fDecodeProc,
+                                    &fRowBytes, fData, &bitmap);
         if (NULL == pixels) {
             fErrorInDecoding = true;
             return NULL;
         }
         fScaledCacheId = SkScaledImageCache::AddAndLock(this->getGenerationID(),
                                                         info->fWidth,
                                                         info->fHeight,
                                                         bitmap);
         SkASSERT(fScaledCacheId != NULL);
-        return pixels;
     }
+
+    rec->fPixels = pixels;
+    rec->fColorTable = NULL;
+    rec->fRowBytes = bitmap.rowBytes();
+    return true;
 }
 
-void* SkLazyPixelRef::onLockPixels(SkColorTable**) {
-    if (fErrorInDecoding) {
-        return NULL;
-    }
-    if (NULL == fImageCache) {
-        return this->lockScaledImageCachePixels();
-    } else {
-        return this->lockImageCachePixels();
-    }
-}
-
-void* SkLazyPixelRef::lockImageCachePixels() {
+bool SkLazyPixelRef::lockImageCachePixels(LockRec* rec) {
     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) {
@@ skipping 12 matching lines @@
 #if LAZY_CACHE_STATS
         sk_atomic_inc(&gCacheMisses);
 #endif
     }
 
     SkASSERT(fData != NULL && fData->size() > 0);
     if (NULL == target.fAddr) {
         const SkImageInfo* info = this->getCachedInfo();
         if (NULL == info) {
             SkASSERT(SkImageCache::UNINITIALIZED_ID == fCacheId);
-            return NULL;
+            return false;
         }
         size_t bytes = ComputeMinRowBytesAndSize(*info, &target.fRowBytes);
         target.fAddr = fImageCache->allocAndPinCache(bytes, &fCacheId);
         if (NULL == target.fAddr) {
             // Space could not be allocated.
             // Just like the last assert, fCacheId must be UNINITIALIZED_ID.
             SkASSERT(SkImageCache::UNINITIALIZED_ID == fCacheId);
-            return NULL;
+            return false;
         }
     } else {
         // pinCache returned purged memory to which target.fAddr already points. Set
         // target.fRowBytes properly.
         target.fRowBytes = fRowBytes;
         // Assume that the size is correct, since it was determined by this same function
         // previously.
     }
     SkASSERT(target.fAddr != NULL);
     SkASSERT(SkImageCache::UNINITIALIZED_ID != fCacheId);
     fErrorInDecoding = !fDecodeProc(fData->data(), fData->size(), NULL, &target);
     if (fErrorInDecoding) {
         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;
+
+    rec->fPixels = target.fAddr;
+    rec->fColorTable = NULL;
+    rec->fRowBytes = target.fRowBytes;
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool SkLazyPixelRef::onNewLockPixels(LockRec* rec) {
+    if (fErrorInDecoding) {
+        return false;
+    }
+    if (NULL == fImageCache) {
+        return this->lockScaledImageCachePixels(rec);
+    } else {
+        return this->lockImageCachePixels(rec);
+    }
 }
 
 void SkLazyPixelRef::onUnlockPixels() {
     if (fErrorInDecoding) {
         return;
     }
     if (NULL == fImageCache) {
         // onUnlockPixels() should never be called a second time from
         // PixelRef::Unlock() without calling onLockPixels() first.
         SkASSERT(NULL != fScaledCacheId);
@@ skipping 54 matching lines @@
 
     target.fAddr = tmp.getPixels();
     fErrorInDecoding = !fDecodeProc(fData->data(), fData->size(), &info, &target);
     if (fErrorInDecoding) {
         return false;
     }
 
     *bitmap = tmp;
     return true;
 }