hack

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 <new>
 #include "SkBBoxHierarchy.h"
 #include "SkOffsetTable.h"
 #include "SkPicturePlayback.h"
@@ skipping 843 matching lines @@
     ~SkAutoResetOpID() {
         if (NULL != fPlayback) {
             fPlayback->resetOpID();
         }
     }
 
 private:
     SkPicturePlayback* fPlayback;
 };
 
-void SkPicturePlayback::draw(SkCanvas& canvas, SkDrawPictureCallback* callback) {
+SkPicturePlayback::Foo* SkPicturePlayback::Bar::lookupStart(size_t start) {
+    for (int i = 0; i < fFoo.count(); ++i) {
+        if (start == fFoo[i].fStart) {
+            return &fFoo[i];
+        }
+    }
+
+    return NULL;
+}
+
+SkPicturePlayback::Foo* SkPicturePlayback::Bar::lookupStop(size_t stop) {
+    for (int i = 0; i < fFoo.count(); ++i) {
+        if (stop == fFoo[i].fStop) {
+            return &fFoo[i];
+        }
+    }
+
+    return NULL;
+}
+
+void SkPicturePlayback::draw(SkCanvas& canvas, 
+                             int start, int stop,
+                             SkDrawPictureCallback* callback,
+                             Bar* foo) {
     SkAutoResetOpID aroi(this);
     SkASSERT(0 == fCurOffset);
 
 #ifdef ENABLE_TIME_DRAW
     SkAutoTime  at("SkPicture::draw", 50);
 #endif
 
 #ifdef SPEW_CLIP_SKIPPING
     SkipClipRec skipRect, skipRRect, skipRegion, skipPath, skipCull;
     int opCount = 0;
 #endif
 
 #ifdef SK_BUILD_FOR_ANDROID
     SkAutoMutexAcquire autoMutex(fDrawMutex);
 #endif
 
     // kDrawComplete will be the signal that we have reached the end of
     // the command stream
     static const uint32_t kDrawComplete = SK_MaxU32;
 
     SkReader32 reader(fOpData->bytes(), fOpData->size());
     TextContainer text;
     const SkTDArray<void*>* activeOps = NULL;
 
-    if (NULL != fStateTree && NULL != fBoundingHierarchy) {
-        SkRect clipBounds;
-        if (canvas.getClipBounds(&clipBounds)) {
-            SkIRect query;
-            clipBounds.roundOut(&query);
+    if (start == -1 ) {
+        if (NULL != fStateTree && NULL != fBoundingHierarchy) {
+            SkRect clipBounds;
+            if (canvas.getClipBounds(&clipBounds)) {
+                SkIRect query;
+                clipBounds.roundOut(&query);
 
-            const SkPicture::OperationList& activeOpsList = this->getActiveOps(query);
-            if (activeOpsList.valid()) {
-                if (0 == activeOpsList.numOps()) {
-                    return;     // nothing to draw
+                const SkPicture::OperationList& activeOpsList = this->getActiveOps(query);
+                if (activeOpsList.valid()) {
+                    if (0 == activeOpsList.numOps()) {
+                        return;     // nothing to draw
+                    }
+
+                    // Since the opList is valid we know it is our derived class
+                    activeOps = &((const CachedOperationList&)activeOpsList).fOps;
                 }
-
-                // Since the opList is valid we know it is our derived class
-                activeOps = &((const CachedOperationList&)activeOpsList).fOps;
             }
         }
     }
 
     SkPictureStateTree::Iterator it = (NULL == activeOps) ?
         SkPictureStateTree::Iterator() :
         fStateTree->getIterator(*activeOps, &canvas);
 
+    if (start != -1) {
+        reader.setOffset(start);
+        uint32_t size;
+        SkDEBUGCODE(DrawType op =) read_op_and_size(&reader, &size);
+        SkASSERT(SAVE_LAYER == op);
+        reader.setOffset(start+size);
+    }
+
     if (it.isValid()) {
         uint32_t skipTo = it.draw();
         if (kDrawComplete == skipTo) {
             return;
         }
         reader.setOffset(skipTo);
     }
 
     this->preLoadBitmaps(activeOps);
 
@@ skipping 12 matching lines @@
     while (!reader.eof()) {
         if (callback && callback->abortDrawing()) {
             canvas.restoreToCount(originalSaveCount);
             return;
         }
 #ifdef SK_BUILD_FOR_ANDROID
         if (fAbortCurrentPlayback) {
             return;
         }
 #endif
+        if (stop != -1) {
+            if (reader.offset() >= (unsigned int) stop) {
+                uint32_t size;
+                SkDEBUGCODE(DrawType op =) read_op_and_size(&reader, &size);
+                SkASSERT(RESTORE == op);
+                return;
+            }
+        }
+
+        if (NULL != foo) {
+#if 0
+            // replace the saveLayer/restore block with a drawBitmap call
+            SkPicturePlayback::Foo* temp = foo->lookupStart(reader.offset());
+
+            if (NULL != temp) {
+                SkASSERT(NULL != temp->fBM);
+                canvas.drawBitmap(*temp->fBM, temp->fPos.fX, temp->fPos.fY, temp->fPaint);
+
+                reader.setOffset(temp->fStop);
+                uint32_t size;
+                SkDEBUGCODE(DrawType op =) read_op_and_size(&reader, &size);
+                SkASSERT(RESTORE == op);
+                continue;
+            }
+#else
+            // execute the saveLayer/restore block but follow it with a drawBitmap call
+            // This is intended (with conversion of saveLayers to saves) to 
+            // separate out the overhead of the saveLayer render target changes
+            // from all the other work
+            SkPicturePlayback::Foo* temp = foo->lookupStop(reader.offset());
+            if (NULL != temp) {
+                SkASSERT(NULL != temp->fBM);
+                uint32_t size;
+                SkDEBUGCODE(DrawType op =) read_op_and_size(&reader, &size);
+                SkASSERT(RESTORE == op);
+
+                canvas.restore();
+
+                canvas.drawBitmap(*temp->fBM, temp->fPos.fX, temp->fPos.fY, temp->fPaint);
+                continue;
+            }
+#endif
+        }
 
 #ifdef SPEW_CLIP_SKIPPING
         opCount++;
 #endif
 
         fCurOffset = reader.offset();
         uint32_t size;
         DrawType op = read_op_and_size(&reader, &size);
         size_t skipTo = 0;
         if (NOOP == op) {
@@ skipping 312 matching lines @@
             case RESTORE:
                 canvas.restore();
                 break;
             case ROTATE:
                 canvas.rotate(reader.readScalar());
                 break;
             case SAVE:
                 canvas.save((SkCanvas::SaveFlags) reader.readInt());
                 break;
             case SAVE_LAYER: {
+#if 1
                 const SkRect* boundsPtr = this->getRectPtr(reader);
                 const SkPaint* paint = this->getPaint(reader);
                 canvas.saveLayer(boundsPtr, paint, (SkCanvas::SaveFlags) reader.readInt());
+#else
+                // replace all saveLayers with a save
+                this->getRectPtr(reader);
+                this->getPaint(reader);
+                canvas.save((SkCanvas::SaveFlags) reader.readInt());
+#endif
                 } break;
             case SCALE: {
                 SkScalar sx = reader.readScalar();
                 SkScalar sy = reader.readScalar();
                 canvas.scale(sx, sy);
             } break;
             case SET_MATRIX: {
                 SkMatrix matrix;
                 this->getMatrix(reader, &matrix);
                 matrix.postConcat(initialMatrix);
@@ skipping 543 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