Deserialize pictures with custom image-deserializer

src/core/SkReadBuffer.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 "SkBitmap.h"
 #include "SkErrorInternals.h"
 #include "SkImage.h"
+#include "SkImageDeserializer.h"
 #include "SkImageGenerator.h"
 #include "SkReadBuffer.h"
 #include "SkStream.h"
 #include "SkTypeface.h"
 
+namespace {
+
+    // This generator intentionally should always fail on all attempts to get its pixels,
+    // simulating a bad or empty codec stream.
+    class EmptyImageGenerator final : public SkImageGenerator {
+    public:
+        EmptyImageGenerator(const SkImageInfo& info) : INHERITED(info) { }
+
+    private:
+        typedef SkImageGenerator INHERITED;
+    };
+
+    static sk_sp<SkImage> MakeEmptyImage(int width, int height) {
+        return SkImage::MakeFromGenerator(
+            new EmptyImageGenerator(SkImageInfo::MakeN32Premul(width, height)));
+    }
+    
+} // anonymous namespace
+
+
 static uint32_t default_flags() {
     uint32_t flags = 0;
     flags |= SkReadBuffer::kScalarIsFloat_Flag;
     if (8 == sizeof(void*)) {
         flags |= SkReadBuffer::kPtrIs64Bit_Flag;
     }
     return flags;
 }
 
 SkReadBuffer::SkReadBuffer() {
     fFlags = default_flags();
     fVersion = 0;
     fMemoryPtr = nullptr;
 
     fTFArray = nullptr;
     fTFCount = 0;
 
     fFactoryArray = nullptr;
     fFactoryCount = 0;
-    fBitmapDecoder = nullptr;
+//    fBitmapDecoder = nullptr;
+    fImageDeserializer = nullptr;
 #ifdef DEBUG_NON_DETERMINISTIC_ASSERT
     fDecodedBitmapIndex = -1;
 #endif // DEBUG_NON_DETERMINISTIC_ASSERT
 }
 
 SkReadBuffer::SkReadBuffer(const void* data, size_t size) {
     fFlags = default_flags();
     fVersion = 0;
     fReader.setMemory(data, size);
     fMemoryPtr = nullptr;
 
     fTFArray = nullptr;
     fTFCount = 0;
 
     fFactoryArray = nullptr;
     fFactoryCount = 0;
-    fBitmapDecoder = nullptr;
+//    fBitmapDecoder = nullptr;
+    fImageDeserializer = nullptr;
 #ifdef DEBUG_NON_DETERMINISTIC_ASSERT
     fDecodedBitmapIndex = -1;
 #endif // DEBUG_NON_DETERMINISTIC_ASSERT
 }
 
 SkReadBuffer::SkReadBuffer(SkStream* stream) {
     fFlags = default_flags();
     fVersion = 0;
     const size_t length = stream->getLength();
     fMemoryPtr = sk_malloc_throw(length);
     stream->read(fMemoryPtr, length);
     fReader.setMemory(fMemoryPtr, length);
 
     fTFArray = nullptr;
     fTFCount = 0;
 
     fFactoryArray = nullptr;
     fFactoryCount = 0;
-    fBitmapDecoder = nullptr;
+//    fBitmapDecoder = nullptr;
+    fImageDeserializer = nullptr;
 #ifdef DEBUG_NON_DETERMINISTIC_ASSERT
     fDecodedBitmapIndex = -1;
 #endif // DEBUG_NON_DETERMINISTIC_ASSERT
 }
 
 SkReadBuffer::~SkReadBuffer() {
     sk_free(fMemoryPtr);
 }
 
 bool SkReadBuffer::readBool() {
@@ skipping 90 matching lines @@
 }
 
 bool SkReadBuffer::readScalarArray(SkScalar* values, size_t size) {
     return readArray(values, size, sizeof(SkScalar));
 }
 
 uint32_t SkReadBuffer::getArrayCount() {
     return *(uint32_t*)fReader.peek();
 }
 
-bool SkReadBuffer::readBitmap(SkBitmap* bitmap) {
+sk_sp<SkImage> SkReadBuffer::readBitmapAsImage() {
     const int width = this->readInt();
     const int height = this->readInt();
 
     // The writer stored a boolean value to determine whether an SkBitmapHeap was used during
     // writing. That feature is deprecated.
     if (this->readBool()) {
         this->readUInt(); // Bitmap index
         this->readUInt(); // Bitmap generation ID
         SkErrorInternals::SetError(kParseError_SkError, "SkWriteBuffer::writeBitmap "
                                    "stored the SkBitmap in an SkBitmapHeap, but "
                                    "that feature is no longer supported.");
     } else {
         // The writer stored false, meaning the SkBitmap was not stored in an SkBitmapHeap.
         const size_t length = this->readUInt();
         if (length > 0) {
 #ifdef DEBUG_NON_DETERMINISTIC_ASSERT
             fDecodedBitmapIndex++;
 #endif // DEBUG_NON_DETERMINISTIC_ASSERT
             // A non-zero size means the SkBitmap was encoded. Read the data and pixel
             // offset.
             const void* data = this->skip(length);
             const int32_t xOffset = this->readInt();
             const int32_t yOffset = this->readInt();
+            SkIRect subset = SkIRect::MakeXYWH(xOffset, yOffset, width, height);
+#if 0
             if (fBitmapDecoder != nullptr && fBitmapDecoder(data, length, bitmap)) {
                 if (bitmap->width() == width && bitmap->height() == height) {
 #ifdef DEBUG_NON_DETERMINISTIC_ASSERT
                     if (0 != xOffset || 0 != yOffset) {
                         SkDebugf("SkReadBuffer::readBitmap: heights match,"
                                  " but offset is not zero. \nInfo about the bitmap:"
                                  "\n\tIndex: %d\n\tDimensions: [%d %d]\n\tEncoded"
                                  " data size: %d\n\tOffset: (%d, %d)\n",
                                  fDecodedBitmapIndex, width, height, length, xOffset,
                                  yOffset);
                     }
 #endif // DEBUG_NON_DETERMINISTIC_ASSERT
                     // If the width and height match, there should be no offset.
                     SkASSERT(0 == xOffset && 0 == yOffset);
                     return true;
                 }
 
                 // This case can only be reached if extractSubset was called, so
                 // the recorded width and height must be smaller than or equal to
                 // the encoded width and height.
                 // FIXME (scroggo): This assert assumes that our decoder and the
                 // sources encoder agree on the width and height which may not
                 // always be the case. Removing until it can be investigated
                 // further.
                 //SkASSERT(width <= bitmap->width() && height <= bitmap->height());
 
                 SkBitmap subsetBm;
-                SkIRect subset = SkIRect::MakeXYWH(xOffset, yOffset, width, height);
                 if (bitmap->extractSubset(&subsetBm, subset)) {
                     bitmap->swap(subsetBm);
                     return true;
                 }
             }
+#else
+            if (fImageDeserializer) {

[mtklein, 2016/08/10 21:48:31]

Might be nice to default this to a singleton default deserializer that calls
SkImage::MakeFromEncoded() instead of null.  That way we never have to check
down here, just always call the deserializer.

[reed1, 2016/08/10 23:43:19]

Agreed. I had meant to mark that as a TODO. WIll implement that now.

+                sk_sp<SkImage> image =
+                    fImageDeserializer->deserialize(SkData::MakeWithCopy(data, length), &subset);
+                if (image) {
+                    return image;
+                }
+            }
+#endif
             // This bitmap was encoded when written, but we are unable to decode, possibly due to
             // not having a decoder.
             SkErrorInternals::SetError(kParseError_SkError,
                                        "Could not decode bitmap. Resulting bitmap will be empty.");
             // Even though we weren't able to decode the pixels, the readbuffer should still be
             // intact, so we return true with an empty bitmap, so we don't force an abort of the
             // larger deserialize.
-            bitmap->setInfo(SkImageInfo::MakeUnknown(width, height));
-            return true;
-        } else if (SkBitmap::ReadRawPixels(this, bitmap)) {
-            return true;
+            return MakeEmptyImage(width, height);
+        } else {
+            SkBitmap bitmap;
+            if (SkBitmap::ReadRawPixels(this, &bitmap)) {
+                bitmap.setImmutable();
+                return SkImage::MakeFromBitmap(bitmap);
+            }
         }
     }
     // Could not read the SkBitmap. Use a placeholder bitmap.
-    bitmap->setInfo(SkImageInfo::MakeUnknown(width, height));
-    return false;
+    return nullptr;
 }
 
-namespace {
-
-// This generator intentionally should always fail on all attempts to get its pixels,
-// simulating a bad or empty codec stream.
-class EmptyImageGenerator final : public SkImageGenerator {
-public:
-    EmptyImageGenerator(const SkImageInfo& info) : INHERITED(info) { }
-
-private:
-    typedef SkImageGenerator INHERITED;
-};
-
-} // anonymous namespace
-
-SkImage* SkReadBuffer::readImage() {
+sk_sp<SkImage> SkReadBuffer::readImage() {
     int width = this->read32();
     int height = this->read32();
     if (width <= 0 || height <= 0) {    // SkImage never has a zero dimension
         this->validate(false);
         return nullptr;
     }
 
-    auto placeholder = [=] {
-        return SkImage::MakeFromGenerator(
-            new EmptyImageGenerator(SkImageInfo::MakeN32Premul(width, height))).release();
-    };
-
     uint32_t encoded_size = this->getArrayCount();
     if (encoded_size == 0) {
         // The image could not be encoded at serialization time - return an empty placeholder.
         (void)this->readUInt();  // Swallow that encoded_size == 0 sentinel.
-        return placeholder();
+        return MakeEmptyImage(width, height);
     }
     if (encoded_size == 1) {
         // We had to encode the image as raw pixels via SkBitmap.
         (void)this->readUInt();  // Swallow that encoded_size == 1 sentinel.
         SkBitmap bm;
         if (SkBitmap::ReadRawPixels(this, &bm)) {
-            return SkImage::MakeFromBitmap(bm).release();
+            return SkImage::MakeFromBitmap(bm);
         }
-        return placeholder();
+        return MakeEmptyImage(width, height);
     }
 
     // The SkImage encoded itself.
     sk_sp<SkData> encoded(this->readByteArrayAsData());
 
     int originX = this->read32();
     int originY = this->read32();
     if (originX < 0 || originY < 0) {
         this->validate(false);
         return nullptr;
     }
 
     const SkIRect subset = SkIRect::MakeXYWH(originX, originY, width, height);
-    SkImage* image = SkImage::MakeFromEncoded(std::move(encoded), &subset).release();
-    if (image) {
-        return image;
+
+    sk_sp<SkImage> image;
+    if (fImageDeserializer) {
+        image = fImageDeserializer->deserialize(std::move(encoded), &subset);
+    } else {
+        image = SkImage::MakeFromEncoded(std::move(encoded), &subset);
     }
-
-    return SkImage::MakeFromGenerator(
-            new EmptyImageGenerator(SkImageInfo::MakeN32Premul(width, height))).release();
+    return image ? image : MakeEmptyImage(width, height);
 }
 
 SkTypeface* SkReadBuffer::readTypeface() {
 
     uint32_t index = fReader.readU32();
     if (0 == index || index > (unsigned)fTFCount) {
         return nullptr;
     } else {
         SkASSERT(fTFArray);
         return fTFArray[index - 1];
@@ skipping 60 matching lines @@
         if (sizeRecorded != sizeRead) {
             this->validate(false);
             return nullptr;
         }
     } else {
         // we must skip the remaining data
         fReader.skip(sizeRecorded);
     }
     return obj.release();
 }