Adding option in SkPicture to record device-space bounds of draw commands.

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 106 matching lines @@
         for (int i = 0; i < fPictureCount; i++) {
             if (deepCopy) {
                 fPictureRefs[i] = pictures[i]->clone();
             } else {
                 fPictureRefs[i] = pictures[i];
                 fPictureRefs[i]->ref();
             }
         }
     }
 
+    fHasRecordedBounds = record.recordBounds();
+
 #ifdef SK_DEBUG_SIZE
     int overall = fPlayback->size(&overallBytes);
     bitmaps = fPlayback->bitmaps(&bitmapBytes);
     paints = fPlayback->paints(&paintBytes);
     paths = fPlayback->paths(&pathBytes);
     pictures = fPlayback->pictures(&pictureBytes);
     regions = fPlayback->regions(&regionBytes);
     SkDebugf("playback size %zd (objects:%d) ", overallBytes, overall);
     if (bitmaps != 0)
         SkDebugf("bitmaps size %zd (bitmaps:%d) ", bitmapBytes, bitmaps);
@@ skipping 32 matching lines @@
 
     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;
-
+    fHasRecordedBounds = src.fHasRecordedBounds;
     SkSafeRef(fBoundingHierarchy);
     SkSafeRef(fStateTree);
 
     if (deepCopyInfo) {
         int paintCount = SafeCount(src.fPaints);
 
         if (src.fBitmaps) {
             fBitmaps = SkTRefArray<SkBitmap>::Create(src.fBitmaps->begin(), src.fBitmaps->count());
         }
 
@@ skipping 73 matching lines @@
     fBitmaps = NULL;
     fMatrices = NULL;
     fPaints = NULL;
     fPictureRefs = NULL;
     fRegions = NULL;
     fPictureCount = 0;
     fOpData = NULL;
     fFactoryPlayback = NULL;
     fBoundingHierarchy = NULL;
     fStateTree = NULL;
+    fHasRecordedBounds = false;
 }
 
 SkPicturePlayback::~SkPicturePlayback() {
     fOpData->unref();
 
     SkSafeUnref(fBitmaps);
     SkSafeUnref(fMatrices);
     SkSafeUnref(fPaints);
     SkSafeUnref(fRegions);
     SkSafeUnref(fBoundingHierarchy);
@@ skipping 296 matching lines @@
             for (size_t i = 0; i < size; ++i) {
                 buffer.readRegion(&fRegions->writableAt(i));
             }
         } break;
     }
 }
 
 SkPicturePlayback::SkPicturePlayback(SkStream* stream, const SkPictInfo& info,
                                      SkPicture::InstallPixelRefProc proc) {
     this->init();
-
+    fHasRecordedBounds = info.fFlags & SkPictInfo::kHasRecordedBounds_Flag;
     for (;;) {
         uint32_t tag = stream->readU32();
         if (PICT_EOF_TAG == tag) {
             break;
         }
 
         uint32_t size = stream->readU32();
         this->parseStreamTag(stream, info, tag, size, proc);
     }
 }
@@ skipping 64 matching lines @@
 #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;
     SkTDArray<void*> results;
 
+    bool initialClipBoundsSet = false;
+    SkIRect initialClipBounds;  // only computed if needed
     if (NULL != fStateTree && NULL != fBoundingHierarchy) {
         SkRect clipBounds;
         if (canvas.getClipBounds(&clipBounds)) {
-            SkIRect query;
-            clipBounds.roundOut(&query);
-            fBoundingHierarchy->search(query, &results);
+            clipBounds.roundOut(&initialClipBounds);
+            initialClipBoundsSet = true;
+            fBoundingHierarchy->search(initialClipBounds, &results);
             if (results.count() == 0) {
                 return;
             }
             SkTQSort<SkPictureStateTree::Draw>(
                 reinterpret_cast<SkPictureStateTree::Draw**>(results.begin()),
                 reinterpret_cast<SkPictureStateTree::Draw**>(results.end()-1));
+        } else {
+            return;
+        }
+    }
+
+    if (fHasRecordedBounds) {
+        // TODO(junov): temporarily disable quickReject testing on 'canvas'
+        // because it is redundant with early bounds check.
+        if (!initialClipBoundsSet) {

[robertphillips, 2013/03/07 18:37:40]

Would it make sense to have a "bool get_initial_clip_bounds(SkCanvas*,
SkIRect*)" helper to share code between here and above (and hide the
'clipBounds' temp)?

+            SkRect clipBounds;
+            if (canvas.getClipBounds(&clipBounds)) {
+                clipBounds.roundOut(&initialClipBounds);

[robertphillips, 2013/03/07 18:37:40]

initialClipBoundsSet = true;?

+            } else {
+                return;
+            }
         }
     }
 
     SkPictureStateTree::Iterator it = (NULL == fStateTree) ?
         SkPictureStateTree::Iterator() :
         fStateTree->getIterator(results, &canvas);
 
     if (it.isValid()) {
         uint32_t skipTo = it.draw();
         if (kDrawComplete == skipTo) {
@@ skipping 12 matching lines @@
     while (!reader.eof()) {
 #ifdef SK_BUILD_FOR_ANDROID
         if (fAbortCurrentPlayback) {
             return;
         }
 #endif
 
         size_t curOffset = reader.offset();
         uint32_t size;
         DrawType op = read_op_and_size(&reader, &size);
+        size_t skipTo = 0;
         if (NOOP == op) {
             // NOOPs are to be ignored - do not propagate them any further
-            reader.setOffset(curOffset+size);
-            continue;
+            skipTo = curOffset + size;
+        }

[robertphillips, 2013/03/07 18:37:40]

add else here?

+        if (fHasRecordedBounds && SkPictureRecord::canRecordBounds(op)) {
+            const SkIRect& clippedBounds = reader.skipT<SkIRect>();
+            // recording canvas device bounds are in the same coordinate space as
+            // local clip bounds at start of playback.

[robertphillips, 2013/03/07 18:37:40]

SkASSERT(initialClipBoundsSet);?

+            if (!SkIRect::Intersects(clippedBounds, initialClipBounds)) {
+                // This test replaces SkCanvas::quickReject when using
+                // kRecordBounds_RecordingFlag
+                skipTo = curOffset + size;
+            }
         }
 
 #ifdef SK_DEVELOPER
         // TODO: once chunk sizes are in all .skps just use "curOffset + size"
-        size_t skipTo = this->preDraw(curOffset, op);
+        skipTo = this->preDraw(curOffset, op);
+#endif
         if (0 != skipTo) {
+            if (it.isValid()) {
+                // If using a bounding box hierarchy, advance the state tree
+                // iterator until at or after skipTo

[reed1, 2013/03/07 20:36:44]

do {
   adjusted = it.draw()
} while (adjusted < skipTo);

+                uint32_t adjustedSkipTo = it.draw();
+                while (adjustedSkipTo < skipTo) {
+                    adjustedSkipTo = it.draw();
+                }
+                skipTo = adjustedSkipTo;
+            }
             if (kDrawComplete == skipTo) {
                 break;
             }
             reader.setOffset(skipTo);
             continue;
         }
-#endif
+
         switch (op) {
             case CLIP_PATH: {
                 const SkPath& path = getPath(reader);
                 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());
                 if (!canvas.clipPath(path, regionOp, doAA) && offsetToRestore) {
@@ skipping 825 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