Expand pixelref to return SkImageInfo and rowbytes

src/core/SkPixelRef.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkPixelRef.h"
 #include "SkFlattenableBuffers.h"
 #include "SkThread.h"
@@ skipping 57 matching lines @@
     // return a 0
     int32_t genID;
     do {
         genID = sk_atomic_inc(&gPixelRefGenerationID) + 1;
     } while (0 == genID);
     return genID;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+static void mark_invalid(SkImageInfo* info) {

[scroggo, 2013/12/04 18:14:03]

Any reason to put this here instead of on SkImageInfo?

[reed1, 2013/12/04 21:12:54]

ImageInfo's valid is possibly what I should use, but it was originally written
just for the valid-deserialization-security code. Perhaps it should be made
private to that logic for now, since it doesn't really check for all possible
"logical" invalid combinations, just checking for out-of-range values.

I'm just doing it here to avoid having a bool field, since I am "caching" the
ImageInfo.

+    info->fWidth = -1;
+}
+
+static bool is_invalid(const SkImageInfo& info) {

[scroggo, 2013/12/04 18:14:03]

What's the reason for calling this instead of !SkImageInfo::isValid()?

[reed1, 2013/12/04 21:12:54]

see above

+    return info.fWidth < 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 void SkPixelRef::setMutex(SkBaseMutex* mutex) {
     if (NULL == mutex) {
         mutex = get_default_mutex();
     }
     fMutex = mutex;
 }
 
 // just need a > 0 value, so pick a funny one to aid in debugging
 #define SKPIXELREF_PRELOCKED_LOCKCOUNT     123456789
 
 SkPixelRef::SkPixelRef(SkBaseMutex* mutex) {
     this->setMutex(mutex);
-    fPixels = NULL;
-    fColorTable = NULL; // we do not track ownership of this
+    mark_invalid(&fInfo);
+    fRec.zero();
     fLockCount = 0;
     this->needsNewGenID();
     fIsImmutable = false;
     fPreLocked = false;
 }
 
 SkPixelRef::SkPixelRef(SkFlattenableReadBuffer& buffer, SkBaseMutex* mutex)
         : INHERITED(buffer) {
     this->setMutex(mutex);
-    fPixels = NULL;
-    fColorTable = NULL; // we do not track ownership of this
+    mark_invalid(&fInfo);
+    fRec.zero();
     fLockCount = 0;
     fIsImmutable = buffer.readBool();
     fGenerationID = buffer.readUInt();
     fUniqueGenerationID = false;  // Conservatively assuming the original still exists.
     fPreLocked = false;
 }
 
 SkPixelRef::~SkPixelRef() {
     this->callGenIDChangeListeners();
 }
 
 void SkPixelRef::needsNewGenID() {
     fGenerationID = 0;
     fUniqueGenerationID = false;
 }
 
 void SkPixelRef::cloneGenID(const SkPixelRef& that) {
     // This is subtle.  We must call that.getGenerationID() to make sure its genID isn't 0.
     this->fGenerationID = that.getGenerationID();
     this->fUniqueGenerationID = false;
     that.fUniqueGenerationID = false;
 }
 
-void SkPixelRef::setPreLocked(void* pixels, SkColorTable* ctable) {
+void SkPixelRef::setPreLocked(const SkImageInfo& info, void* pixels,
+                              size_t rowBytes, SkColorTable* ctable) {
 #ifndef SK_IGNORE_PIXELREF_SETPRELOCKED
     // only call me in your constructor, otherwise fLockCount tracking can get
     // out of sync.
-    fPixels = pixels;
-    fColorTable = ctable;
+    fInfo = info;
+    fRec.fPixels = pixels;
+    fRec.fColorTable = ctable;
+    fRec.fRowBytes = rowBytes;
     fLockCount = SKPIXELREF_PRELOCKED_LOCKCOUNT;
     fPreLocked = true;
 #endif
 }
 
 void SkPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeBool(fIsImmutable);
     // We write the gen ID into the picture for within-process recording. This
     // is safe since the same genID will never refer to two different sets of
     // pixels (barring overflow). However, each process has its own "namespace"
     // of genIDs. So for cross-process recording we write a zero which will
     // trigger assignment of a new genID in playback.
     if (buffer.isCrossProcess()) {
         buffer.writeUInt(0);
     } else {
         buffer.writeUInt(fGenerationID);
         fUniqueGenerationID = false;  // Conservative, a copy is probably about to exist.
     }
 }
 
-void SkPixelRef::lockPixels() {
-    SkASSERT(!fPreLocked || SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount);
-
+bool SkPixelRef::getInfo(SkImageInfo* info) {
     if (!fPreLocked) {
         SkAutoMutexAcquire  ac(*fMutex);
-
-        if (1 == ++fLockCount) {
-            fPixels = this->onLockPixels(&fColorTable);
+        
+        if (is_invalid(fInfo)) {
+            if (!this->onGetInfo(&fInfo)) {
+                mark_invalid(&fInfo);
+                return false;
+            }
         }
     }
+    *info = fInfo;
+    return true;
+}
+
+bool SkPixelRef::lockPixels(LockRec* rec) {
+    SkASSERT(!fPreLocked || SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount);
+    
+    if (!fPreLocked) {
+        SkAutoMutexAcquire  ac(*fMutex);
+        
+        if (0 == fLockCount) {
+            fRec.zero();
+            if (!this->onNewLockPixels(&fRec)) {
+                fRec.zero();
+                return false;
+            }
+        }
+        fLockCount += 1;
+    }
+    *rec = fRec;
+    return true;
+}
+
+void SkPixelRef::lockPixels() {
+    LockRec rec;
+    this->lockPixels(&rec);
 }
 
 void SkPixelRef::unlockPixels() {
     SkASSERT(!fPreLocked || SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount);
 
     if (!fPreLocked) {
         SkAutoMutexAcquire  ac(*fMutex);
 
         SkASSERT(fLockCount > 0);
         if (0 == --fLockCount) {
             this->onUnlockPixels();
-            fPixels = NULL;
-            fColorTable = NULL;
+            fRec.zero();
         }
     }
 }
 
 bool SkPixelRef::lockPixelsAreWritable() const {
     return this->onLockPixelsAreWritable();
 }
 
 bool SkPixelRef::onLockPixelsAreWritable() const {
     return true;
@@ skipping 65 matching lines @@
 
 #ifdef SK_BUILD_FOR_ANDROID
 void SkPixelRef::globalRef(void* data) {
     this->ref();
 }
 
 void SkPixelRef::globalUnref() {
     this->unref();
 }
 #endif