Add new skpinfo tool

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 287 matching lines @@
         if (fPictureRefs[i]->willPlayBackBitmaps()) {
             return true;
         }
     }
     return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-#define PICT_READER_TAG     SkSetFourByteTag('r', 'e', 'a', 'd')
-#define PICT_FACTORY_TAG    SkSetFourByteTag('f', 'a', 'c', 't')
-#define PICT_TYPEFACE_TAG   SkSetFourByteTag('t', 'p', 'f', 'c')
-#define PICT_PICTURE_TAG    SkSetFourByteTag('p', 'c', 't', 'r')
-
-// This tag specifies the size of the ReadBuffer, needed for the following tags
-#define PICT_BUFFER_SIZE_TAG     SkSetFourByteTag('a', 'r', 'a', 'y')
-// these are all inside the ARRAYS tag
-#define PICT_BITMAP_BUFFER_TAG  SkSetFourByteTag('b', 't', 'm', 'p')
-#define PICT_PAINT_BUFFER_TAG   SkSetFourByteTag('p', 'n', 't', ' ')
-#define PICT_PATH_BUFFER_TAG    SkSetFourByteTag('p', 't', 'h', ' ')
-
-// Always write this guy last (with no length field afterwards)
-#define PICT_EOF_TAG     SkSetFourByteTag('e', 'o', 'f', ' ')
-
 #include "SkStream.h"
 
 static void writeTagSize(SkWriteBuffer& 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);
 }
 
 static void writeFactories(SkWStream* stream, const SkFactorySet& rec) {
     int count = rec.count();
 
-    writeTagSize(stream, PICT_FACTORY_TAG, count);
+    writeTagSize(stream, SK_PICT_FACTORY_TAG, count);
 
     SkAutoSTMalloc<16, SkFlattenable::Factory> storage(count);
     SkFlattenable::Factory* array = (SkFlattenable::Factory*)storage.get();
     rec.copyToArray(array);
 
     for (int i = 0; i < count; i++) {
         const char* name = SkFlattenable::FactoryToName(array[i]);
 //        SkDebugf("---- write factories [%d] %p <%s>\n", i, array[i], name);
         if (NULL == name || 0 == *name) {
             stream->writePackedUInt(0);
         } else {
             uint32_t len = strlen(name);
             stream->writePackedUInt(len);
             stream->write(name, len);
         }
     }
 }
 
 static void writeTypefaces(SkWStream* stream, const SkRefCntSet& rec) {
     int count = rec.count();
 
-    writeTagSize(stream, PICT_TYPEFACE_TAG, count);
+    writeTagSize(stream, SK_PICT_TYPEFACE_TAG, count);
 
     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(SkWriteBuffer& buffer) const {
     int i, n;
 
     if ((n = SafeCount(fBitmaps)) > 0) {
-        writeTagSize(buffer, PICT_BITMAP_BUFFER_TAG, n);
+        writeTagSize(buffer, SK_PICT_BITMAP_BUFFER_TAG, n);
         for (i = 0; i < n; i++) {
             buffer.writeBitmap((*fBitmaps)[i]);
         }
     }
 
     if ((n = SafeCount(fPaints)) > 0) {
-        writeTagSize(buffer, PICT_PAINT_BUFFER_TAG, n);
+        writeTagSize(buffer, SK_PICT_PAINT_BUFFER_TAG, n);
         for (i = 0; i < n; i++) {
             buffer.writePaint((*fPaints)[i]);
         }
     }
 
     if ((n = SafeCount(fPathHeap.get())) > 0) {
-        writeTagSize(buffer, PICT_PATH_BUFFER_TAG, n);
+        writeTagSize(buffer, SK_PICT_PATH_BUFFER_TAG, n);
         fPathHeap->flatten(buffer);
     }
 }
 
 void SkPicturePlayback::serialize(SkWStream* stream,
                                   SkPicture::EncodeBitmap encoder) const {
-    writeTagSize(stream, PICT_READER_TAG, fOpData->size());
+    writeTagSize(stream, SK_PICT_READER_TAG, fOpData->size());
     stream->write(fOpData->bytes(), fOpData->size());
 
     if (fPictureCount > 0) {
-        writeTagSize(stream, PICT_PICTURE_TAG, fPictureCount);
+        writeTagSize(stream, SK_PICT_PICTURE_TAG, fPictureCount);
         for (int i = 0; i < fPictureCount; i++) {
             fPictureRefs[i]->serialize(stream, encoder);
         }
     }
 
     // Write some of our data into a writebuffer, and then serialize that
     // into our stream
     {
         SkRefCntSet  typefaceSet;
         SkFactorySet factSet;
 
         SkWriteBuffer buffer(SkWriteBuffer::kCrossProcess_Flag);
         buffer.setTypefaceRecorder(&typefaceSet);
         buffer.setFactoryRecorder(&factSet);
         buffer.setBitmapEncoder(encoder);
 
         this->flattenToBuffer(buffer);
 
         // We have to write these to sets into the stream *before* we write
         // the buffer, since parsing that buffer will require that we already
         // have these sets available to use.
         writeFactories(stream, factSet);
         writeTypefaces(stream, typefaceSet);
 
-        writeTagSize(stream, PICT_BUFFER_SIZE_TAG, buffer.bytesWritten());
+        writeTagSize(stream, SK_PICT_BUFFER_SIZE_TAG, buffer.bytesWritten());
         buffer.writeToStream(stream);
     }
 
-    stream->write32(PICT_EOF_TAG);
+    stream->write32(SK_PICT_EOF_TAG);
 }
 
 void SkPicturePlayback::flatten(SkWriteBuffer& buffer) const {
-    writeTagSize(buffer, PICT_READER_TAG, fOpData->size());
+    writeTagSize(buffer, SK_PICT_READER_TAG, fOpData->size());
     buffer.writeByteArray(fOpData->bytes(), fOpData->size());
 
     if (fPictureCount > 0) {
-        writeTagSize(buffer, PICT_PICTURE_TAG, fPictureCount);
+        writeTagSize(buffer, SK_PICT_PICTURE_TAG, fPictureCount);
         for (int i = 0; i < fPictureCount; i++) {
             fPictureRefs[i]->flatten(buffer);
         }
     }
 
     // Write this picture playback's data into a writebuffer
     this->flattenToBuffer(buffer);
-    buffer.write32(PICT_EOF_TAG);
+    buffer.write32(SK_PICT_EOF_TAG);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  *  Return the corresponding SkReadBuffer flags, given a set of
  *  SkPictInfo flags.
  */
 static uint32_t pictInfoFlagsToReadBufferFlags(uint32_t pictInfoFlags) {
     static const struct {
@@ skipping 21 matching lines @@
      *  its dependents: FACTORY_TAG and TYPEFACE_TAG. These two are not required
      *  but if they are present, they need to have been seen before the buffer.
      *
      *  We assert that if/when we see either of these, that we have not yet seen
      *  the buffer tag, because if we have, then its too-late to deal with the
      *  factories or typefaces.
      */
     SkDEBUGCODE(bool haveBuffer = false;)
 
     switch (tag) {
-        case PICT_READER_TAG: {
+        case SK_PICT_READER_TAG: {
             SkAutoMalloc storage(size);
             if (stream->read(storage.get(), size) != size) {
                 return false;
             }
             SkASSERT(NULL == fOpData);
             fOpData = SkData::NewFromMalloc(storage.detach(), size);
         } break;
-        case PICT_FACTORY_TAG: {
+        case SK_PICT_FACTORY_TAG: {
             SkASSERT(!haveBuffer);
             fFactoryPlayback = SkNEW_ARGS(SkFactoryPlayback, (size));
             for (size_t i = 0; i < size; i++) {
                 SkString str;
                 const size_t len = stream->readPackedUInt();
                 str.resize(len);
                 if (stream->read(str.writable_str(), len) != len) {
                     return false;
                 }
                 fFactoryPlayback->base()[i] = SkFlattenable::NameToFactory(str.c_str());
             }
         } break;
-        case PICT_TYPEFACE_TAG: {
+        case SK_PICT_TYPEFACE_TAG: {
             SkASSERT(!haveBuffer);
             fTFPlayback.setCount(size);
             for (size_t i = 0; i < size; i++) {
                 SkAutoTUnref<SkTypeface> tf(SkTypeface::Deserialize(stream));
                 if (!tf.get()) {    // failed to deserialize
                     // fTFPlayback asserts it never has a null, so we plop in
                     // the default here.
                     tf.reset(SkTypeface::RefDefault());
                 }
                 fTFPlayback.set(i, tf);
             }
         } break;
-        case PICT_PICTURE_TAG: {
+        case SK_PICT_PICTURE_TAG: {
             fPictureCount = size;
             fPictureRefs = SkNEW_ARRAY(SkPicture*, fPictureCount);
             bool success = true;
             int i = 0;
             for ( ; i < fPictureCount; i++) {
                 fPictureRefs[i] = SkPicture::CreateFromStream(stream, proc);
                 if (NULL == fPictureRefs[i]) {
                     success = false;
                     break;
                 }
             }
             if (!success) {
                 // Delete all of the pictures that were already created (up to but excluding i):
                 for (int j = 0; j < i; j++) {
                     fPictureRefs[j]->unref();
                 }
                 // Delete the array
                 SkDELETE_ARRAY(fPictureRefs);
                 fPictureCount = 0;
                 return false;
             }
         } break;
-        case PICT_BUFFER_SIZE_TAG: {
+        case SK_PICT_BUFFER_SIZE_TAG: {
             SkAutoMalloc storage(size);
             if (stream->read(storage.get(), size) != size) {
                 return false;
             }
 
             SkReadBuffer buffer(storage.get(), size);
             buffer.setFlags(pictInfoFlagsToReadBufferFlags(info.fFlags));
 
             fFactoryPlayback->setupBuffer(buffer);
             fTFPlayback.setupBuffer(buffer);
             buffer.setBitmapDecoder(proc);
 
             while (!buffer.eof()) {
                 tag = buffer.readUInt();
                 size = buffer.readUInt();
                 if (!this->parseBufferTag(buffer, tag, size)) {
                     return false;
                 }
             }
             SkDEBUGCODE(haveBuffer = true;)
         } break;
     }
     return true;    // success
 }
 
 bool SkPicturePlayback::parseBufferTag(SkReadBuffer& buffer,
                                        uint32_t tag, size_t size) {
     switch (tag) {
-        case PICT_BITMAP_BUFFER_TAG: {
+        case SK_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;
-        case PICT_PAINT_BUFFER_TAG: {
+        case SK_PICT_PAINT_BUFFER_TAG: {
             fPaints = SkTRefArray<SkPaint>::Create(size);
             for (size_t i = 0; i < size; ++i) {
                 buffer.readPaint(&fPaints->writableAt(i));
             }
         } break;
-        case PICT_PATH_BUFFER_TAG:
+        case SK_PICT_PATH_BUFFER_TAG:
             if (size > 0) {
                 fPathHeap.reset(SkNEW_ARGS(SkPathHeap, (buffer)));
             }
             break;
         default:
             // The tag was invalid.
             return false;
     }
     return true;    // success
 }
@@ skipping 15 matching lines @@
     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) {
+        if (SK_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(SkReadBuffer& buffer) {
     for (;;) {
         uint32_t tag = buffer.readUInt();
-        if (PICT_EOF_TAG == tag) {
+        if (SK_PICT_EOF_TAG == tag) {
             break;
         }
 
         uint32_t size = buffer.readUInt();
         if (!this->parseBufferTag(buffer, tag, size)) {
             return false; // we're invalid
         }
     }
     return true;
 }
@@ skipping 1012 matching lines @@
     for (index = 0; index < fPictureCount; index++)
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
             "picture%p, ", fPictureRefs[index]);
     if (fPictureCount > 0)
         SkDebugf("%s0};\n", pBuffer);
 
     const_cast<SkPicturePlayback*>(this)->dumpStream();
 }
 
 #endif