Relax the extra span's alpha

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 1313 matching lines @@
                            const int16_t runs[]) override {
         this->recordMinY(y);
         this->checkForYGap(y);
         for (;;) {
             int count = *runs;
             if (count <= 0) {
                 return;
             }
 
             // The supersampler's buffer can be the width of the device, so
-            // we may have to trim the run to our bounds. If so, we assert that
-            // the extra spans are always alpha==0
+            // we may have to trim the run to our bounds. Previously, we assert that
+            // the extra spans are always alpha==0.
+            // However, the analytic AA is too sensitive to precision errors
+            // so it may have extra spans with very tiny alpha because after several
+            // arithmatic operations, the edge may bleed the path boundary a little bit.
+            // Therefore, instead of always asserting alpha==0, we assert alpha < 0x10.

[caryclark, 2016/11/07 16:50:51]

The assert below disagrees with the comment; it asserts that alpha <= 0x10

I understand that it is OK if alpha > 0, but does it get to be as large as 0x0F
or 0x10 in the case this is trying to avoid? Or is it only 0x01 or 0x02?

[liyuqian, 2016/11/08 16:33:47]

Is SkASSERT(0x10 > *alpha) equivalent to SkASSERT(*alpha < 0x10)?

It's hard to tell how small the alpha is since this only happens in mac trybot
and I couldn't reproduce it on my Goobuntu. The reason that I chose 0x10 is
because that supersampling could only produce alpha 0x10, 0x20, ... so the
threshold of 0x10 should have a quality no worse than that.

Theoretically, since SkFixed has a precision of 1/65536, we could have an
accumulative error up to 1000/65536 for 1000x1000 resolution, which is about
0x04. (The larger the resolution is, the larger this error becomes.)

And as discussed in
https://docs.google.com/a/google.com/document/d/1gudGmF9HUSzq12YNUibaYuCcjvtd...
, we don't have to worry about this error in supersampling algorithm unless we
have 8k resolution screen :)

             int localX = x;
             int localCount = count;
             if (x < fLeft) {
-                SkASSERT(0 == *alpha);
+                SkASSERT(0x10 > *alpha);
                 int gap = fLeft - x;
                 SkASSERT(gap <= count);
                 localX += gap;
                 localCount -= gap;
             }
             int right = x + count;
             if (right > fRight) {
-                SkASSERT(0 == *alpha);
+                SkASSERT(0x10 > *alpha);
                 localCount -= right - fRight;
                 SkASSERT(localCount >= 0);
             }
 
             if (localCount) {
                 fBuilder->addRun(localX, y, *alpha, localCount);
             }
             // Next run
             runs += count;
             alpha += count;
@@ skipping 870 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;
 }