No deduping dictionaries for matrices and regions.

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 78 matching lines @@
         void* buffer = sk_malloc_throw(size);
         writer.flatten(buffer);
         SkASSERT(!fOpData);
         fOpData = SkData::NewFromMalloc(buffer, size);
     }
 
     // copy over the refcnt dictionary to our reader
     record.fFlattenableHeap.setupPlaybacks();
 
     fBitmaps = record.fBitmapHeap->extractBitmaps();
-    fMatrices = record.fMatrices.unflattenToArray();
     fPaints = record.fPaints.unflattenToArray();
-    fRegions = record.fRegions.unflattenToArray();
 
     fBitmapHeap.reset(SkSafeRef(record.fBitmapHeap));
     fPathHeap.reset(SkSafeRef(record.fPathHeap));
 
     // ensure that the paths bounds are pre-computed
     if (fPathHeap.get()) {
         for (int i = 0; i < fPathHeap->count(); i++) {
             (*fPathHeap)[i].updateBoundsCache();
         }
     }
@@ skipping 51 matching lines @@
            paint.getLooper() ||
            paint.getImageFilter();
 }
 
 SkPicturePlayback::SkPicturePlayback(const SkPicturePlayback& src, SkPictCopyInfo* deepCopyInfo) {
     this->init();
 
     fBitmapHeap.reset(SkSafeRef(src.fBitmapHeap.get()));
     fPathHeap.reset(SkSafeRef(src.fPathHeap.get()));
 
-    fMatrices = SkSafeRef(src.fMatrices);
-    fRegions = SkSafeRef(src.fRegions);
     fOpData = SkSafeRef(src.fOpData);
 
     fBoundingHierarchy = src.fBoundingHierarchy;
     fStateTree = src.fStateTree;
 
     SkSafeRef(fBoundingHierarchy);
     SkSafeRef(fStateTree);
 
     if (deepCopyInfo) {
         int paintCount = SafeCount(src.fPaints);
@@ skipping 69 matching lines @@
             fPictureRefs[i] = src.fPictureRefs[i]->clone();
         } else {
             fPictureRefs[i] = src.fPictureRefs[i];
             fPictureRefs[i]->ref();
         }
     }
 }
 
 void SkPicturePlayback::init() {
     fBitmaps = NULL;
-    fMatrices = NULL;
     fPaints = NULL;
     fPictureRefs = NULL;
-    fRegions = NULL;
     fPictureCount = 0;
     fOpData = NULL;
     fFactoryPlayback = NULL;
     fBoundingHierarchy = NULL;
     fStateTree = NULL;
 }
 
 SkPicturePlayback::~SkPicturePlayback() {
     fOpData->unref();
 
     SkSafeUnref(fBitmaps);
-    SkSafeUnref(fMatrices);
     SkSafeUnref(fPaints);
-    SkSafeUnref(fRegions);
     SkSafeUnref(fBoundingHierarchy);
     SkSafeUnref(fStateTree);
 
     for (int i = 0; i < fPictureCount; i++) {
         fPictureRefs[i]->unref();
     }
     SkDELETE_ARRAY(fPictureRefs);
 
     SkDELETE(fFactoryPlayback);
 }
 
 void SkPicturePlayback::dumpSize() const {
-    SkDebugf("--- picture size: ops=%d bitmaps=%d [%d] matrices=%d [%d] paints=%d [%d] paths=%d regions=%d\n",
+    SkDebugf("--- picture size: ops=%d bitmaps=%d [%d] paints=%d [%d] paths=%d\n",
              fOpData->size(),
              SafeCount(fBitmaps), SafeCount(fBitmaps) * sizeof(SkBitmap),
-             SafeCount(fMatrices), SafeCount(fMatrices) * sizeof(SkMatrix),
              SafeCount(fPaints), SafeCount(fPaints) * sizeof(SkPaint),
-             SafeCount(fPathHeap.get()),
-             SafeCount(fRegions));
+             SafeCount(fPathHeap.get()));
 }
 
 bool SkPicturePlayback::containsBitmaps() const {
     if (fBitmaps && fBitmaps->count() > 0) {
         return true;
     }
     for (int i = 0; i < fPictureCount; ++i) {
         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_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,
                          uint32_t size) {
     buffer.writeUInt(tag);
     buffer.writeUInt(size);
@@ skipping 44 matching lines @@
 void SkPicturePlayback::flattenToBuffer(SkOrderedWriteBuffer& 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) {
-        writeTagSize(buffer, PICT_MATRIX_BUFFER_TAG, n);
-        for (i = 0; i < n; i++) {
-            buffer.writeMatrix((*fMatrices)[i]);
-        }
-
-    }
-
     if ((n = SafeCount(fPaints)) > 0) {
         writeTagSize(buffer, 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);
         fPathHeap->flatten(buffer);
     }
-
-    if ((n = SafeCount(fRegions)) > 0) {
-        writeTagSize(buffer, PICT_REGION_BUFFER_TAG, n);
-        for (i = 0; i < n; i++) {
-            buffer.writeRegion((*fRegions)[i]);
-        }
-    }
 }
 
 void SkPicturePlayback::serialize(SkWStream* stream,
                                   SkPicture::EncodeBitmap encoder) const {
     writeTagSize(stream, PICT_READER_TAG, fOpData->size());
     stream->write(fOpData->bytes(), fOpData->size());
 
     if (fPictureCount > 0) {
         writeTagSize(stream, PICT_PICTURE_TAG, fPictureCount);
         for (int i = 0; i < fPictureCount; i++) {
@@ skipping 154 matching lines @@
                                        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;
-        case PICT_MATRIX_BUFFER_TAG:
-            fMatrices = SkTRefArray<SkMatrix>::Create(size);
-            for (size_t i = 0; i < size; ++i) {
-                buffer.readMatrix(&fMatrices->writableAt(i));
-            }
-            break;
         case 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:
             if (size > 0) {
                 fPathHeap.reset(SkNEW_ARGS(SkPathHeap, (buffer)));
             }
             break;
-        case PICT_REGION_BUFFER_TAG: {
-            fRegions = SkTRefArray<SkRegion>::Create(size);
-            for (size_t i = 0; i < size; ++i) {
-                buffer.readRegion(&fRegions->writableAt(i));
-            }
-        } break;
         default:
             // The tag was invalid.
             return false;
     }
     return true;    // success
 }
 
 SkPicturePlayback* SkPicturePlayback::CreateFromStream(SkStream* stream,
                                                        const SkPictInfo& info,
                                                        SkPicture::InstallPixelRefProc proc) {
@@ skipping 187 matching lines @@
                 SkASSERT(!offsetToRestore || \
                     offsetToRestore >= reader.offset());
                 if (!canvas.clipPath(path, regionOp, doAA) && offsetToRestore) {
 #ifdef SPEW_CLIP_SKIPPING
                     skipPath.recordSkip(offsetToRestore - reader.offset());
 #endif
                     reader.setOffset(offsetToRestore);
                 }
             } break;
             case CLIP_REGION: {
-                const SkRegion& region = getRegion(reader);
+                SkRegion region;
+                this->getRegion(reader, &region);
                 uint32_t packed = reader.readInt();
                 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
                 size_t offsetToRestore = reader.readInt();
                 SkASSERT(!offsetToRestore || \
                     offsetToRestore >= reader.offset());
                 if (!canvas.clipRegion(region, regionOp) && offsetToRestore) {
 #ifdef SPEW_CLIP_SKIPPING
                     skipRegion.recordSkip(offsetToRestore - reader.offset());
 #endif
                     reader.setOffset(offsetToRestore);
@@ skipping 23 matching lines @@
                 size_t offsetToRestore = reader.readInt();
                 SkASSERT(!offsetToRestore || \
                          offsetToRestore >= reader.offset());
                 if (!canvas.clipRRect(rrect, regionOp, doAA) && offsetToRestore) {
 #ifdef SPEW_CLIP_SKIPPING
                     skipRRect.recordSkip(offsetToRestore - reader.offset());
 #endif
                     reader.setOffset(offsetToRestore);
                 }
             } break;
-            case CONCAT:
-                canvas.concat(*getMatrix(reader));
+            case CONCAT: {
+                SkMatrix matrix;
+                this->getMatrix(reader, &matrix);
+                canvas.concat(matrix);
                 break;
+            }
             case DRAW_BITMAP: {
                 const SkPaint* paint = getPaint(reader);
                 const SkBitmap& bitmap = getBitmap(reader);
                 const SkPoint& loc = reader.skipT<SkPoint>();
                 canvas.drawBitmap(bitmap, loc.fX, loc.fY, paint);
             } break;
             case DRAW_BITMAP_RECT_TO_RECT: {
                 const SkPaint* paint = getPaint(reader);
                 const SkBitmap& bitmap = getBitmap(reader);
                 const SkRect* src = this->getRectPtr(reader);   // may be null
                 const SkRect& dst = reader.skipT<SkRect>();     // required
                 SkCanvas::DrawBitmapRectFlags flags;
                 flags = (SkCanvas::DrawBitmapRectFlags) reader.readInt();
                 canvas.drawBitmapRectToRect(bitmap, src, dst, paint, flags);
             } break;
             case DRAW_BITMAP_MATRIX: {
                 const SkPaint* paint = getPaint(reader);
                 const SkBitmap& bitmap = getBitmap(reader);
-                const SkMatrix* matrix = getMatrix(reader);
-                canvas.drawBitmapMatrix(bitmap, *matrix, paint);
+                SkMatrix matrix;
+                this->getMatrix(reader, &matrix);
+                canvas.drawBitmapMatrix(bitmap, matrix, paint);
             } break;
             case DRAW_BITMAP_NINE: {
                 const SkPaint* paint = getPaint(reader);
                 const SkBitmap& bitmap = getBitmap(reader);
                 const SkIRect& src = reader.skipT<SkIRect>();
                 const SkRect& dst = reader.skipT<SkRect>();
                 canvas.drawBitmapNine(bitmap, src, dst, paint);
             } break;
             case DRAW_CLEAR:
                 canvas.clear(reader.readInt());
@@ skipping 110 matching lines @@
                 // ptr[3] == bottom
                 if (!canvas.quickRejectY(ptr[2], ptr[3])) {
                     canvas.drawText(text.text(), text.length(), ptr[0], ptr[1],
                                     paint);
                 }
             } break;
             case DRAW_TEXT_ON_PATH: {
                 const SkPaint& paint = *getPaint(reader);
                 getText(reader, &text);
                 const SkPath& path = getPath(reader);
-                const SkMatrix* matrix = getMatrix(reader);
-                canvas.drawTextOnPath(text.text(), text.length(), path,
-                                      matrix, paint);
+                SkMatrix matrix;
+                this->getMatrix(reader, &matrix);
+                canvas.drawTextOnPath(text.text(), text.length(), path, &matrix, paint);
             } break;
             case DRAW_VERTICES: {
                 SkAutoTUnref<SkXfermode> xfer;
                 const SkPaint& paint = *getPaint(reader);
                 DrawVertexFlags flags = (DrawVertexFlags)reader.readInt();
                 SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader.readInt();
                 int vCount = reader.readInt();
                 const SkPoint* verts = (const SkPoint*)reader.skip(
                                                     vCount * sizeof(SkPoint));
                 const SkPoint* texs = NULL;
@@ skipping 37 matching lines @@
                 const SkPaint* paint = getPaint(reader);
                 canvas.saveLayer(boundsPtr, paint, (SkCanvas::SaveFlags) reader.readInt());
                 } break;
             case SCALE: {
                 SkScalar sx = reader.readScalar();
                 SkScalar sy = reader.readScalar();
                 canvas.scale(sx, sy);
             } break;
             case SET_MATRIX: {
                 SkMatrix matrix;
-                matrix.setConcat(initialMatrix, *getMatrix(reader));
+                this->getMatrix(reader, &matrix);
+                matrix.postConcat(initialMatrix);
                 canvas.setMatrix(matrix);
             } break;
             case SKEW: {
                 SkScalar sx = reader.readScalar();
                 SkScalar sy = reader.readScalar();
                 canvas.skew(sx, sy);
             } break;
             case TRANSLATE: {
                 SkScalar dx = reader.readScalar();
                 SkScalar dy = reader.readScalar();
@@ skipping 62 matching lines @@
 
 int SkPicturePlayback::paths(size_t* size) {
     size_t result = 0;
     for (int index = 0; index < fPathCount; index++) {
         const SkPath& path = fPaths[index];
         result += path.flatten(NULL);
     }
     *size = result;
     return fPathCount;
 }
-
-int SkPicturePlayback::regions(size_t* size) {
-    size_t result = 0;
-    for (int index = 0; index < fRegionCount; index++) {
-    //    const SkRegion& region = fRegions[index];
-        result += sizeof(SkRegion); // region->size();
-    }
-    *size = result;
-    return fRegionCount;
-}
 #endif
 
 #ifdef SK_DEBUG_DUMP
 void SkPicturePlayback::dumpBitmap(const SkBitmap& bitmap) const {
     char pBuffer[DUMP_BUFFER_SIZE];
     char* bufferPtr = pBuffer;
     bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
         "BitmapData bitmap%p = {", &bitmap);
     bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
         "{kWidth, %d}, ", bitmap.width());
@@ skipping 279 matching lines @@
     while (fReadStream.read(&drawType, sizeof(drawType))) {
         bufferPtr = buffer;
         DUMP_DRAWTYPE(drawType);
         switch (drawType) {
             case CLIP_PATH: {
                 DUMP_PTR(SkPath, &getPath());
                 DUMP_INT(SkRegion::Op);
                 DUMP_INT(offsetToRestore);
                 } break;
             case CLIP_REGION: {
-                DUMP_PTR(SkRegion, &getRegion());
                 DUMP_INT(SkRegion::Op);
                 DUMP_INT(offsetToRestore);
             } break;
             case CLIP_RECT: {
                 DUMP_RECT(rect);
                 DUMP_INT(SkRegion::Op);
                 DUMP_INT(offsetToRestore);
                 } break;
             case CONCAT:
-                DUMP_PTR(SkMatrix, getMatrix());
                 break;
             case DRAW_BITMAP: {
                 DUMP_PTR(SkPaint, getPaint());
                 DUMP_PTR(SkBitmap, &getBitmap());
                 DUMP_SCALAR(left);
                 DUMP_SCALAR(top);
                 } break;
             case DRAW_PAINT:
                 DUMP_PTR(SkPaint, getPaint());
                 break;
@@ skipping 41 matching lines @@
             case DRAW_TEXT: {
                 DUMP_PTR(SkPaint, getPaint());
                 DUMP_TEXT();
                 DUMP_SCALAR(x);
                 DUMP_SCALAR(y);
                 } break;
             case DRAW_TEXT_ON_PATH: {
                 DUMP_PTR(SkPaint, getPaint());
                 DUMP_TEXT();
                 DUMP_PTR(SkPath, &getPath());
-                DUMP_PTR(SkMatrix, getMatrix());
                 } break;
             case RESTORE:
                 break;
             case ROTATE:
                 DUMP_SCALAR(rotate);
                 break;
             case SAVE:
                 DUMP_INT(SkCanvas::SaveFlags);
                 break;
             case SAVE_LAYER: {
@@ skipping 32 matching lines @@
     }
     if (fBitmapCount > 0)
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
             "Bitmaps bitmaps = {");
     for (index = 0; index < fBitmapCount; index++)
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
             "bitmap%p, ", &fBitmaps[index]);
     if (fBitmapCount > 0)
         SkDebugf("%s0};\n", pBuffer);
 
-    if (fMatrixCount > 0)
-        SkDebugf("// matrices (%d)\n", fMatrixCount);
-    for (index = 0; index < fMatrixCount; index++) {
-        const SkMatrix& matrix = fMatrices[index];
-        dumpMatrix(matrix);
-    }
-    bufferPtr = pBuffer;
-    if (fMatrixCount > 0)
-        bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
-            "Matrices matrices = {");
-    for (index = 0; index < fMatrixCount; index++)
-        bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
-            "matrix%p, ", &fMatrices[index]);
-    if (fMatrixCount > 0)
-        SkDebugf("%s0};\n", pBuffer);
 
     if (fPaintCount > 0)
         SkDebugf("// paints (%d)\n", fPaintCount);
     for (index = 0; index < fPaintCount; index++) {
         const SkPaint& paint = fPaints[index];
         dumpPaint(paint);
     }
     bufferPtr = pBuffer;
     if (fPaintCount > 0)
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
@@ skipping 24 matching lines @@
     bufferPtr = pBuffer;
     if (fPictureCount > 0)
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
             "Pictures pictures = {");
     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);
 
-    for (index = 0; index < fRegionCount; index++) {
-        const SkRegion& region = fRegions[index];
-        dumpRegion(region);
-    }
-    bufferPtr = pBuffer;
-    if (fRegionCount > 0)
-        bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
-            "Regions regions = {");
-    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