Expand pixelref to return SkImageInfo and rowbytes

src/core/SkMallocPixelRef.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 "SkMallocPixelRef.h"
 #include "SkBitmap.h"
 #include "SkFlattenableBuffers.h"
 
-SkMallocPixelRef::SkMallocPixelRef(void* storage, size_t size,
-                                   SkColorTable* ctable, bool ownPixels) {
+SkMallocPixelRef::SkMallocPixelRef(const SkImageInfo& info, void* storage,
+                       size_t rowBytes, SkColorTable* ctable, bool ownPixels) {
+    size_t size = info.fHeight * rowBytes;
     if (NULL == storage) {
         SkASSERT(ownPixels);
         storage = sk_malloc_throw(size);
     }
     fStorage = storage;
-    fSize = size;
+    fInfo = info;
+    fRB = rowBytes;
     fCTable = ctable;
     SkSafeRef(ctable);
     fOwnPixels = ownPixels;
 
-    this->setPreLocked(fStorage, fCTable);
+    this->setPreLocked(fStorage, rowBytes, fCTable);
 }
 
 SkMallocPixelRef::~SkMallocPixelRef() {
     SkSafeUnref(fCTable);
     if (fOwnPixels) {
         sk_free(fStorage);
     }
 }
 
-void* SkMallocPixelRef::onLockPixels(SkColorTable** ct) {
+void* SkMallocPixelRef::onLockPixels(SkImageInfo* info, size_t* rowBytes,
+                                     SkColorTable** ct) {
+    *info = fInfo;
+    *rowBytes = fRB;
     *ct = fCTable;
     return fStorage;
 }
 
 void SkMallocPixelRef::onUnlockPixels() {
     // nothing to do
 }
 
 void SkMallocPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
 
-    buffer.writeByteArray(fStorage, fSize);
+    buffer.write32(fInfo.fWidth);

[scroggo, 2013/11/19 18:17:09]

SkImageInfo::writeToMemory?

[reed1, 2013/11/20 20:56:56]

removed (for now at least. only one caller)

+    buffer.write32(fInfo.fHeight);

[scroggo, 2013/11/19 18:17:09]

This will require a change to the picture format.

[reed1, 2013/11/20 20:56:56]

indeed. I'll update the picvers code next.

+    buffer.write32(fInfo.fAlphaType);
+    buffer.write32(fInfo.fColorType);
+
+    // TODO: replace this bulk write with a chunky one that can trim off any
+    // trailing bytes on each scanline (in case rowbytes > width*size)
+    size_t size = this->computeSize();
+    buffer.write32(fRB);
+    buffer.writeByteArray(fStorage, size);
     buffer.writeBool(fCTable != NULL);
     if (fCTable) {
         fCTable->writeToBuffer(buffer);
     }
 }
 
 SkMallocPixelRef::SkMallocPixelRef(SkFlattenableReadBuffer& buffer)
         : INHERITED(buffer, NULL) {
-    fSize = buffer.getArrayCount();
-    fStorage = sk_malloc_throw(fSize);
-    buffer.readByteArray(fStorage, fSize);
+    fInfo.fWidth = buffer.read32();

[scroggo, 2013/11/19 18:17:09]

readFromMemory?

[reed1, 2013/11/20 20:56:56]

removed api

+    fInfo.fHeight = buffer.read32();
+    fInfo.fAlphaType = (SkAlphaType)buffer.read32();
+    fInfo.fColorType = (SkColorType)buffer.read32();
+
+    fRB = buffer.read32();
+    size_t size = this->computeSize();
+    fStorage = sk_malloc_throw(size);
+    buffer.readByteArray(fStorage, size);
     if (buffer.readBool()) {
         fCTable = SkNEW_ARGS(SkColorTable, (buffer));
     } else {
         fCTable = NULL;
     }
     fOwnPixels = true;
 
-    this->setPreLocked(fStorage, fCTable);
+    this->setPreLocked(fStorage, fRB, fCTable);
 }