Tighten SkAAClip Bounds by Path Bounds

src/core/SkScan_AAAPath.cpp

 /*
  * Copyright 2016 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 "SkAntiRun.h"
 #include "SkBlitter.h"
 #include "SkEdge.h"
@@ skipping 172 matching lines @@
     SkBlitter*  fRealBlitter;
     SkMask      fMask;
     SkIRect     fClipRect;
     // we add 2 because we can write 1 extra byte at either end due to precision error
     uint32_t    fStorage[(kMAX_STORAGE >> 2) + 2];
 
     uint8_t*    fRow;
     int         fY;
 };
 
-MaskAdditiveBlitter::MaskAdditiveBlitter(SkBlitter* realBlitter, const SkIRect& ir, const SkRegion& clip,
-                                         bool isInverse) {
+MaskAdditiveBlitter::MaskAdditiveBlitter(
+        SkBlitter* realBlitter, const SkIRect& ir, const SkRegion& clip, bool isInverse) {
     SkASSERT(canHandleRect(ir));
     SkASSERT(!isInverse);
 
     fRealBlitter = realBlitter;
 
     fMask.fImage    = (uint8_t*)fStorage + 1; // There's 1 extra byte at either end of fStorage
     fMask.fBounds   = ir;
     fMask.fRowBytes = ir.width();
     fMask.fFormat   = SkMask::kA8_Format;
 
@@ skipping 155 matching lines @@
     }
 
     inline void checkY(int y) {
         if (y != fCurrY) {
             this->flush();
             fCurrY = y;
         }
     }
 };
 
-RunBasedAdditiveBlitter::RunBasedAdditiveBlitter(SkBlitter* realBlitter, const SkIRect& ir, const SkRegion& clip,
-                                 bool isInverse) {
+RunBasedAdditiveBlitter::RunBasedAdditiveBlitter(
+        SkBlitter* realBlitter, const SkIRect& ir, const SkRegion& clip, bool isInverse) {
     fRealBlitter = realBlitter;
 
     SkIRect sectBounds;
     if (isInverse) {
         // We use the clip bounds instead of the ir, since we may be asked to
         //draw outside of the rect when we're a inverse filltype
         sectBounds = clip.getBounds();
     } else {
         if (!sectBounds.intersect(ir, clip.getBounds())) {
             sectBounds.setEmpty();
@@ skipping 144 matching lines @@
         SkFixed alpha16 = firstH + (dY >> 1); // rectangle plus triangle
         for (int i = 1; i < R - 1; i++) {
             alphas[i] = alpha16 >> 8;
             alpha16 += dY;
         }
         alphas[R - 1] = fullAlpha - partialTriangleToAlpha(last, dY);
     }
 }
 
 // Here we always send in l < SK_Fixed1, and the first alpha we want to compute is alphas[0]
-static inline void computeAlphaBelowLine(SkAlpha* alphas, SkFixed l, SkFixed r, SkFixed dY, SkAlpha fullAlpha) {
+static inline void computeAlphaBelowLine(
+        SkAlpha* alphas, SkFixed l, SkFixed r, SkFixed dY, SkAlpha fullAlpha) {
     SkASSERT(l <= r);
     SkASSERT(l >> 16 == 0);
     int R = SkFixedCeilToInt(r);
     if (R == 0) {
         return;
     } else if (R == 1) {
         alphas[0] = getPartialAlpha(trapezoidToAlpha(l, r), fullAlpha);
     } else {
         SkFixed first = SK_Fixed1 - l; // horizontal edge length of the left-most triangle
         SkFixed last = r - ((R - 1) << 16); // horizontal edge length of the right-most triangle
@@ skipping 411 matching lines @@
         SkFixed local_bot_fixed = SkMin32(leftE->fLowerY, riteE->fLowerY);
         // Skip the fractional y if edges are changing smoothly.
         // If forceRLE is true, we won't skip the fractional y because it
         // implies that SkAAClip is calling us and there are strict
         // assertions inside SkAAClip.
         if (isSmoothEnough(leftE, riteE, currE, stop_y) && !forceRLE) {
             local_bot_fixed = SkFixedCeilToFixed(local_bot_fixed);
         }
         local_bot_fixed = SkMin32(local_bot_fixed, SkIntToFixed(stop_y));
 
-        SkFixed left = leftE->fX;
+        SkFixed left = SkTMax(leftBound, leftE->fX);
         SkFixed dLeft = leftE->fDX;
-        SkFixed rite = riteE->fX;
+        SkFixed rite = SkTMin(riteBound, riteE->fX);
         SkFixed dRite = riteE->fDX;
         if (0 == (dLeft | dRite)) {
             int     fullLeft    = SkFixedCeilToInt(left);
             int     fullRite    = SkFixedFloorToInt(rite);
             SkFixed partialLeft = SkIntToFixed(fullLeft) - left;
             SkFixed partialRite = rite - SkIntToFixed(fullRite);
             int     fullTop     = SkFixedCeilToInt(y);
             int     fullBot     = SkFixedFloorToInt(local_bot_fixed);
             SkFixed partialTop  = SkIntToFixed(fullTop) - y;
             SkFixed partialBot  = local_bot_fixed - SkIntToFixed(fullBot);
@@ skipping 89 matching lines @@
             // and full-row trapezoid_row together, we use the following 3-stage flow to
             // handle partial-row blit and full-row blit separately. It will save us much time
             // on changing y, left, and rite.
             if (count > 1) {
                 if ((int)(y & 0xFFFF0000) != y) { // There's a partial-row on the top
                     count--;
                     SkFixed nextY = SkFixedCeilToFixed(y + 1);
                     SkFixed dY = nextY - y;
                     SkFixed nextLeft = left + SkFixedMul_lowprec(dLeft, dY);
                     SkFixed nextRite = rite + SkFixedMul_lowprec(dRite, dY);
+                    SkASSERT((left & kSnapMask) >= leftBound && (rite & kSnapMask) <= riteBound &&
+                            (nextLeft & kSnapMask) >= leftBound &&
+                            (nextRite & kSnapMask) <= riteBound);
                     blit_trapezoid_row(blitter, y >> 16, left & kSnapMask, rite & kSnapMask,
                             nextLeft & kSnapMask, nextRite & kSnapMask, leftE->fDY, riteE->fDY,
                             getPartialAlpha(0xFF, dY), maskRow, isUsingMask);
                     if (forceRLE) {
                         ((RunBasedAdditiveBlitter*)blitter)->flush_if_y_changed(y, nextY);
                     }
                     left = nextLeft; rite = nextRite; y = nextY;
                 }
 
                 while (count > 1) { // Full rows in the middle
                     count--;
                     if (isUsingMask) {
                         maskRow = static_cast<MaskAdditiveBlitter*>(blitter)->getRow(y >> 16);
                     }
                     SkFixed nextY = y + SK_Fixed1, nextLeft = left + dLeft, nextRite = rite + dRite;
+                    SkASSERT((left & kSnapMask) >= leftBound && (rite & kSnapMask) <= riteBound &&
+                            (nextLeft & kSnapMask) >= leftBound &&
+                            (nextRite & kSnapMask) <= riteBound);
                     blit_trapezoid_row(blitter, y >> 16, left & kSnapMask, rite & kSnapMask,
                             nextLeft & kSnapMask, nextRite & kSnapMask,
                             leftE->fDY, riteE->fDY, 0xFF, maskRow, isUsingMask);
                     if (forceRLE) {
                         ((RunBasedAdditiveBlitter*)blitter)->flush_if_y_changed(y, nextY);
                     }
                     left = nextLeft; rite = nextRite; y = nextY;
                 }
             }
 
             if (isUsingMask) {
                 maskRow = static_cast<MaskAdditiveBlitter*>(blitter)->getRow(y >> 16);
             }
 
             SkFixed dY = local_bot_fixed - y; // partial-row on the bottom
             SkASSERT(dY <= SK_Fixed1);
             // Smooth jumping to integer y may make the last nextLeft/nextRite out of bound.
             // Take them back into the bound here.
             // Note that we substract kSnapHalf later so we have to add them to leftBound/riteBound
             SkFixed nextLeft = SkTMax(left + SkFixedMul_lowprec(dLeft, dY), leftBound + kSnapHalf);
             SkFixed nextRite = SkTMin(rite + SkFixedMul_lowprec(dRite, dY), riteBound + kSnapHalf);
+            SkASSERT((left & kSnapMask) >= leftBound && (rite & kSnapMask) <= riteBound &&
+                    (nextLeft & kSnapMask) >= leftBound && (nextRite & kSnapMask) <= riteBound);
             blit_trapezoid_row(blitter, y >> 16, left & kSnapMask, rite & kSnapMask,
                     nextLeft & kSnapMask, nextRite & kSnapMask, leftE->fDY, riteE->fDY,
                     getPartialAlpha(0xFF, dY), maskRow, isUsingMask);
             if (forceRLE) {
                 ((RunBasedAdditiveBlitter*)blitter)->flush_if_y_changed(y, local_bot_fixed);
             }
             left = nextLeft; rite = nextRite; y = local_bot_fixed;
             left -= kSnapHalf; rite -= kSnapHalf;
         }
 
@@ skipping 222 matching lines @@
         AAAFillPath(path, clip.bwRgn(), blitter);
     } else {
         SkRegion        tmp;
         SkAAClipBlitter aaBlitter;
 
         tmp.setRect(clip.getBounds());
         aaBlitter.init(blitter, &clip.aaRgn());
         AAAFillPath(path, tmp, &aaBlitter, true);
     }
 }