First pass at pre-rendering saveLayers for GPU

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 "SkPicturePlayback.h"
 #include "SkPictureRecord.h"
@@ skipping 187 matching lines @@
     fBitmaps = NULL;
     fPaints = NULL;
     fPictureRefs = NULL;
     fPictureCount = 0;
     fOpData = NULL;
     fFactoryPlayback = NULL;
     fBoundingHierarchy = NULL;
     fStateTree = NULL;
     fCachedActiveOps = NULL;
     fCurOffset = 0;
+    fUseBBH = true;
+    fStart = 0;
+    fStop = 0;
+    fReplacements = NULL;
 }
 
 SkPicturePlayback::~SkPicturePlayback() {
     SkSafeUnref(fOpData);
 
     SkSafeUnref(fBitmaps);
     SkSafeUnref(fPaints);
     SkSafeUnref(fBoundingHierarchy);
     SkSafeUnref(fStateTree);
 
@@ skipping 519 matching lines @@
     ~SkAutoResetOpID() {
         if (NULL != fPlayback) {
             fPlayback->resetOpID();
         }
     }
 
 private:
     SkPicturePlayback* fPlayback;
 };
 
+// TODO: Replace with hash or pass in "lastLookedUp" hint
+SkPicturePlayback::PlaybackReplacements::ReplacementInfo* 
+SkPicturePlayback::PlaybackReplacements::lookupByStart(size_t start) {
+    SkDEBUGCODE(this->validate());
+    for (int i = 0; i < fReplacements.count(); ++i) {
+        if (start == fReplacements[i].fStart) {
+            return &fReplacements[i];
+        } else if (start < fReplacements[i].fStart) {
+            return NULL;  // the ranges are monotonically increasing and non-overlapping
+        }
+    }
+
+    return NULL;
+}
+
 void SkPicturePlayback::draw(SkCanvas& canvas, SkDrawPictureCallback* callback) {
     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);
+    // When draw limits are enabled (i.e., 0 != fStart || 0 != fStop) the state
+    // tree isn't used to pick and choose the draw operations
+    if (0 == fStart && 0 == fStop) {
+        if (fUseBBH && 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 (0 != fStart || 0 != fStop) {
+        reader.setOffset(fStart);
+        uint32_t size;
+        SkDEBUGCODE(DrawType op =) read_op_and_size(&reader, &size);
+        SkASSERT(SAVE_LAYER == op);
+        reader.setOffset(fStart+size);
+    }
+
     if (it.isValid()) {
         uint32_t skipTo = it.nextDraw();
         if (kDrawComplete == skipTo) {
             return;
         }
         reader.setOffset(skipTo);
     }
 
     // Record this, so we can concat w/ it if we encounter a setMatrix()
     SkMatrix initialMatrix = canvas.getTotalMatrix();
@@ skipping 10 matching lines @@
     while (!reader.eof()) {
         if (callback && callback->abortDrawing()) {
             canvas.restoreToCount(originalSaveCount);
             return;
         }
 #ifdef SK_BUILD_FOR_ANDROID
         if (fAbortCurrentPlayback) {
             return;
         }
 #endif
+        if (0 != fStart || 0 != fStop) {
+            size_t offset = reader.offset() ;
+            if (offset >= fStop) {
+                uint32_t size;
+                SkDEBUGCODE(DrawType op =) read_op_and_size(&reader, &size);
+                SkASSERT(RESTORE == op);
+                return;
+            }
+        }
+
+        if (NULL != fReplacements) {
+            // Potentially replace a block of operations with a single drawBitmap call
+            SkPicturePlayback::PlaybackReplacements::ReplacementInfo* temp = 
+                                            fReplacements->lookupByStart(reader.offset());
+            if (NULL != temp) {
+                SkASSERT(NULL != temp->fBM);
+                SkASSERT(NULL != temp->fPaint);
+                canvas.drawBitmap(*temp->fBM, temp->fPos.fX, temp->fPos.fY, temp->fPaint);
+
+                if (it.isValid()) {
+                    // This save is needed since the BBH will automatically issue
+                    // a restore to balanced the saveLayer we're skipping
+                    canvas.save();
+                    // Note: This skipping only works if the client only issues
+                    // well behaved saveLayer calls (i.e., doesn't use 
+                    // kMatrix_SaveFlag or kClip_SaveFlag in isolation)
+
+                    // At this point we know that the PictureStateTree was aiming
+                    // for some draw op within temp's saveLayer (although potentially
+                    // in a separate saveLayer nested inside it).
+                    // We need to skip all the operations inside temp's range
+                    // along with all the associated state changes but update 
+                    // the state tree to the first operation outside temp's range.
+                    SkASSERT(it.peekDraw() >= temp->fStart && it.peekDraw() <= temp->fStop);
+
+                    while (kDrawComplete != it.peekDraw() && it.peekDraw() <= temp->fStop) {
+                        it.skipDraw();
+                    }
+
+                    if (kDrawComplete == it.peekDraw()) {
+                        break;
+                    }
+
+                    uint32_t skipTo = it.nextDraw();
+                    reader.setOffset(skipTo);
+                } else {
+                    reader.setOffset(temp->fStop);
+                    uint32_t size;
+                    SkDEBUGCODE(DrawType op =) read_op_and_size(&reader, &size);
+                    SkASSERT(RESTORE == op);
+                }
+                continue;
+            }
+        }
 
 #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 74 matching lines @@
                     reader.setOffset(offsetToRestore);
                 }
             } break;
             case CLIP_RRECT: {
                 SkRRect rrect;
                 reader.readRRect(&rrect);
                 uint32_t packed = reader.readInt();
                 SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
                 bool doAA = ClipParams_unpackDoAA(packed);
                 size_t offsetToRestore = reader.readInt();
-                SkASSERT(!offsetToRestore || \
-                         offsetToRestore >= reader.offset());
+                SkASSERT(!offsetToRestore || offsetToRestore >= reader.offset());
                 canvas.clipRRect(rrect, regionOp, doAA);
                 if (canvas.isClipEmpty() && offsetToRestore) {
 #ifdef SPEW_CLIP_SKIPPING
                     skipRRect.recordSkip(offsetToRestore - reader.offset());
 #endif
                     reader.setOffset(offsetToRestore);
                 }
             } break;
             case PUSH_CULL: {
                 const SkRect& cullRect = reader.skipT<SkRect>();
@@ skipping 782 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