handle halfway case in scan converter

src/core/SkScan_Path.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"
 #include "SkBlitter.h"
 #include "SkEdge.h"
@@ skipping 541 matching lines @@
 
     SkIRect limitR;
     limitR.set(-limit, -limit, limit, limit);
     if (limitR.contains(orig.getBounds())) {
         return false;
     }
     reduced->op(orig, limitR, SkRegion::kIntersect_Op);
     return true;
 }
 
+/**
+  * Variant of SkScalarRoundToInt, identical to SkDScalarRoundToInt except when the input fraction
+  * is 0.5. In this case only, round the value down. This is used to round the top and left
+  * of a rectangle, and corresponds to the way the scan converter treats the top and left edges.
+  */
+static inline int round_down_to_int(SkScalar x) {
+    double xx = x;
+    xx += 0.5;
+    double floorXX = floor(xx);
+    return (int)floorXX - (xx == floorXX);
+}
+
+/**
+  *  Variant of SkRect::round() that explicitly performs the rounding step (i.e. floor(x + 0.5))
+  *  using double instead of SkScalar (float). It does this by calling SkDScalarRoundToInt(),
+  *  which may be slower than calling SkScalarRountToInt(), but gives slightly more accurate
+  *  results.
+  *
+  *  e.g.
+  *      SkScalar x = 0.49999997f;

[reed1, 2016/01/04 19:43:39]

I think the comment block needs to be expanded, now that we're treating top/left
differently from bottom/right

[caryclark, 2016/01/04 20:58:42]

Done.

+  *      int ix = SkScalarRoundToInt(x);
+  *      SkASSERT(0 == ix);  // <--- fails
+  *      ix = SkDScalarRoundToInt(x);
+  *      SkASSERT(0 == ix);  // <--- succeeds
+  */
+static void round_out(const SkRect& src, SkIRect* dst) {

[reed1, 2016/01/04 19:43:39]

SkRect uses "out" to mean we floor/ceiling the values. Perhaps we need a name
more specific... round_asymmetric_to_int?

[caryclark, 2016/01/04 20:58:42]

Done.

+    SkASSERT(dst);
+    dst->set(round_down_to_int(src.fLeft), round_down_to_int(src.fTop),
+             SkDScalarRoundToInt(src.fRight), SkDScalarRoundToInt(src.fBottom));
+}
+
 void SkScan::FillPath(const SkPath& path, const SkRegion& origClip,
                       SkBlitter* blitter) {
     if (origClip.isEmpty()) {
         return;
     }
 
     // Our edges are fixed-point, and don't like the bounds of the clip to
     // exceed that. Here we trim the clip just so we don't overflow later on
     const SkRegion* clipPtr = &origClip;
     SkRegion finiteClip;
     if (clip_to_limit(origClip, &finiteClip)) {
         if (finiteClip.isEmpty()) {
             return;
         }
         clipPtr = &finiteClip;
     }
         // don't reference "origClip" any more, just use clipPtr
 
     SkIRect ir;
     // We deliberately call dround() instead of round(), since we can't afford to generate a
     // bounds that is tighter than the corresponding SkEdges. The edge code basically converts
     // the floats to fixed, and then "rounds". If we called round() instead of dround() here,
     // we could generate the wrong ir for values like 0.4999997.
-    path.getBounds().dround(&ir);
+    round_out(path.getBounds(), &ir);
     if (ir.isEmpty()) {
         if (path.isInverseFillType()) {
             blitter->blitRegion(*clipPtr);
         }
         return;
     }
 
     SkScanClipper clipper(blitter, clipPtr, ir, path.isInverseFillType());
 
     blitter = clipper.getBlitter();
@@ skipping 104 matching lines @@
         clipRgn = &wrap.getRgn();
         blitter = wrap.getBlitter();
     }
 
     SkScanClipper clipper(blitter, clipRgn, ir);
     blitter = clipper.getBlitter();
     if (blitter) {
         sk_fill_triangle(pts, clipper.getClipRect(), blitter, ir);
     }
 }