allow canvas to force conservative clips (for speed)

src/core/SkRasterClip.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkRasterClip.h"
-
-
-SkRasterClip::SkRasterClip() {
-    fIsBW = true;
-    fIsEmpty = true;
-    fIsRect = false;
-    SkDEBUGCODE(this->validate();)
-}
+#include "SkPath.h"
 
 SkRasterClip::SkRasterClip(const SkRasterClip& src) {
     AUTO_RASTERCLIP_VALIDATE(src);
 
+    fForceConservativeRects = src.fForceConservativeRects;
     fIsBW = src.fIsBW;
     if (fIsBW) {
         fBW = src.fBW;
     } else {
         fAA = src.fAA;
     }
 
     fIsEmpty = src.isEmpty();
     fIsRect = src.isRect();
     SkDEBUGCODE(this->validate();)
 }
 
-SkRasterClip::SkRasterClip(const SkIRect& bounds) : fBW(bounds) {
+SkRasterClip::SkRasterClip(const SkIRect& bounds, bool forceConservativeRects) : fBW(bounds) {
+    fForceConservativeRects = forceConservativeRects;
     fIsBW = true;
     fIsEmpty = this->computeIsEmpty();  // bounds might be empty, so compute
     fIsRect = !fIsEmpty;
     SkDEBUGCODE(this->validate();)
 }
 
+SkRasterClip::SkRasterClip(bool forceConservativeRects) {
+    fForceConservativeRects = forceConservativeRects;
+    fIsBW = true;
+    fIsEmpty = true;
+    fIsRect = false;
+    SkDEBUGCODE(this->validate();)
+}
+
 SkRasterClip::~SkRasterClip() {
     SkDEBUGCODE(this->validate();)
 }
 
 bool SkRasterClip::isComplex() const {
     return fIsBW ? fBW.isComplex() : !fAA.isEmpty();
 }
 
 const SkIRect& SkRasterClip::getBounds() const {
     return fIsBW ? fBW.getBounds() : fAA.getBounds();
@@ skipping 13 matching lines @@
 bool SkRasterClip::setRect(const SkIRect& rect) {
     AUTO_RASTERCLIP_VALIDATE(*this);
 
     fIsBW = true;
     fAA.setEmpty();
     fIsRect = fBW.setRect(rect);
     fIsEmpty = !fIsRect;
     return fIsRect;
 }
 
+/////////////////////////////////////////////////////////////////////////////////////
+
+bool SkRasterClip::setConservativeRect(const SkRect& r, const SkIRect& clipR, bool isInverse) {
+    SkIRect ir;
+    r.roundOut(&ir);
+
+    SkRegion::Op op;
+    if (isInverse) {
+        op = SkRegion::kDifference_Op;
+    } else {
+        op = SkRegion::kIntersect_Op;
+    }
+    fBW.setRect(clipR);
+    fBW.op(ir, op);
+    return this->updateCacheAndReturnNonEmpty();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+
+enum MutateResult {
+    kDoNothing_MutateResult,
+    kReplaceClippedAgainstGlobalBounds_MutateResult,
+    kContinue_MutateResult,
+};
+
+static MutateResult mutate_conservative_op(SkRegion::Op* op, bool inverseFilled) {
+    if (inverseFilled) {
+        switch (*op) {
+            case SkRegion::kIntersect_Op:
+            case SkRegion::kDifference_Op:
+                // These ops can only shrink the current clip. So leaving
+                // the clip unchanged conservatively respects the contract.
+                return kDoNothing_MutateResult;
+            case SkRegion::kUnion_Op:
+            case SkRegion::kReplace_Op:
+            case SkRegion::kReverseDifference_Op:
+            case SkRegion::kXOR_Op: {
+                // These ops can grow the current clip up to the extents of
+                // the input clip, which is inverse filled, so we just set
+                // the current clip to the device bounds.
+                *op = SkRegion::kReplace_Op;
+                return kReplaceClippedAgainstGlobalBounds_MutateResult;
+            }
+        }
+    } else {
+        // Not inverse filled
+        switch (*op) {
+            case SkRegion::kIntersect_Op:
+            case SkRegion::kUnion_Op:
+            case SkRegion::kReplace_Op:
+                return kContinue_MutateResult;
+            case SkRegion::kDifference_Op:
+                // Difference can only shrink the current clip.
+                // Leaving clip unchanged conservatively fullfills the contract.
+                return kDoNothing_MutateResult;
+            case SkRegion::kReverseDifference_Op:
+                // To reverse, we swap in the bounds with a replace op.
+                // As with difference, leave it unchanged.
+                *op = SkRegion::kReplace_Op;
+                return kContinue_MutateResult;
+            case SkRegion::kXOR_Op:
+                // Be conservative, based on (A XOR B) always included in (A union B),
+                // which is always included in (bounds(A) union bounds(B))
+                *op = SkRegion::kUnion_Op;
+                return kContinue_MutateResult;
+        }
+    }
+    SkFAIL("should not get here");
+    return kDoNothing_MutateResult;
+}
+
 bool SkRasterClip::setPath(const SkPath& path, const SkRegion& clip, bool doAA) {
     AUTO_RASTERCLIP_VALIDATE(*this);
 
+    if (fForceConservativeRects) {
+        return this->setConservativeRect(path.getBounds(), clip.getBounds(), path.isInverseFillType());
+    }
+
     if (this->isBW() && !doAA) {
         (void)fBW.setPath(path, clip);
     } else {
         // TODO: since we are going to over-write fAA completely (aren't we?)
         // we should just clear our BW data (if any) and set fIsAA=true
         if (this->isBW()) {
             this->convertToAA();
         }
         (void)fAA.setPath(path, &clip, doAA);
     }
     return this->updateCacheAndReturnNonEmpty();
 }
 
 bool SkRasterClip::op(const SkPath& path, const SkISize& size, SkRegion::Op op, bool doAA) {
     // base is used to limit the size (and therefore memory allocation) of the
     // region that results from scan converting devPath.
     SkRegion base;
-    
+

[robertphillips, 2014/09/10 14:44:23]

Subroutine for this and the version in SkRasterClip::op ?

+    if (fForceConservativeRects) {
+        SkIRect ir;
+        switch (mutate_conservative_op(&op, path.isInverseFillType())) {
+            case kDoNothing_MutateResult:
+                return !this->isEmpty();
+            case kReplaceClippedAgainstGlobalBounds_MutateResult:
+                ir = SkIRect::MakeSize(size);
+                break;
+            case kContinue_MutateResult:
+                path.getBounds().roundOut(&ir);
+                break;
+        }
+        return this->op(ir, op);
+    }
+
     if (SkRegion::kIntersect_Op == op) {
         // since we are intersect, we can do better (tighter) with currRgn's
         // bounds, than just using the device. However, if currRgn is complex,
         // our region blitter may hork, so we do that case in two steps.
         if (this->isRect()) {
             // FIXME: we should also be able to do this when this->isBW(),
             // but relaxing the test above triggers GM asserts in
             // SkRgnBuilder::blitH(). We need to investigate what's going on.
             return this->setPath(path, this->bwRgn(), doAA);
         } else {
             base.setRect(this->getBounds());
-            SkRasterClip clip;
+            SkRasterClip clip(fForceConservativeRects);
             clip.setPath(path, base, doAA);
             return this->op(clip, op);
         }
     } else {
         base.setRect(0, 0, size.width(), size.height());
         
         if (SkRegion::kReplace_Op == op) {
             return this->setPath(path, base, doAA);
         } else {
-            SkRasterClip clip;
+            SkRasterClip clip(fForceConservativeRects);
             clip.setPath(path, base, doAA);
             return this->op(clip, op);
         }
     }
 }
 
 bool SkRasterClip::setPath(const SkPath& path, const SkIRect& clip, bool doAA) {
     SkRegion tmp;
     tmp.setRect(clip);
     return this->setPath(path, tmp, doAA);
@@ skipping 49 matching lines @@
  *  from its nearest int by < half of that value (1.8 in this case).
  */
 static bool nearly_integral(SkScalar x) {
     static const SkScalar domain = SK_Scalar1 / 4;
     static const SkScalar halfDomain = domain / 2;
 
     x += halfDomain;
     return x - SkScalarFloorToScalar(x) < domain;
 }
 
-bool SkRasterClip::op(const SkRect& r, SkRegion::Op op, bool doAA) {
+bool SkRasterClip::op(const SkRect& r, const SkISize& size, SkRegion::Op op, bool doAA) {
     AUTO_RASTERCLIP_VALIDATE(*this);
 
+    if (fForceConservativeRects) {
+        SkIRect ir;
+        switch (mutate_conservative_op(&op, false)) {
+            case kDoNothing_MutateResult:
+                return !this->isEmpty();
+            case kReplaceClippedAgainstGlobalBounds_MutateResult:
+                ir = SkIRect::MakeSize(size);
+                break;
+            case kContinue_MutateResult:
+                r.roundOut(&ir);
+                break;
+        }
+        return this->op(ir, op);
+    }
+    
     if (fIsBW && doAA) {
         // check that the rect really needs aa, or is it close enought to
         // integer boundaries that we can just treat it as a BW rect?
         if (nearly_integral(r.fLeft) && nearly_integral(r.fTop) &&
             nearly_integral(r.fRight) && nearly_integral(r.fBottom)) {
             doAA = false;
         }
     }
 
     if (fIsBW && !doAA) {
@@ skipping 46 matching lines @@
     AUTO_RASTERCLIP_VALIDATE(*this);
 
     if (!fIsBW) {
         fBW.setRect(fAA.getBounds());
     }
     return fBW;
 }
 
 void SkRasterClip::convertToAA() {
     AUTO_RASTERCLIP_VALIDATE(*this);
-
+    
+    SkASSERT(!fForceConservativeRects);
+    
     SkASSERT(fIsBW);
     fAA.setRegion(fBW);
     fIsBW = false;
     
     // since we are being explicitly asked to convert-to-aa, we pass false so we don't "optimize"
     // ourselves back to BW.
     (void)this->updateCacheAndReturnNonEmpty(false);
 }
 
 #ifdef SK_DEBUG
@@ skipping 41 matching lines @@
         fBlitter = blitter;
     } else {
         const SkAAClip& aaclip = clip.aaRgn();
         fBWRgn.setRect(aaclip.getBounds());
         fAABlitter.init(blitter, &aaclip);
         // now our return values
         fClipRgn = &fBWRgn;
         fBlitter = &fAABlitter;
     }
 }