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 250 matching lines @@
     const void* row(int y) const { return fSrc + y * fWidth[0]; }
 
 private:
     const Element* const                 fSrc;
     const Sk4i                           fWidth;
     PixelGetter<colorType, colorProfile> fGetter;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // GeneralSampler handles all the different sampling scenarios. It makes runtime decisions to
-// choose the fastest stratagy given a particular job. It ultimately uses PixelGetters to access
+// choose the fastest strategy given a particular job. It ultimately uses PixelGetters to access
 // the pixels.
 template<SkColorType colorType, SkColorProfileType colorProfile, typename Next>
 class GeneralSampler {
 public:
     template<typename... Args>
     GeneralSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next, Args&& ... args)
         : fNext{next}, fStrategy{std::forward<Args>(args)...} { }
 
     GeneralSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next,
                    const GeneralSampler& sampler)
@@ skipping 23 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) {
+    Sk4f bilerpNonEdgePixel(SkScalar x, SkScalar y) {
         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};
+        // bilerp4() expects xs, ys are the top-lefts of the 2x2 kernel.
+        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]);
+            return this->bilerpNonEdgePixel(xs[index], ys[index]);
         };
 
         if (n >= 1) fNext->blendPixel(bilerpPixel(0));
         if (n >= 2) fNext->blendPixel(bilerpPixel(1));
         if (n >= 3) fNext->blendPixel(bilerpPixel(2));
     }
 
     void VECTORCALL bilerpList4(Sk4s xs, Sk4s ys) {
         auto bilerpPixel = [&](int index) {
-            return this->bilerNonEdgePixel(xs[index], ys[index]);
+            return this->bilerpNonEdgePixel(xs[index], ys[index]);
         };
         fNext->blend4Pixels(bilerpPixel(0), bilerpPixel(1), bilerpPixel(2), bilerpPixel(3));
     }
 
     void VECTORCALL bilerpEdge(Sk4s sampleXs, Sk4s sampleYs) {
         Sk4f px00, px10, px01, px11;
         Sk4f xs = Sk4f{sampleXs[0]};
         Sk4f ys = Sk4f{sampleYs[0]};
         fStrategy.get4Pixels(sampleXs, sampleYs, &px00, &px10, &px01, &px11);
         Sk4f pixel = bilerp4(xs, ys, px00, px10, px01, px11);
@@ skipping 158 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