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 = true;

[reed1, 2013/03/08 20:23:23]

do we want false here?

[Justin Novosad, 2013/03/08 22:35:42]

Done.

+#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 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;

[reed1, 2013/03/08 20:23:23]

SkToBool(...)

[Justin Novosad, 2013/03/08 22:35:42]

Done.

     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;
 }
 
+static inline bool get_intial_clip_bounds(const SkCanvas& canvas, SkIRect* bounds, bool* isSet) {

[reed1, 2013/03/08 20:23:23]

Maybe this is the best way, but this treats both isSet and bounds as
input/output params, which is unexpected in general. Of note, we call this
sometimes with an uninitialized bounds, and just happen to know that we are
passing the right value in isSet so that bounds won't be read-from. Is there a
cleaner way to organize this? Perhaps diff variants of this that don't overload
the params so much?

getClipBounds returns its answer in local coordinates, yet you are rounding it
to IRect (which we typically use for device-bounds).

[Justin Novosad, 2013/03/08 22:35:42]

Done.

+    SkASSERT(NULL != bounds && NULL != isSet);
+    if (!(*isSet)) {
+        SkRect clipBounds;
+        *isSet = true;
+        if (canvas.getClipBounds(&clipBounds)) {
+            clipBounds.roundOut(bounds);
+        } else {
+            bounds->setEmpty();
+            return false;
+        }
+    }
+    return !bounds->isEmpty();
+}
+
 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;
 
+    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);
+        if (get_intial_clip_bounds(canvas, &initialClipBounds, &initialClipBoundsSet)) {
+            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 (!get_intial_clip_bounds(canvas, &initialClipBounds, &initialClipBoundsSet)) {
+            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);
-        if (NOOP == op) {
-            // NOOPs are to be ignored - do not propagate them any further
-            reader.setOffset(curOffset+size);
-            continue;
+        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) {
+            if (NOOP == op) {
+                // NOOPs are to be ignored - do not propagate them any further
+                skipTo = curOffset + size;
+            } 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;
+                }
+            }
         }
 
-#ifdef SK_DEVELOPER
-        // TODO: once chunk sizes are in all .skps just use "curOffset + size"
-        size_t skipTo = this->preDraw(curOffset, op);
         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);
+                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