interesct path bounds with clip bounds before initializing supersampler

src/core/SkScan_AntiPath.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkScanPriv.h"
@@ skipping 27 matching lines @@
 //#define FORCE_SUPERMASK
 //#define FORCE_RLE
 //#define SK_USE_LEGACY_AA_COVERAGE
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /// Base class for a single-pass supersampled blitter.
 class BaseSuperBlitter : public SkBlitter {
 public:
     BaseSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
-                     const SkRegion& clip);
+                     const SkRegion& clip, bool isInverse);
 
     /// Must be explicitly defined on subclasses.
     virtual void blitAntiH(int x, int y, const SkAlpha antialias[],
                            const int16_t runs[]) SK_OVERRIDE {
         SkDEBUGFAIL("How did I get here?");
     }
     /// May not be called on BaseSuperBlitter because it blits out of order.
     virtual void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE {
         SkDEBUGFAIL("How did I get here?");
     }
 
 protected:
     SkBlitter*  fRealBlitter;
     /// Current y coordinate, in destination coordinates.
     int         fCurrIY;
     /// Widest row of region to be blitted, in destination coordinates.
     int         fWidth;
     /// Leftmost x coordinate in any row, in destination coordinates.
     int         fLeft;
     /// Leftmost x coordinate in any row, in supersampled coordinates.
     int         fSuperLeft;
 
     SkDEBUGCODE(int fCurrX;)
     /// Current y coordinate in supersampled coordinates.
     int fCurrY;
     /// Initial y coordinate (top of bounds).
     int fTop;
+
+    SkIRect fSectBounds;
 };
 
-BaseSuperBlitter::BaseSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
-                                   const SkRegion& clip) {
-    fRealBlitter = realBlitter;
+BaseSuperBlitter::BaseSuperBlitter(SkBlitter* realBlit, const SkIRect& ir, const SkRegion& clip,
+                                   bool isInverse) {
+    fRealBlitter = realBlit;
+
+    SkIRect sectBounds;
+    if (isInverse) {
+        sectBounds = clip.getBounds();
+    } else {
+        if (!sectBounds.intersect(ir, clip.getBounds())) {
+            sectBounds.setEmpty();
+        }
+    }
 
     /*
      *  We use the clip bounds instead of the ir, since we may be asked to
      *  draw outside of the rect if we're a inverse filltype

[caryclark, 2014/10/15 15:51:31]

comment no longer accurate?

      */
-    const int left = clip.getBounds().fLeft;
-    const int right = clip.getBounds().fRight;
+    const int left = sectBounds.left();
+    const int right = sectBounds.right();
 
     fLeft = left;
     fSuperLeft = left << SHIFT;
     fWidth = right - left;
-#if 0
-    fCurrIY = -1;
-    fCurrY = -1;
-#else
-    fTop = ir.fTop;
-    fCurrIY = ir.fTop - 1;
-    fCurrY = (ir.fTop << SHIFT) - 1;
-#endif
+    fTop = sectBounds.top();
+    fCurrIY = fTop - 1;
+    fCurrY = (fTop << SHIFT) - 1;
+
     SkDEBUGCODE(fCurrX = -1;)
 }
 
 /// Run-length-encoded supersampling antialiased blitter.
 class SuperBlitter : public BaseSuperBlitter {
 public:
-    SuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
-                 const SkRegion& clip);
+    SuperBlitter(SkBlitter* realBlitter, const SkIRect& ir, const SkRegion& clip, bool isInverse);
 
     virtual ~SuperBlitter() {
         this->flush();
     }
 
     /// Once fRuns contains a complete supersampled row, flush() blits
     /// it out through the wrapped blitter.
     void flush();
 
     /// Blits a row of pixels, with location and width specified
@@ skipping 24 matching lines @@
         fCurrentRun = (fCurrentRun + 1) % fRunsToBuffer;
         fRuns.fRuns = reinterpret_cast<int16_t*>(
             reinterpret_cast<uint8_t*>(fRunsBuffer) + fCurrentRun * kRunsSz);
         fRuns.fAlpha = reinterpret_cast<SkAlpha*>(fRuns.fRuns + fWidth + 1);
         fRuns.reset(fWidth);
     }
 
     int         fOffsetX;
 };
 
-SuperBlitter::SuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
-                           const SkRegion& clip)
-        : BaseSuperBlitter(realBlitter, ir, clip) {
+SuperBlitter::SuperBlitter(SkBlitter* realBlitter, const SkIRect& ir, const SkRegion& clip,
+                           bool isInverse)
+        : BaseSuperBlitter(realBlitter, ir, clip, isInverse)
+{
     fRunsToBuffer = realBlitter->requestRowsPreserved();
     fRunsBuffer = realBlitter->allocBlitMemory(fRunsToBuffer * this->getRunsSz());
     fCurrentRun = -1;
 
     this->advanceRuns();
 
     fOffsetX = 0;
 }
 
 void SuperBlitter::flush() {
@@ skipping 226 matching lines @@
     while (--height >= 0) {
         this->blitH(x, y++, width);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /// Masked supersampling antialiased blitter.
 class MaskSuperBlitter : public BaseSuperBlitter {
 public:
-    MaskSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
-                     const SkRegion& clip);
+    MaskSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir, const SkRegion&, bool isInverse);
     virtual ~MaskSuperBlitter() {
         fRealBlitter->blitMask(fMask, fClipRect);
     }
 
     virtual void blitH(int x, int y, int width) SK_OVERRIDE;
 
     static bool CanHandleRect(const SkIRect& bounds) {
 #ifdef FORCE_RLE
         return false;
 #endif
@@ skipping 17 matching lines @@
 #endif
     };
 
     SkMask      fMask;
     SkIRect     fClipRect;
     // we add 1 because add_aa_span can write (unchanged) 1 extra byte at the end, rather than
     // perform a test to see if stopAlpha != 0
     uint32_t    fStorage[(kMAX_STORAGE >> 2) + 1];
 };
 
-MaskSuperBlitter::MaskSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
-                                   const SkRegion& clip)
-        : BaseSuperBlitter(realBlitter, ir, clip) {
+MaskSuperBlitter::MaskSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir, const SkRegion& clip,
+                                   bool isInverse)
+    : BaseSuperBlitter(realBlitter, ir, clip, isInverse)
+{
     SkASSERT(CanHandleRect(ir));
+    SkASSERT(!isInverse);
 
     fMask.fImage    = (uint8_t*)fStorage;
     fMask.fBounds   = ir;
     fMask.fRowBytes = ir.width();
     fMask.fFormat   = SkMask::kA8_Format;
 
     fClipRect = ir;
     fClipRect.intersect(clip.getBounds());
 
     // For valgrind, write 1 extra byte at the end so we don't read
@@ skipping 167 matching lines @@
     }
     return false;
 }
 
 void SkScan::AntiFillPath(const SkPath& path, const SkRegion& origClip,
                           SkBlitter* blitter, bool forceRLE) {
     if (origClip.isEmpty()) {
         return;
     }
 
+    const bool isInverse = path.isInverseFillType();
     SkIRect ir;
 
     if (!safeRoundOut(path.getBounds(), &ir, SK_MaxS32 >> SHIFT)) {
 #if 0
         const SkRect& r = path.getBounds();
         SkDebugf("--- bounds can't fit in SkIRect\n", r.fLeft, r.fTop, r.fRight, r.fBottom);
 #endif
         return;
     }
     if (ir.isEmpty()) {
-        if (path.isInverseFillType()) {
+        if (isInverse) {
             blitter->blitRegion(origClip);
         }
         return;
     }
 
     // If the intersection of the path bounds and the clip bounds
     // will overflow 32767 when << by SHIFT, we can't supersample,
     // so draw without antialiasing.
     SkIRect clippedIR;
-    if (path.isInverseFillType()) {
+    if (isInverse) {
        // If the path is an inverse fill, it's going to fill the entire
        // clip, and we care whether the entire clip exceeds our limits.
        clippedIR = origClip.getBounds();
     } else {
        if (!clippedIR.intersect(ir, origClip.getBounds())) {
            return;
        }
     }
     if (rect_overflows_short_shift(clippedIR, SHIFT)) {
         SkScan::FillPath(path, origClip, blitter);
@@ skipping 16 matching lines @@
             tmpClipStorage.op(origClip, limit, SkRegion::kIntersect_Op);
             clipRgn = &tmpClipStorage;
         }
     }
     // for here down, use clipRgn, not origClip
 
     SkScanClipper   clipper(blitter, clipRgn, ir);
     const SkIRect*  clipRect = clipper.getClipRect();
 
     if (clipper.getBlitter() == NULL) { // clipped out
-        if (path.isInverseFillType()) {
+        if (isInverse) {
             blitter->blitRegion(*clipRgn);
         }
         return;
     }
 
     // now use the (possibly wrapped) blitter
     blitter = clipper.getBlitter();
 
-    if (path.isInverseFillType()) {
+    if (isInverse) {
         sk_blit_above(blitter, ir, *clipRgn);
     }
 
     SkIRect superRect, *superClipRect = NULL;
 
     if (clipRect) {
         superRect.set(  clipRect->fLeft << SHIFT, clipRect->fTop << SHIFT,
                         clipRect->fRight << SHIFT, clipRect->fBottom << SHIFT);
         superClipRect = &superRect;
     }
 
     SkASSERT(SkIntToScalar(ir.fTop) <= path.getBounds().fTop);
 
     // MaskSuperBlitter can't handle drawing outside of ir, so we can't use it
     // if we're an inverse filltype
-    if (!path.isInverseFillType() && MaskSuperBlitter::CanHandleRect(ir) && !forceRLE) {
-        MaskSuperBlitter    superBlit(blitter, ir, *clipRgn);
+    if (!isInverse && MaskSuperBlitter::CanHandleRect(ir) && !forceRLE) {
+        MaskSuperBlitter    superBlit(blitter, ir, *clipRgn, isInverse);
         SkASSERT(SkIntToScalar(ir.fTop) <= path.getBounds().fTop);
         sk_fill_path(path, superClipRect, &superBlit, ir.fTop, ir.fBottom, SHIFT, *clipRgn);
     } else {
-        SuperBlitter    superBlit(blitter, ir, *clipRgn);
+        SuperBlitter    superBlit(blitter, ir, *clipRgn, isInverse);
         sk_fill_path(path, superClipRect, &superBlit, ir.fTop, ir.fBottom, SHIFT, *clipRgn);
     }
 
-    if (path.isInverseFillType()) {
+    if (isInverse) {
         sk_blit_below(blitter, ir, *clipRgn);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkRasterClip.h"
 
 void SkScan::FillPath(const SkPath& path, const SkRasterClip& clip,
                           SkBlitter* blitter) {
@@ skipping 23 matching lines @@
         AntiFillPath(path, clip.bwRgn(), blitter);
     } else {
         SkRegion        tmp;
         SkAAClipBlitter aaBlitter;
 
         tmp.setRect(clip.getBounds());
         aaBlitter.init(blitter, &clip.aaRgn());
         SkScan::AntiFillPath(path, tmp, &aaBlitter, true);
     }
 }