Use Analytic AA in SkAAClip

src/core/SkAAClip.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 "SkAAClip.h"
 #include "SkAtomics.h"
 #include "SkBlitter.h"
@@ skipping 1019 matching lines @@
         // so we ensure our row goes all the way to our right
         this->flushRowH(fCurrRow);
 
         y -= fBounds.fTop;
         SkASSERT(y == fCurrRow->fY);
         fCurrRow->fY = y + height - 1;
     }
 
     void addAntiRectRun(int x, int y, int width, int height,
                         SkAlpha leftAlpha, SkAlpha rightAlpha) {
-        SkASSERT(fBounds.contains(x + width - 1 +
-                 (leftAlpha > 0 ? 1 : 0) + (rightAlpha > 0 ? 1 : 0),
+        // According to SkBlitter.cpp, no matter whether leftAlpha is 0 or positive,
+        // we should always consider [x, x+1] as the left-most column and [x+1, x+1+width]
+        // as the rect with full alpha.
+        SkASSERT(fBounds.contains(x + width + (rightAlpha > 0 ? 1 : 0),
                  y + height - 1));
         SkASSERT(width >= 0);
 
         // Conceptually we're always adding 3 runs, but we should
         // merge or omit them if possible.
         if (leftAlpha == 0xFF) {
             width++;
         } else if (leftAlpha > 0) {
           this->addRun(x++, y, leftAlpha, 1);
+        } else {
+          // leftAlpha is 0, ignore the left column
+          x++;
         }
         if (rightAlpha == 0xFF) {
             width++;
         }
         if (width > 0) {
             this->addRun(x, y, 0xFF, width);
         }
         if (rightAlpha > 0 && rightAlpha < 255) {
             this->addRun(x + width, y, rightAlpha, 1);
         }
@@ skipping 206 matching lines @@
     }
 
     /**
        Must evaluate clips in scan-line order, so don't want to allow blitV(),
        but an AAClip can be clipped down to a single pixel wide, so we
        must support it (given AntiRect semantics: minimum width is 2).
        Instead we'll rely on the runtime asserts to guarantee Y monotonicity;
        any failure cases that misses may have minor artifacts.
     */
     void blitV(int x, int y, int height, SkAlpha alpha) override {
-        this->recordMinY(y);
-        fBuilder->addColumn(x, y, alpha, height);
-        fLastY = y + height - 1;
+        if (height == 1) {
+            // We're still in scan-line order if height is 1
+            // This is useful for Analytic AA
+            const SkAlpha alphas[2] = {alpha, 0};
+            const int16_t runs[2] = {1, 0};
+            this->blitAntiH(x, y, alphas, runs);
+        } else {
+            this->recordMinY(y);
+            fBuilder->addColumn(x, y, alpha, height);
+            fLastY = y + height - 1;
+        }
     }
 
     void blitRect(int x, int y, int width, int height) override {
         this->recordMinY(y);
         this->checkForYGap(y);
         fBuilder->addRectRun(x, y, width, height);
         fLastY = y + height - 1;
     }
 
     virtual void blitAntiRect(int x, int y, int width, int height,
@@ skipping 101 matching lines @@
     } else {
         if (ibounds.isEmpty() || !ibounds.intersect(clip->getBounds())) {
             return this->setEmpty();
         }
     }
 
     Builder        builder(ibounds);
     BuilderBlitter blitter(&builder);
 
     if (doAA) {
-        SkScan::AntiFillPath(path, *clip, &blitter, true);
+        if (gSkUseAnalyticAA.load()) {
+            SkScan::AAAFillPath(path, *clip, &blitter, true);
+        } else {
+            SkScan::AntiFillPath(path, *clip, &blitter, true);
+        }
     } else {
         SkScan::FillPath(path, *clip, &blitter);
     }
 
     blitter.finish();
     return builder.finish(this);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 799 matching lines @@
             rowMask.fBounds.fBottom = y + 1;
             fBlitter->blitMask(rowMask, rowMask.fBounds);
             src = (const void*)((const char*)src + srcRB);
         } while (++y < localStopY);
     } while (y < stopY);
 }
 
 const SkPixmap* SkAAClipBlitter::justAnOpaqueColor(uint32_t* value) {
     return nullptr;
 }