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();
             }
         }
     }
 
+#if SK_RECORD_BOUNDS_IN_PICTURE
+    fHasRecordedBounds = true;
+#else
+    fHasRecordedBounds = false;
+#endif
+
 #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 302 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();
-
+#if SK_RECORD_BOUNDS_IN_PICTURE
+    fHasRecordedBounds = SkToBool(info.fFlags & SkPictInfo::kHasRecordedBounds_Flag);
+#else
+    // Can't handle skps with recorded bounds in a build that does support them.

[Tom Hudson, 2013/05/14 17:00:49]

Typo: does *not* support them?

+    SkASSERT(false == SkToBool(info.fFlags & SkPictInfo::kHasRecordedBounds_Flag));
+    fHasRecordedBounds = false;
+#endif
     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 43 matching lines @@
         *size = 0;
     } else {
         UNPACK_8_24(temp, op, *size);
         if (MASK_24 == *size) {
             *size = reader->readInt();
         }
     }
     return (DrawType) op;
 }
 
+// Sets 'bounds' to represent the clip bounds of the playback canvas,
+// expressed in the recording device's coordinate space.
+// returns true if the bounds are not empty.
+static inline bool get_intial_clip_bounds(const SkCanvas& canvas, SkIRect* bounds) {
+    SkASSERT(NULL != bounds);
+    SkRect clipBounds;
+    if (canvas.getClipBounds(&clipBounds)) {
+        clipBounds.roundOut(bounds);
+    } else {
+        bounds->setEmpty();
+        return false;
+    }
+    return !bounds->isEmpty();
+}
+
+class SkDisableQuickRejectInScope {
+public:
+    SkDisableQuickRejectInScope() {
+        fCanvas = NULL;

[Tom Hudson, 2013/05/14 17:00:49]

Why not pass a canvas to the constructor, and avoid set()?

+    }
+    void set(SkCanvas* canvas) {
+        if (canvas->fQuickRejectEnabled == true) {

[Tom Hudson, 2013/05/14 17:00:49]

// protect against nested Disables

+            fCanvas = canvas;
+            fCanvas->fQuickRejectEnabled = false;
+        } 
+    }
+
+    ~SkDisableQuickRejectInScope() {
+        if (fCanvas) {
+            fCanvas->fQuickRejectEnabled = true;
+        }
+    }
+private:
+    SkCanvas* fCanvas;
+};
+
 void SkPicturePlayback::draw(SkCanvas& canvas) {
 #ifdef ENABLE_TIME_DRAW
     SkAutoTime  at("SkPicture::draw", 50);
 #endif
 
 #ifdef SPEW_CLIP_SKIPPING
     SkipClipRec skipRect, skipRRect, skipRegion, skipPath;
 #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;
     SkTDArray<void*> results;
 
+#if SK_RECORD_BOUNDS_IN_PICTURE
+    bool initialClipBoundsSet = false;
+#endif
+    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);
-            if (results.count() == 0) {
-                return;
-            }
-            SkTQSort<SkPictureStateTree::Draw>(
-                reinterpret_cast<SkPictureStateTree::Draw**>(results.begin()),
-                reinterpret_cast<SkPictureStateTree::Draw**>(results.end()-1));
+        if (!get_intial_clip_bounds(canvas, &initialClipBounds)) {
+            return;

[Tom Hudson, 2013/05/14 17:00:49]

You now have an early return where it looks like you used to fall through?

         }
+        fBoundingHierarchy->search(initialClipBounds, &results);
+        if (results.count() == 0) {
+            return;
+        }
+#if SK_RECORD_BOUNDS_IN_PICTURE
+        initialClipBoundsSet = true;
+#endif
+        SkTQSort<SkPictureStateTree::Draw>(
+            reinterpret_cast<SkPictureStateTree::Draw**>(results.begin()),
+            reinterpret_cast<SkPictureStateTree::Draw**>(results.end()-1));
     }
 
+#if SK_RECORD_BOUNDS_IN_PICTURE
+    SkDisableQuickRejectInScope dqr;
+    if (fHasRecordedBounds) {
+        // Temporarily disable quickReject testing on 'canvas'
+        // because it is redundant with early bounds check.

[Tom Hudson, 2013/05/14 17:00:49]

Nit: Second line of this comment is more useful than the first.

+        dqr.set(&canvas);

[Tom Hudson, 2013/05/14 17:00:49]

Ugh, given that you need this to be conditionally activated I suppose I see why
you created set() instead of passing the canvas to the constructor.

+        if (!initialClipBoundsSet && !get_intial_clip_bounds(canvas, &initialClipBounds)) {
+            return;
+        }
+        initialClipBoundsSet = true;
+    }
+#endif
+
     SkPictureStateTree::Iterator it = (NULL == fStateTree) ?
         SkPictureStateTree::Iterator() :
         fStateTree->getIterator(results, &canvas);
 
     if (it.isValid()) {
         uint32_t skipTo = it.draw();
         if (kDrawComplete == skipTo) {
             return;
         }
         reader.setOffset(skipTo);
@@ skipping 15 matching lines @@
 
         size_t curOffset = reader.offset();
         uint32_t size;
         DrawType op = read_op_and_size(&reader, &size);
         size_t skipTo = 0;
 #ifdef SK_DEVELOPER
         // TODO: once chunk sizes are in all .skps just use
         // "curOffset + size"
         skipTo = this->preDraw(curOffset, op);
 #endif
-        if (0 == skipTo && NOOP == op) {
-            // NOOPs are to be ignored - do not propagate them any further
-            skipTo = curOffset + size;
+        if (0 == skipTo) {
+            if (NOOP == op) {
+                // NOOPs are to be ignored - do not propagate them any further
+                skipTo = curOffset + size;
+            }  
+#if SK_RECORD_BOUNDS_IN_PICTURE
+            else 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.
+                SkASSERT(initialClipBoundsSet);
+                if (!SkIRect::Intersects(clippedBounds, initialClipBounds)) {
+                    skipTo = curOffset + size;
+                }
+            }
+#endif
         }
 
         if (0 != skipTo) {
             if (it.isValid()) {
                 // If using a bounding box hierarchy, advance the state tree
                 // iterator until at or after skipTo
                 uint32_t adjustedSkipTo;
                 do {
                     adjustedSkipTo = it.draw();
                 } while (adjustedSkipTo < skipTo);
@@ skipping 844 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