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 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();
-
+#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.
+    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();
+}
+
 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 (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;
         }
+        fBoundingHierarchy->search(initialClipBounds, &results);
+        if (results.count() == 0) {
+            return;
+        }
+        initialClipBoundsSet = true;
+        SkTQSort<SkPictureStateTree::Draw>(
+            reinterpret_cast<SkPictureStateTree::Draw**>(results.begin()),
+            reinterpret_cast<SkPictureStateTree::Draw**>(results.end()-1));
     }
 
+#if SK_RECORD_BOUNDS_IN_PICTURE
+    if (fHasRecordedBounds) {
+        // TODO(junov): temporarily disable quickReject testing on 'canvas'
+        // because it is redundant with early bounds check.
+        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);
     }
 
     // Record this, so we can concat w/ it if we encounter a setMatrix()
     SkMatrix initialMatrix = canvas.getTotalMatrix();
 
 #ifdef SK_BUILD_FOR_ANDROID
     fAbortCurrentPlayback = false;
 #endif
 
     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;
+            }  
+#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
         }
 
-#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