Use Analytic AA in SkAAClip

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 255 matching lines @@
     ~RunBasedAdditiveBlitter();
 
     SkBlitter* getRealBlitter(bool forceRealBlitter) override;
 
     void blitAntiH(int x, int y, const SkAlpha antialias[], int len) override;
     void blitAntiH(int x, int y, const SkAlpha alpha) override;
     void blitAntiH(int x, int y, int width, const SkAlpha alpha) override;
 
     int getWidth() override;
 
+    // This should only be called when forceRLE = true which implies that SkAAClip
+    // is calling us.
+    // SkAAClip requires that we blit in scan-line order so we have to flush
+    // for each row in order. Without this, we may have the first row unflushed,
+    // then blit the 2nd and the 3rd row with full alpha (so we won't flush the first row);
+    // finally when we blit the fourth row, we trigger the first row to flush, and this
+    // would cause SkAAClip to crash.
+    inline void flush_if_y_changed(SkFixed y, SkFixed nextY) {
+        if ((y >> 16) != (nextY >> 16)) {

[caryclark, 2016/10/20 16:58:14]

maybe overly wordy, but a macro like SkFixedFloorToInt(y) instead of y >> 16
will help the reader know where the >> 16 comes from, here and below

[liyuqian, 2016/10/20 17:19:50]

Thanks, done.

+            this->flush();
+        }
+    }
+
 private:
     SkBlitter* fRealBlitter;
 
     /// Current y coordinate
     int         fCurrY;
     /// Widest row of region to be blitted
     int         fWidth;
     /// Leftmost x coordinate in any row
     int         fLeft;
     /// Initial y coordinate (top of bounds).
@@ skipping 428 matching lines @@
     // We're going to use the left line ul-ll and the rite line ur-lr
     // to exclude the area that's not covered by the path.
     // Swapping (ul, ll) or (ur, lr) won't affect that exclusion
     // so we'll do that for simplicity.
     if (ul > ll) { SkTSwap(ul, ll); }
     if (ur > lr) { SkTSwap(ur, lr); }
 
     SkFixed joinLeft = SkFixedCeilToFixed(ll);
     SkFixed joinRite = SkFixedFloorToFixed(ur);
     if (joinLeft <= joinRite) { // There's a rect from joinLeft to joinRite that we can blit
-        if (joinLeft < joinRite) {
-            blit_full_alpha(blitter, y, joinLeft >> 16, (joinRite - joinLeft) >> 16, fullAlpha,
-                            maskRow, isUsingMask);
-        }
         if (ul < joinLeft) {
             int len = SkFixedCeilToInt(joinLeft - ul);
             if (len == 1) {
                 SkAlpha alpha = trapezoidToAlpha(joinLeft - ul, joinLeft - ll);
                 blit_single_alpha(blitter, y, ul >> 16, alpha, fullAlpha, maskRow, isUsingMask);
             } else if (len == 2) {
                 SkFixed first = joinLeft - SK_Fixed1 - ul;
                 SkFixed second = ll - ul - first;
                 SkAlpha a1 = partialTriangleToAlpha(first, lDY);
                 SkAlpha a2 = fullAlpha - partialTriangleToAlpha(second, lDY);
                 blit_two_alphas(blitter, y, ul >> 16, a1, a2, fullAlpha, maskRow, isUsingMask);
             } else {
                 blit_aaa_trapezoid_row(blitter, y, ul, joinLeft, ll, joinLeft, lDY, SK_MaxS32,
                                        fullAlpha, maskRow, isUsingMask);
             }
         }
+        // SkAAClip requires that we blit from left to right.
+        // Hence we must blit [ul, joinLeft] before blitting [joinLeft, joinRite]
+        if (joinLeft < joinRite) {
+            blit_full_alpha(blitter, y, joinLeft >> 16, (joinRite - joinLeft) >> 16, fullAlpha,
+                            maskRow, isUsingMask);
+        }
         if (lr > joinRite) {
             int len = SkFixedCeilToInt(lr - joinRite);
             if (len == 1) {
                 SkAlpha alpha = trapezoidToAlpha(ur - joinRite, lr - joinRite);
                 blit_single_alpha(blitter, y, joinRite >> 16, alpha, fullAlpha, maskRow,
                                   isUsingMask);
             } else if (len == 2) {
                 SkFixed first = joinRite + SK_Fixed1 - ur;
                 SkFixed second = lr - ur - first;
                 SkAlpha a1 = fullAlpha - partialTriangleToAlpha(first, rDY);
@@ skipping 119 matching lines @@
         return false;
     }
     if (*nextCurrE < *currE) {
         SkTSwap(currE, nextCurrE);
     }
     return isSmoothEnough(leftE, currE, stop_y) && isSmoothEnough(riteE, nextCurrE, stop_y);
 }
 
 static inline void aaa_walk_convex_edges(SkAnalyticEdge* prevHead, AdditiveBlitter* blitter,
                            int start_y, int stop_y, SkFixed leftBound, SkFixed riteBound,
-                           bool isUsingMask) {
+                           bool isUsingMask, bool forceRLE) {
     validate_sort((SkAnalyticEdge*)prevHead->fNext);
 
     SkAnalyticEdge* leftE = (SkAnalyticEdge*) prevHead->fNext;
     SkAnalyticEdge* riteE = (SkAnalyticEdge*) leftE->fNext;
     SkAnalyticEdge* currE = (SkAnalyticEdge*) riteE->fNext;
 
     SkFixed y = SkTMax(leftE->fUpperY, riteE->fUpperY);
 
     #ifdef SK_DEBUG
     int frac_y_cnt = 0;
@@ skipping 60 matching lines @@
             int     fullTop     = SkFixedCeilToInt(y);
             int     fullBot     = SkFixedFloorToInt(local_bot_fixed);
             SkFixed partialTop  = SkIntToFixed(fullTop) - y;
             SkFixed partialBot  = local_bot_fixed - SkIntToFixed(fullBot);
             if (fullTop > fullBot) { // The rectangle is within one pixel height...
                 partialTop -= (SK_Fixed1 - partialBot);
                 partialBot = 0;
             }
 
             if (fullRite >= fullLeft) {
+                if (partialTop > 0) { // blit first partial row
+                    if (partialLeft > 0) {
+                        blitter->blitAntiH(fullLeft - 1, fullTop - 1,
+                                f2a(SkFixedMul_lowprec(partialTop, partialLeft)));
+                    }
+                    blitter->blitAntiH(fullLeft, fullTop - 1, fullRite - fullLeft,
+                                       f2a(partialTop));
+                    if (partialRite > 0) {
+                        blitter->blitAntiH(fullRite, fullTop - 1,
+                                f2a(SkFixedMul_lowprec(partialTop, partialRite)));
+                    }
+                    if (forceRLE) {
+                        ((RunBasedAdditiveBlitter*)blitter)->flush_if_y_changed(y, y + partialTop);
+                    }
+                }
+
                 // Blit all full-height rows from fullTop to fullBot
                 if (fullBot > fullTop) {
                     blitter->getRealBlitter()->blitAntiRect(fullLeft - 1, fullTop,
                                                             fullRite - fullLeft, fullBot - fullTop,
                                                             f2a(partialLeft), f2a(partialRite));
                 }
 
-                if (partialTop > 0) { // blit first partial row
-                    if (partialLeft > 0) {
-                        blitter->blitAntiH(fullLeft - 1, fullTop - 1,
-                                f2a(SkFixedMul_lowprec(partialTop, partialLeft)));
-                    }
-                    if (partialRite > 0) {
-                        blitter->blitAntiH(fullRite, fullTop - 1,
-                                f2a(SkFixedMul_lowprec(partialTop, partialRite)));
-                    }
-                    blitter->blitAntiH(fullLeft, fullTop - 1, fullRite - fullLeft,
-                                       f2a(partialTop));
-                }
-
                 if (partialBot > 0) { // blit last partial row
                     if (partialLeft > 0) {
                         blitter->blitAntiH(fullLeft - 1, fullBot,
                                            f2a(SkFixedMul_lowprec(partialBot, partialLeft)));
                     }
+                    blitter->blitAntiH(fullLeft, fullBot, fullRite - fullLeft, f2a(partialBot));
                     if (partialRite > 0) {
                         blitter->blitAntiH(fullRite, fullBot,
                                            f2a(SkFixedMul_lowprec(partialBot, partialRite)));
                     }
-                    blitter->blitAntiH(fullLeft, fullBot, fullRite - fullLeft, f2a(partialBot));
                 }
             } else { // left and rite are within the same pixel
                 if (partialTop > 0) {
                     blitter->getRealBlitter()->blitV(fullLeft - 1, fullTop - 1, 1,
                             f2a(SkFixedMul_lowprec(partialTop, rite - left)));
+                    if (forceRLE) {
+                        ((RunBasedAdditiveBlitter*)blitter)->flush_if_y_changed(y, y + partialTop);
+                    }
+                }
+                if (fullBot >= fullTop) {
+                    blitter->getRealBlitter()->blitV(fullLeft - 1, fullTop, fullBot - fullTop,
+                            f2a(rite - left));
                 }
                 if (partialBot > 0) {
                     blitter->getRealBlitter()->blitV(fullLeft - 1, fullBot, 1,
                             f2a(SkFixedMul_lowprec(partialBot, rite - left)));
                 }
-                if (fullBot >= fullTop) {
-                    blitter->getRealBlitter()->blitV(fullLeft - 1, fullTop, fullBot - fullTop,
-                            f2a(rite - left));
-                }
             }
 
             y = local_bot_fixed;
         } else {
             // The following constant are used to snap X
             // We snap X mainly for speedup (no tiny triangle) and
             // avoiding edge cases caused by precision errors
             const SkFixed kSnapDigit = SK_Fixed1 >> 4;
             const SkFixed kSnapHalf = kSnapDigit >> 1;
             const SkFixed kSnapMask = (-1 ^ (kSnapDigit - 1));
@@ skipping 23 matching lines @@
             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);
                     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;
                     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.
-            SkFixed nextLeft = SkTMax(left + SkFixedMul_lowprec(dLeft, dY), leftBound);
-            SkFixed nextRite = SkTMin(rite + SkFixedMul_lowprec(dRite, dY), riteBound);
+            // 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);
             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;
         }
 
         leftE->fX = left;
         riteE->fX = rite;
         leftE->fY = riteE->fY = y;
     }
 
 END_WALK:
     ;
     #ifdef SK_DEBUG
     SkDebugf("frac_y_cnt = %d, total_y_cnt = %d\n", frac_y_cnt, total_y_cnt);
     #endif
 }
 
 void SkScan::aaa_fill_path(const SkPath& path, const SkIRect* clipRect, AdditiveBlitter* blitter,
-                   int start_y, int stop_y, const SkRegion& clipRgn, bool isUsingMask) {
+                   int start_y, int stop_y, const SkRegion& clipRgn, bool isUsingMask,
+                   bool forceRLE) { // forceRLE implies that SkAAClip is calling us
     SkASSERT(blitter);
 
     if (path.isInverseFillType() || !path.isConvex()) {
         // fall back to supersampling AA
         SkScan::AntiFillPath(path, clipRgn, blitter->getRealBlitter(true), false);
         return;
     }
 
     SkEdgeBuilder   builder;
 
@@ skipping 55 matching lines @@
     if (clipRect && start_y < clipRect->fTop) {
         start_y = clipRect->fTop;
     }
     if (clipRect && stop_y > clipRect->fBottom) {
         stop_y = clipRect->fBottom;
     }
 
     if (!path.isInverseFillType() && path.isConvex()) {
         SkASSERT(count >= 2);   // convex walker does not handle missing right edges
         aaa_walk_convex_edges(&headEdge, blitter, start_y, stop_y,
-                              rect.fLeft << 16, rect.fRight << 16, isUsingMask);
+                              rect.fLeft << 16, rect.fRight << 16, isUsingMask,
+                              forceRLE);
     } else {
         SkFAIL("Concave AAA is not yet implemented!");
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkScan::AAAFillPath(const SkPath& path, const SkRegion& origClip, SkBlitter* blitter) {
+void SkScan::AAAFillPath(const SkPath& path, const SkRegion& origClip, SkBlitter* blitter,
+                         bool forceRLE) {
     if (origClip.isEmpty()) {
         return;
     }
 
     const bool isInverse = path.isInverseFillType();
     SkIRect ir;
     path.getBounds().roundOut(&ir);
     if (ir.isEmpty()) {
         if (isInverse) {
             blitter->blitRegion(origClip);
@@ skipping 45 matching lines @@
     blitter = clipper.getBlitter();
 
     if (isInverse) {
         // Currently, we use the old path to render the inverse path,
         // so we don't need this.
         // sk_blit_above(blitter, ir, *clipRgn);
     }
 
     SkASSERT(SkIntToScalar(ir.fTop) <= path.getBounds().fTop);
 
-    if (MaskAdditiveBlitter::canHandleRect(ir) && !isInverse) {
+    if (MaskAdditiveBlitter::canHandleRect(ir) && !isInverse && !forceRLE) {
         MaskAdditiveBlitter additiveBlitter(blitter, ir, *clipRgn, isInverse);
-        aaa_fill_path(path, clipRect, &additiveBlitter, ir.fTop, ir.fBottom, *clipRgn, true);
+        aaa_fill_path(path, clipRect, &additiveBlitter, ir.fTop, ir.fBottom, *clipRgn, true,
+                      forceRLE);
     } else {
         RunBasedAdditiveBlitter additiveBlitter(blitter, ir, *clipRgn, isInverse);
-        aaa_fill_path(path, clipRect, &additiveBlitter, ir.fTop, ir.fBottom, *clipRgn, false);
+        aaa_fill_path(path, clipRect, &additiveBlitter, ir.fTop, ir.fBottom, *clipRgn, false,
+                      forceRLE);
     }
 
     if (isInverse) {
         // Currently, we use the old path to render the inverse path,
         // so we don't need this.
         // sk_blit_below(blitter, ir, *clipRgn);
     }
 }
 
 // This almost copies SkScan::AntiFillPath
 void SkScan::AAAFillPath(const SkPath& path, const SkRasterClip& clip, SkBlitter* blitter) {
     if (clip.isEmpty()) {
         return;
     }
 
     if (clip.isBW()) {
         AAAFillPath(path, clip.bwRgn(), blitter);
     } else {
         SkRegion        tmp;
         SkAAClipBlitter aaBlitter;
 
         tmp.setRect(clip.getBounds());
         aaBlitter.init(blitter, &clip.aaRgn());
         AAAFillPath(path, tmp, &aaBlitter);
     }
 }