Serialization of SkPictureImageFilter

src/core/SkPicturePlayback.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 "SkPicturePlayback.h"
 #include "SkPictureRecord.h"
 #include "SkTypeface.h"
@@ skipping 316 matching lines @@
 #define PICT_MATRIX_BUFFER_TAG  SkSetFourByteTag('m', 't', 'r', 'x')
 #define PICT_PAINT_BUFFER_TAG   SkSetFourByteTag('p', 'n', 't', ' ')
 #define PICT_PATH_BUFFER_TAG    SkSetFourByteTag('p', 't', 'h', ' ')
 #define PICT_REGION_BUFFER_TAG  SkSetFourByteTag('r', 'g', 'n', ' ')
 
 // Always write this guy last (with no length field afterwards)
 #define PICT_EOF_TAG     SkSetFourByteTag('e', 'o', 'f', ' ')
 
 #include "SkStream.h"
 
-static void writeTagSize(SkOrderedWriteBuffer& buffer, uint32_t tag,
+static void writeTagSize(SkFlattenableWriteBuffer& buffer, uint32_t tag,
                          uint32_t size) {
     buffer.writeUInt(tag);
     buffer.writeUInt(size);
 }
 
 static void writeTagSize(SkWStream* stream, uint32_t tag,
                          uint32_t size) {
     stream->write32(tag);
     stream->write32(size);
 }
@@ skipping 27 matching lines @@
 
     SkAutoSTMalloc<16, SkTypeface*> storage(count);
     SkTypeface** array = (SkTypeface**)storage.get();
     rec.copyToArray((SkRefCnt**)array);
 
     for (int i = 0; i < count; i++) {
         array[i]->serialize(stream);
     }
 }
 
-void SkPicturePlayback::flattenToBuffer(SkOrderedWriteBuffer& buffer) const {
+void SkPicturePlayback::flattenToBuffer(SkFlattenableWriteBuffer& buffer) const {
     int i, n;
 
     if ((n = SafeCount(fBitmaps)) > 0) {
         writeTagSize(buffer, PICT_BITMAP_BUFFER_TAG, n);
         for (i = 0; i < n; i++) {
             buffer.writeBitmap((*fBitmaps)[i]);
         }
     }
 
     if ((n = SafeCount(fMatrices)) > 0) {
@@ skipping 56 matching lines @@
         writeFactories(stream, factSet);
         writeTypefaces(stream, typefaceSet);
 
         writeTagSize(stream, PICT_BUFFER_SIZE_TAG, buffer.size());
         buffer.writeToStream(stream);
     }
 
     stream->write32(PICT_EOF_TAG);
 }
 
+void SkPicturePlayback::flatten(SkFlattenableWriteBuffer& buffer) const {
+    writeTagSize(buffer, PICT_READER_TAG, fOpData->size());
+    buffer.writeByteArray(fOpData->bytes(), fOpData->size());
+
+    if (fPictureCount > 0) {
+        writeTagSize(buffer, PICT_PICTURE_TAG, fPictureCount);
+        for (int i = 0; i < fPictureCount; i++) {
+            fPictureRefs[i]->flatten(buffer);
+        }
+    }
+
+    // Write some of our data into a writebuffer
+    this->flattenToBuffer(buffer);
+    buffer.write32(PICT_EOF_TAG);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  *  Return the corresponding SkFlattenableReadBuffer flags, given a set of
  *  SkPictInfo flags.
  */
 static uint32_t pictInfoFlagsToReadBufferFlags(uint32_t pictInfoFlags) {
     static const struct {
         uint32_t    fSrc;
         uint32_t    fDst;
@@ skipping 102 matching lines @@
                 if (!this->parseBufferTag(buffer, tag, size)) {
                     return false;
                 }
             }
             SkDEBUGCODE(haveBuffer = true;)
         } break;
     }
     return true;    // success
 }
 
-bool SkPicturePlayback::parseBufferTag(SkOrderedReadBuffer& buffer,
+bool SkPicturePlayback::parseBufferTag(SkFlattenableReadBuffer& buffer,
                                        uint32_t tag, size_t size) {
     switch (tag) {
         case PICT_BITMAP_BUFFER_TAG: {
             fBitmaps = SkTRefArray<SkBitmap>::Create(size);
             for (size_t i = 0; i < size; ++i) {
                 SkBitmap* bm = &fBitmaps->writableAt(i);
                 buffer.readBitmap(bm);
                 bm->setImmutable();
             }
         } break;
@@ skipping 31 matching lines @@
                                                        const SkPictInfo& info,
                                                        SkPicture::InstallPixelRefProc proc) {
     SkAutoTDelete<SkPicturePlayback> playback(SkNEW(SkPicturePlayback));
 
     if (!playback->parseStream(stream, info, proc)) {
         return NULL;
     }
     return playback.detach();
 }
 
+SkPicturePlayback* SkPicturePlayback::CreateFromBuffer(SkFlattenableReadBuffer& buffer) {
+    SkAutoTDelete<SkPicturePlayback> playback(SkNEW(SkPicturePlayback));
+
+    if (!playback->parseBuffer(buffer)) {
+        return NULL;
+    }
+    return playback.detach();
+}
+
 bool SkPicturePlayback::parseStream(SkStream* stream, const SkPictInfo& info,
                                     SkPicture::InstallPixelRefProc proc) {
     for (;;) {
         uint32_t tag = stream->readU32();
         if (PICT_EOF_TAG == tag) {
             break;
         }
 
         uint32_t size = stream->readU32();
         if (!this->parseStreamTag(stream, info, tag, size, proc)) {
             return false; // we're invalid
         }
     }
     return true;
 }
 
+bool SkPicturePlayback::parseBuffer(SkFlattenableReadBuffer& buffer) {
+    for (;;) {
+        uint32_t tag = buffer.readUInt();
+        if (PICT_EOF_TAG == tag) {
+            break;
+        }
+
+        uint32_t size = buffer.readUInt();
+        if (!this->parseBufferTag(buffer, tag, size)) {
+            return false; // we're invalid
+        }
+    }
+    return true;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SPEW_CLIP_SKIPPING
 struct SkipClipRec {
     int     fCount;
     size_t  fSize;
 
     SkipClipRec() {
         fCount = 0;
@@ skipping 1004 matching lines @@
     for (index = 0; index < fRegionCount; index++)
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
             "region%p, ", &fRegions[index]);
     if (fRegionCount > 0)
         SkDebugf("%s0};\n", pBuffer);
 
     const_cast<SkPicturePlayback*>(this)->dumpStream();
 }
 
 #endif