Use faster case for on tile sampling, and a little clean up

src/core/SkLinearBitmapPipeline_sample.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkLinearBitmapPipeline_sampler_DEFINED
 #define SkLinearBitmapPipeline_sampler_DEFINED
 
@@ skipping 294 matching lines @@
         SkScalar absLength = SkScalarAbs(length);
         if (absLength < (count - 1)) {
             this->nearestSpanSlowRate(span);
         } else if (absLength == (count - 1)) {
             this->nearestSpanUnitRate(span);
         } else {
             this->nearestSpanFastRate(span);
         }
     }
 
     Sk4f bilerNonEdgePixel(SkScalar x, SkScalar y) {

[mtklein, 2016/06/08 20:58:49]

you can't spell

[herb_g, 2016/06/08 21:05:48]

Fxied

         Sk4f px00, px10, px01, px11;
-        Sk4f xs = Sk4f{x};
-        Sk4f ys = Sk4f{y};
-        Sk4f sampleXs = xs + Sk4f{-0.5f, 0.5f, -0.5f, 0.5f};
-        Sk4f sampleYs = ys + Sk4f{-0.5f, -0.5f, 0.5f, 0.5f};
+        // Offset for filtering is expected in the top left of the kernel.

[mtklein, 2016/06/08 20:58:49]

// bilerp4() expects xs,ys are the top-lefts of the 2x2 kernel.

?

[herb_g, 2016/06/08 21:05:48]

Done.

+        Sk4f xs = Sk4f{x} - 0.5f;
+        Sk4f ys = Sk4f{y} - 0.5f;
+        Sk4f sampleXs = xs + Sk4f{0.0f, 1.0f, 0.0f, 1.0f};
+        Sk4f sampleYs = ys + Sk4f{0.0f, 0.0f, 1.0f, 1.0f};
         fStrategy.get4Pixels(sampleXs, sampleYs, &px00, &px10, &px01, &px11);
         return bilerp4(xs, ys, px00, px10, px01, px11);
     }
 
     void VECTORCALL bilerpListFew(int n, Sk4s xs, Sk4s ys) {
         SkASSERT(0 < n && n < 4);
         auto bilerpPixel = [&](int index) {
             return this->bilerNonEdgePixel(xs[index], ys[index]);
         };
 
@@ skipping 176 matching lines @@
         }
     }
 
     // When moving through source space more slowly than dst space (zoomed in),
     // we'll be sampling from the same source pixel more than once.
     void bilerpSpanSlowRate(Span span, SkScalar ry1) {
         SkPoint start;
         SkScalar length;
         int count;
         std::tie(start, length, count) = span;
-        SkFixed fx = SkScalarToFixed(X(start)
-                                         -0.5f);
+        SkFixed fx = SkScalarToFixed(X(start)-0.5f);
 
         SkFixed fdx = SkScalarToFixed(length / (count - 1));
-        //start = start + SkPoint{-0.5f, -0.5f};
 
         Sk4f xAdjust;
         if (fdx >= 0) {
             xAdjust = Sk4f{-1.0f};
         } else {
             xAdjust = Sk4f{1.0f};
         }
         int ix = SkFixedFloorToInt(fx);
         int ioldx = ix;
         Sk4f x{SkFixedToScalar(fx) - ix};
@@ skipping 212 matching lines @@
 
     // We're moving through source space faster than dst (zoomed out),
     // so we'll never reuse a source pixel or be able to do contiguous loads.
     void bilerpSpanFastRate(Span span, SkScalar y1) {
         SkPoint start;
         SkScalar length;
         int count;
         std::tie(start, length, count) = span;
         SkScalar x = X(start);
         SkScalar y = Y(start);
-        if (false && y == y1) {
+        // In this sampler, it is assumed that if span.StartY() and y1 are the same then both
+        // y-lines are on the same tile.
+        if (y == y1) {
+            // Both y-lines are on the same tile.
             struct BilerpWrapper {
                 void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) {
                     fSampler.bilerpListFew(n, xs, ys);
                 }
 
                 void VECTORCALL pointList4(Sk4s xs, Sk4s ys) {
                     fSampler.bilerpList4(xs, ys);
                 }
 
                 GeneralSampler& fSampler;
             };
             BilerpWrapper wrapper{*this};
             span_fallback(span, &wrapper);
         } else {
+            // The y-lines are on different tiles.
             SkScalar dx = length / (count - 1);
             Sk4f ys = {y - 0.5f, y - 0.5f, y1 + 0.5f, y1 + 0.5f};
             while (count > 0) {
                 Sk4f xs = Sk4f{-0.5f, 0.5f, -0.5f, 0.5f} + Sk4f{x};
                 this->bilerpEdge(xs, ys);
                 x += dx;
                 count -= 1;
             }
         }
     }
 
     Next* const                            fNext;
     PixelAccessor<colorType, colorProfile> fStrategy;
 };
 
 }  // namespace
 
 #endif  // SkLinearBitmapPipeline_sampler_DEFINED