tile spans

src/core/SkLinearBitmapPipeline.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLinearBitmapPipeline.h"
 #include "SkPM4f.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include "SkColor.h"
 #include "SkSize.h"
 
 // Tweak ABI of functions that pass Sk4f by value to pass them via registers.
-#if defined(_MSC_VER) && SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
+  #if defined(_MSC_VER) && SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
      #define VECTORCALL __vectorcall
- #elif defined(SK_CPU_ARM32) && defined(SK_ARM_HAS_NEON)
+  #elif defined(SK_CPU_ARM32) && defined(SK_ARM_HAS_NEON)
      #define VECTORCALL __attribute__((pcs("aapcs-vfp")))
- #else
+  #else
      #define VECTORCALL
- #endif
+  #endif
 
 class SkLinearBitmapPipeline::PointProcessorInterface {
 public:
     virtual ~PointProcessorInterface() { }
-    virtual void VECTORCALL pointListFew(int n, Sk4f xs, Sk4f ys) = 0;
-    virtual void VECTORCALL pointList4(Sk4f xs, Sk4f ys) = 0;
+    virtual void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) = 0;
+    virtual void VECTORCALL pointList4(Sk4s xs, Sk4s ys) = 0;
 
     // The pointSpan method efficiently process horizontal spans of pixels.
     // * start - the point where to start the span.
     // * length - the number of pixels to traverse in source space.
     // * count - the number of pixels to produce in destination space.
     // Both start and length are mapped through the inversion matrix to produce values in source
     // space. After the matrix operation, the tilers may break the spans up into smaller spans.
     // The tilers can produce spans that seem nonsensical.
     // * The clamp tiler can create spans with length of 0. This indicates to copy an edge pixel out
     //   to the edge of the destination scan.
@@ skipping 10 matching lines @@
     // |        |        |
     // |  px00  |  px10  |
     // |    0   |    1   |
     // +--------+--------+
     // |        |        |
     // |  px01  |  px11  |
     // |    2   |    3   |
     // +--------+--------+
     // These pixels coordinates are arranged in the following order in xs and ys:
     // px00  px10  px01  px11
-    virtual void VECTORCALL bilerpList(Sk4f xs, Sk4f ys) = 0;
+    virtual void VECTORCALL bilerpList(Sk4s xs, Sk4s ys) = 0;
 };
 
 class SkLinearBitmapPipeline::PixelPlacerInterface {
 public:
     virtual ~PixelPlacerInterface() { }
     virtual void setDestination(SkPM4f* dst) = 0;
     virtual void VECTORCALL placePixel(Sk4f pixel0) = 0;
     virtual void VECTORCALL place4Pixels(Sk4f p0, Sk4f p1, Sk4f p2, Sk4f p3) = 0;
 };
 
 namespace  {
 
 struct X {
     explicit X(SkScalar val) : fVal{val} { }
     explicit X(SkPoint pt)   : fVal{pt.fX} { }
     explicit X(SkSize s)     : fVal{s.fWidth} { }
     explicit X(SkISize s)    : fVal(s.fWidth) { }
-    operator float () const {return fVal;}
+    operator SkScalar () const {return fVal;}
 private:
-    float fVal;
+    SkScalar fVal;
 };
 
 struct Y {
     explicit Y(SkScalar val) : fVal{val} { }
     explicit Y(SkPoint pt)   : fVal{pt.fY} { }
     explicit Y(SkSize s)     : fVal{s.fHeight} { }
     explicit Y(SkISize s)    : fVal(s.fHeight) { }
-    operator float () const {return fVal;}
+    operator SkScalar () const {return fVal;}
 private:
-    float fVal;
+    SkScalar fVal;
 };
 
 template <typename Stage>
 void span_fallback(SkPoint start, SkScalar length, int count, Stage* stage) {
-    // If count == 1 use PointListFew instead.
-    SkASSERT(count > 1);
-
-    float dx = length / (count - 1);
-    Sk4f Xs = Sk4f(X(start)) + Sk4f{0.0f, 1.0f, 2.0f, 3.0f} * Sk4f{dx};
-    Sk4f Ys{Y(start)};
-    Sk4f fourDx = {4.0f * dx};
+    Sk4f xs{X(start)};
+    Sk4f ys{Y(start)};
+    Sk4s fourDx;
+    if (count > 1) {
+        SkScalar dx = length / (count - 1);
+        xs = xs + Sk4f{0.0f, 1.0f, 2.0f, 3.0f} * dx;
+        // Only used if count is >= 4.
+        fourDx = Sk4f{4.0f * dx};
+    }
 
     while (count >= 4) {
-        stage->pointList4(Xs, Ys);
-        Xs = Xs + fourDx;
+        stage->pointList4(xs, ys);
+        xs = xs + fourDx;
         count -= 4;
     }
     if (count > 0) {
-        stage->pointListFew(count, Xs, Ys);
+        stage->pointListFew(count, xs, ys);
     }
 }
 
 // PointProcessor uses a strategy to help complete the work of the different stages. The strategy
 // must implement the following methods:
 // * processPoints(xs, ys) - must mutate the xs and ys for the stage.
 // * maybeProcessSpan(start, length, count) - This represents a horizontal series of pixels
 //   to work over.
 //   start - is the starting pixel. This is in destination space before the matrix stage, and in
 //           source space after the matrix stage.
 //   length - is this distance between the first pixel center and the last pixel center. Like start,
 //           this is in destination space before the matrix stage, and in source space after.
 //   count - the number of pixels in source space to produce.
 //   next - a pointer to the next stage.
 //   maybeProcessSpan - returns false if it can not process the span and needs to fallback to
 //                      point lists for processing.
 template<typename Strategy, typename Next>
 class PointProcessor final : public SkLinearBitmapPipeline::PointProcessorInterface {
 public:
     template <typename... Args>
     PointProcessor(Next* next, Args&&... args)
         : fNext{next}
         , fStrategy{std::forward<Args>(args)...}{ }
 
-    void VECTORCALL pointListFew(int n, Sk4f xs, Sk4f ys) override {
+    void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
         fStrategy.processPoints(&xs, &ys);
         fNext->pointListFew(n, xs, ys);
     }
 
-    void VECTORCALL pointList4(Sk4f xs, Sk4f ys) override {
+    void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
         fStrategy.processPoints(&xs, &ys);
         fNext->pointList4(xs, ys);
     }
 
     void pointSpan(SkPoint start, SkScalar length, int count) override {
         if (!fStrategy.maybeProcessSpan(start, length, count, fNext)) {
             span_fallback(start, length, count, this);
         }
     }
 
 private:
     Next* const fNext;
     Strategy fStrategy;
 };
 
 // See PointProcessor for responsibilities of Strategy.
 template<typename Strategy, typename Next>
 class BilerpProcessor final : public SkLinearBitmapPipeline::BilerpProcessorInterface  {
 public:
     template <typename... Args>
     BilerpProcessor(Next* next, Args&&... args)
         : fNext{next}
         , fStrategy{std::forward<Args>(args)...}{ }
 
-    void VECTORCALL pointListFew(int n, Sk4f xs, Sk4f ys) override {
+    void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
         fStrategy.processPoints(&xs, &ys);
         fNext->pointListFew(n, xs, ys);
     }
 
-    void VECTORCALL pointList4(Sk4f xs, Sk4f ys) override {
+    void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
         fStrategy.processPoints(&xs, &ys);
         fNext->pointList4(xs, ys);
     }
 
-    void VECTORCALL bilerpList(Sk4f xs, Sk4f ys) override {
+    void VECTORCALL bilerpList(Sk4s xs, Sk4s ys) override {
         fStrategy.processPoints(&xs, &ys);
         fNext->bilerpList(xs, ys);
     }
 
     void pointSpan(SkPoint start, SkScalar length, int count) override {
         if (!fStrategy.maybeProcessSpan(start, length, count, fNext)) {
             span_fallback(start, length, count, this);
         }
     }
 
 private:
     Next* const fNext;
     Strategy fStrategy;
 };
 
 class SkippedStage final : public SkLinearBitmapPipeline::BilerpProcessorInterface {
-    void VECTORCALL pointListFew(int n, Sk4f xs, Sk4f ys) override {
+    void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
         SkFAIL("Skipped stage.");
     }
-    void VECTORCALL pointList4(Sk4f xs, Sk4f ys) override {
+    void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
         SkFAIL("Skipped stage.");
     }
-    void VECTORCALL bilerpList(Sk4f xs, Sk4f ys) override {
+    void VECTORCALL bilerpList(Sk4s xs, Sk4s ys) override {
         SkFAIL("Skipped stage.");
     }
     void pointSpan(SkPoint start, SkScalar length, int count) override {
         SkFAIL("Skipped stage.");
     }
 };
 
 class TranslateMatrixStrategy {
 public:
     TranslateMatrixStrategy(SkVector offset)
         : fXOffset{X(offset)}
         , fYOffset{Y(offset)} { }
 
-    void processPoints(Sk4f* xs, Sk4f* ys) {
+    void processPoints(Sk4s* xs, Sk4s* ys) {
         *xs = *xs + fXOffset;
         *ys = *ys + fYOffset;
     }
 
     template <typename Next>
     bool maybeProcessSpan(SkPoint start, SkScalar length, int count, Next* next) {
         next->pointSpan(start + SkPoint{fXOffset[0], fYOffset[0]}, length, count);
         return true;
     }
 
 private:
-    const Sk4f fXOffset, fYOffset;
+    const Sk4s fXOffset, fYOffset;
 };
 template <typename Next = SkLinearBitmapPipeline::PointProcessorInterface>
 using TranslateMatrix = PointProcessor<TranslateMatrixStrategy, Next>;
 
 class ScaleMatrixStrategy {
 public:
     ScaleMatrixStrategy(SkVector offset, SkVector scale)
         : fXOffset{X(offset)}, fYOffset{Y(offset)}
         ,  fXScale{X(scale)},   fYScale{Y(scale)} { }
-    void processPoints(Sk4f* xs, Sk4f* ys) {
+    void processPoints(Sk4s* xs, Sk4s* ys) {
         *xs = *xs * fXScale + fXOffset;
         *ys = *ys * fYScale + fYOffset;
     }
 
     template <typename Next>
     bool maybeProcessSpan(SkPoint start, SkScalar length, int count, Next* next) {
         SkPoint newStart =
             SkPoint{X(start) * fXScale[0] + fXOffset[0], Y(start) * fYScale[0] + fYOffset[0]};
         SkScalar newLength = length * fXScale[0];
         next->pointSpan(newStart, newLength, count);
         return true;
     }
 
 private:
-    const Sk4f fXOffset, fYOffset;
-    const Sk4f fXScale, fYScale;
+    const Sk4s fXOffset, fYOffset;
+    const Sk4s fXScale, fYScale;
 };
 template <typename Next = SkLinearBitmapPipeline::PointProcessorInterface>
 using ScaleMatrix = PointProcessor<ScaleMatrixStrategy, Next>;
 
 class AffineMatrixStrategy {
 public:
     AffineMatrixStrategy(SkVector offset, SkVector scale, SkVector skew)
         : fXOffset{X(offset)}, fYOffset{Y(offset)}
         , fXScale{X(scale)},   fYScale{Y(scale)}
         , fXSkew{X(skew)},     fYSkew{Y(skew)} { }
-    void processPoints(Sk4f* xs, Sk4f* ys) {
-        Sk4f newXs = fXScale * *xs +  fXSkew * *ys + fXOffset;
-        Sk4f newYs =  fYSkew * *xs + fYScale * *ys + fYOffset;
+    void processPoints(Sk4s* xs, Sk4s* ys) {
+        Sk4s newXs = fXScale * *xs +  fXSkew * *ys + fXOffset;
+        Sk4s newYs =  fYSkew * *xs + fYScale * *ys + fYOffset;
 
         *xs = newXs;
         *ys = newYs;
     }
 
     template <typename Next>
     bool maybeProcessSpan(SkPoint start, SkScalar length, int count, Next* next) {
         return false;
     }
 
 private:
-    const Sk4f fXOffset, fYOffset;
-    const Sk4f fXScale,  fYScale;
-    const Sk4f fXSkew,   fYSkew;
+    const Sk4s fXOffset, fYOffset;
+    const Sk4s fXScale,  fYScale;
+    const Sk4s fXSkew,   fYSkew;
 };
 template <typename Next = SkLinearBitmapPipeline::PointProcessorInterface>
 using AffineMatrix = PointProcessor<AffineMatrixStrategy, Next>;
 
 static SkLinearBitmapPipeline::PointProcessorInterface* choose_matrix(
     SkLinearBitmapPipeline::PointProcessorInterface* next,
     const SkMatrix& inverse,
     SkLinearBitmapPipeline::MatrixStage* matrixProc) {
     if (inverse.hasPerspective()) {
         SkFAIL("Not implemented.");
@@ skipping 17 matching lines @@
         return next;
     }
     return matrixProc->get();
 }
 
 template <typename Next = SkLinearBitmapPipeline::BilerpProcessorInterface>
 class ExpandBilerp final : public SkLinearBitmapPipeline::PointProcessorInterface {
 public:
     ExpandBilerp(Next* next) : fNext{next} { }
 
-    void VECTORCALL pointListFew(int n, Sk4f xs, Sk4f ys) override {
+    void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
         SkASSERT(0 < n && n < 4);
         //                    px00   px10   px01  px11
-        const Sk4f kXOffsets{-0.5f,  0.5f, -0.5f, 0.5f},
+        const Sk4s kXOffsets{-0.5f,  0.5f, -0.5f, 0.5f},
                    kYOffsets{-0.5f, -0.5f,  0.5f, 0.5f};
-        if (n >= 1) fNext->bilerpList(Sk4f{xs[0]} + kXOffsets, Sk4f{ys[0]} + kYOffsets);
-        if (n >= 2) fNext->bilerpList(Sk4f{xs[1]} + kXOffsets, Sk4f{ys[1]} + kYOffsets);
-        if (n >= 3) fNext->bilerpList(Sk4f{xs[2]} + kXOffsets, Sk4f{ys[2]} + kYOffsets);
+        if (n >= 1) fNext->bilerpList(Sk4s{xs[0]} + kXOffsets, Sk4s{ys[0]} + kYOffsets);
+        if (n >= 2) fNext->bilerpList(Sk4s{xs[1]} + kXOffsets, Sk4s{ys[1]} + kYOffsets);
+        if (n >= 3) fNext->bilerpList(Sk4s{xs[2]} + kXOffsets, Sk4s{ys[2]} + kYOffsets);
     }
 
     void VECTORCALL pointList4(Sk4f xs, Sk4f ys) override {
         //                    px00   px10   px01  px11
         const Sk4f kXOffsets{-0.5f,  0.5f, -0.5f, 0.5f},
                    kYOffsets{-0.5f, -0.5f,  0.5f, 0.5f};
-        fNext->bilerpList(Sk4f{xs[0]} + kXOffsets, Sk4f{ys[0]} + kYOffsets);
-        fNext->bilerpList(Sk4f{xs[1]} + kXOffsets, Sk4f{ys[1]} + kYOffsets);
-        fNext->bilerpList(Sk4f{xs[2]} + kXOffsets, Sk4f{ys[2]} + kYOffsets);
-        fNext->bilerpList(Sk4f{xs[3]} + kXOffsets, Sk4f{ys[3]} + kYOffsets);
+        fNext->bilerpList(Sk4s{xs[0]} + kXOffsets, Sk4s{ys[0]} + kYOffsets);
+        fNext->bilerpList(Sk4s{xs[1]} + kXOffsets, Sk4s{ys[1]} + kYOffsets);
+        fNext->bilerpList(Sk4s{xs[2]} + kXOffsets, Sk4s{ys[2]} + kYOffsets);
+        fNext->bilerpList(Sk4s{xs[3]} + kXOffsets, Sk4s{ys[3]} + kYOffsets);
     }
 
     void pointSpan(SkPoint start, SkScalar length, int count) override {
         span_fallback(start, length, count, this);
     }
 
 private:
     Next* const fNext;
 };
 
 static SkLinearBitmapPipeline::PointProcessorInterface* choose_filter(
     SkLinearBitmapPipeline::BilerpProcessorInterface* next,
     SkFilterQuality filterQuailty,
     SkLinearBitmapPipeline::FilterStage* filterProc) {
     if (SkFilterQuality::kNone_SkFilterQuality == filterQuailty) {
         filterProc->Initialize<SkippedStage>();
         return next;
     } else {
         filterProc->Initialize<ExpandBilerp<>>(next);
         return filterProc->get();
     }
 }
 
+class Span {
+public:
+    Span(SkPoint start, SkScalar length, int count)
+        : fStart{start}
+        , fLength(length)
+        , fCount{count} {
+        SkASSERT(std::isfinite(length));
+    }
+
+    bool isEmpty() const { return 0 == count(); }
+    int count() const { return fCount; }
+    SkScalar length() const { return fLength; }
+    SkScalar startX() const { return X(fStart); }
+    SkScalar endX() const { return startX() + length(); }
+
+    bool inRange(SkScalar xMin, SkScalar xMax) const {

[mtklein, 2016/02/25 21:47:41]

-> completelyWithin?  inRange seems ambiguous about whether partial overlap
returns true or false.

[herb_g, 2016/02/26 04:05:53]

Done.

+        SkScalar sMin, sMax;
+        std::tie(sMin, sMax) = std::minmax(startX(), endX());
+        return xMin <= sMin && sMax <= xMax;
+    }
+
+    void offset(SkScalar offsetX) {
+        fStart.offset(offsetX, 0.0f);
+    }
+
+    Span breakAt(SkScalar breakX, SkScalar dx) {

[mtklein, 2016/02/25 21:47:41]

I find the countToBreak() and lengthToBreakAndAdjust() helpers confusing.  They
seem like they either want to be
   - countToBreak() const
   - lengthToBreak() const
   - break()
or all inlined here, with breakAtSingleColor() implemented by calling breakAt().

[herb_g, 2016/02/26 04:05:54]

Done.

+        SkPoint newStart = fStart;
+
+        int newCount = countToBreak(breakX, dx);

[mtklein, 2016/02/25 21:47:41]

all self calls need this->

[herb_g, 2016/02/26 04:05:54]

Done.

+
+        // The length is one dx less than the count * dx like the example above. There are

[mtklein, 2016/02/25 21:47:40]

this comment doesn't belong here given the code that surrounds it

[herb_g, 2016/02/26 04:05:54]

Done.

+        // middleCount samples, but dx is advanced one less time to get to the last sample.
+        SkScalar newLength = lengthToBreakAndAdjust(newCount, dx);
+
+        return Span{newStart, newLength, newCount};
+    }
+
+    Span breakAtSingleColor(SkScalar breakX, SkScalar dx) {

[mtklein, 2016/02/25 21:47:41]

I don't understand where colors are getting involved?

[herb_g, 2016/02/26 04:05:54]

Changed the way this is done.

+
+        int newCount = countToBreak(breakX, dx);
+
+        lengthToBreakAndAdjust(newCount, dx);
+        return Span{{breakX, Y(fStart)}, 0.0f, newCount};
+    }
+
+    template <typename Next>
+    void nextStage(Next* next) {
+        SkASSERT(next != nullptr);
+        SkASSERT(fCount > 0);
+        next->pointSpan(fStart, fLength, fCount);

[mtklein, 2016/02/25 21:47:41]

why does this function exist?  doesn't this suggest pointSpan() should take a
span?

[herb_g, 2016/02/26 04:05:53]

This is still a work in progress. Doing it now.

+    }
+
+private:
+    int countToBreak(SkScalar breakX, SkScalar dx) {
+        SkASSERT(std::isfinite(breakX));
+        SkASSERT(std::isfinite(dx));
+        SkScalar x = X(fStart);
+        // newCount will be at least 1.
+        int newCount = SkScalarFloorToInt((breakX - x) / dx) + 1;
+        SkASSERT(newCount > 0);
+        return newCount;
+    }
+
+    SkScalar lengthToBreakAndAdjust(int count, SkScalar dx) {
+        SkScalar lengthToStart = count * dx;
+        fLength -= lengthToStart;
+        fCount -= count;
+        fStart = {X(fStart) + lengthToStart, Y(fStart)};
+        // The length is one dx less than the count * dx like the example above. There are

[mtklein, 2016/02/25 21:47:41]

there is no example above

[herb_g, 2016/02/26 04:05:54]

Done.

+        // middleCount samples, but dx is advanced one less time to get to the last sample.
+        return lengthToStart - dx;
+    }
+
+    SkPoint  fStart;
+    SkScalar fLength;
+    int      fCount;
+};
+
 class ClampStrategy {
 public:
     ClampStrategy(X max)
         : fXMin{0.0f}
         , fXMax{max - 1.0f} { }
     ClampStrategy(Y max)
         : fYMin{0.0f}
         , fYMax{max - 1.0f} { }
     ClampStrategy(SkSize max)
         : fXMin{0.0f}
         , fYMin{0.0f}
         , fXMax{X(max) - 1.0f}
         , fYMax{Y(max) - 1.0f} { }
 
-    void processPoints(Sk4f* xs, Sk4f* ys) {
-        *xs = Sk4f::Min(Sk4f::Max(*xs, fXMin), fXMax);
-        *ys = Sk4f::Min(Sk4f::Max(*ys, fYMin), fYMax);
+    void processPoints(Sk4s* xs, Sk4s* ys) {
+        *xs = Sk4s::Min(Sk4s::Max(*xs, fXMin), fXMax);
+        *ys = Sk4s::Min(Sk4s::Max(*ys, fYMin), fYMax);
     }
 
     template <typename Next>
     bool maybeProcessSpan(SkPoint start, SkScalar length, int count, Next* next) {
-        return false;
+        SkASSERT(count > 0);
+        SkASSERT(std::isfinite(length));

[mtklein, 2016/02/25 21:47:41]

We seem to assert this multiple times, but count > 0 only here.  If we're going
to assert an invariant about Spans, doing it in its constructor seems like a
good consistent place.

[herb_g, 2016/02/26 04:05:54]

Acknowledged.

+        SkScalar xMin = fXMin[0];
+        SkScalar xMax = fXMax[0] + 1.0f;
+        SkScalar yMin = fYMin[0];
+        SkScalar yMax = fYMax[0];
+        SkScalar x = X(start);
+        SkScalar y = std::min(std::max<SkScalar>(yMin, Y(start)), yMax);
+
+        Span span{{x, y}, length, count};
+
+        // Handle the Span is on the tile if xMin and xMax not infinities or handle the case where

[mtklein, 2016/02/25 21:47:40]

please make this a sentence or delete it?

[herb_g, 2016/02/26 04:05:53]

Done.

+        // the x component is a pass through when xMin and xMax are infinities.
+        if (span.inRange(xMin, xMax)) {
+            span.nextStage(next);
+            return true;
+        }
+
+        SkScalar dx = length / (count - 1);
+
+        // This is only the case where the count is one and it is in x < xMin || xMax < x,

[mtklein, 2016/02/25 21:47:41]

...and it it outside [xMin, xMax]?

Is it really important to explain this here?  It should be obvious that we want
to avoid calculating dx if count == 1?

[herb_g, 2016/02/26 04:05:54]

Acknowledged.

+        // otherwise it was handled above.
+        if (1 == count || dx < 0) {

[mtklein, 2016/02/25 21:47:41]

if (count == 1 || length < 0) {
    return false;   // Fallback to point-by-point tiling.
}
SkScalar dx = length / (count - 1);

?

[herb_g, 2016/02/26 04:05:53]

Changed logic

+            return false;
+        }
+
+        //    A                 B     C
+        // +-------+-------+-------++-------+-------+-------+     +-------+-------++------
+        // |  *---*|---*---|*---*--||-*---*-|---*---|*---...|     |--*---*|---*---||*---*....
+        // |       |       |       ||       |       |       | ... |       |       ||
+        // |       |       |       ||       |       |       |     |       |       ||
+        // +-------+-------+-------++-------+-------+-------+     +-------+-------++------
+        //                         ^                                              ^
+        //                         | xMin                                  xMax-1 | xMax
+        //
+        //     *---*---*---... - track of samples. * = sample
+        //
+        //     +-+                                 ||
+        //     | |  - pixels in source space.      || - tile border.
+        //     +-+                                 ||
+        //
+        // The length from A to B is the length in source space or 4 * dx or (count - 1) * dx
+        // where dx is the distance between samples. There are 5 destination pixels
+        // corresponding to 5 samples specified in the A, B span. The distance from A to the next
+        // span starting at C is 5 * dx, so count * dx.
+        // Remember, count is the number of pixels needed for the destination and the number of
+        // samples.
+        // Overall Strategy:
+        // * Under - for portions of the span < xMin, take the color at pixel {xMin, y} and use it
+        //   to fill in the 5 pixel sampled from A to B.
+        // * Middle - for the portion of the span between xMin and xMax sample normally.
+        // * Over - for the portion of the span > xMax, take the color at pixel {xMax-1, y} and
+        //   use it to fill in the rest of the destination pixels.
+
+        if (dx > 0) {
+            if (span.startX() < xMin) {
+                if (span.endX() > xMin) {
+                    Span toDraw = span.breakAtSingleColor(xMin, dx);

[mtklein, 2016/02/25 21:47:40]

This breakAtSingleColor seems like something Span doesn't need to know about. 
It's only going to come up here in clamping right?

[mtklein, 2016/02/25 21:47:41]

We're not drawing anything here...

[herb_g, 2016/02/26 04:05:54]

Totally redid logic.

+                    toDraw.nextStage(next);
+                } else {
+                    span.nextStage(next);

[mtklein, 2016/02/25 21:47:41]

I don't think I follow this case.  It's entirely off the left, correct?  Should
we not be passing along a zero-length span at xMin to the next stage?

[herb_g, 2016/02/26 04:05:54]

Redid logic

+                    return true;
+                }
+            }
+            if (!span.isEmpty() && span.startX() < xMax) {

[mtklein, 2016/02/25 21:47:40]

All these if cases are really complicated.  Seems like things would be simpler
if we made 0-count spans legal (no-ops, but legal to ask for).

Then we could just unconditionally break the span into three spans here in
Clamp: a span at the left edge, a span in the tile, and a span at the right
edge.  Any of those might be empty.

[herb_g, 2016/02/26 04:05:53]

Done.

+                if (span.endX() > xMax) {
+                    Span toDraw = span.breakAt(xMax, dx);
+                    toDraw.nextStage(next);
+                } else {
+                    span.nextStage(next);
+                    return true;
+                };
+            }
+            if (!span.isEmpty()) {
+                next->pointSpan({xMax - 1.0f, y}, 0.0f, span.count());
+            }
+        } else {

[mtklein, 2016/02/25 21:47:41]

How did we get dx == 0 here?  Some sort of degenerate matrix?  Why don't we just
handle that case with fallback?

[herb_g, 2016/02/26 04:05:54]

Done.

+            if (span.startX() > xMax) {
+                if (span.endX() < xMax) {
+                    Span toDraw = span.breakAtSingleColor(xMax - 1.0f, dx);
+                    toDraw.nextStage(next);
+                } else {
+                    span.nextStage(next);
+                    return true;
+                }
+            }
+            if (!span.isEmpty() && span.startX() > xMin) {
+                if (span.endX() < xMin) {
+                    Span toDraw = span.breakAt(xMin, dx);
+                    toDraw.nextStage(next);
+                } else {
+                    span.nextStage(next);
+                    return true;
+                }
+            }
+            if (!span.isEmpty()) {
+                next->pointSpan({xMin, y}, 0.0f, span.count());
+            }
+        }
+        return true;
     }
 
 private:
-    const Sk4f fXMin{SK_FloatNegativeInfinity};
-    const Sk4f fYMin{SK_FloatNegativeInfinity};
-    const Sk4f fXMax{SK_FloatInfinity};
-    const Sk4f fYMax{SK_FloatInfinity};
+    const Sk4s fXMin{SK_FloatNegativeInfinity};
+    const Sk4s fYMin{SK_FloatNegativeInfinity};
+    const Sk4s fXMax{SK_FloatInfinity};
+    const Sk4s fYMax{SK_FloatInfinity};
 };
 template <typename Next = SkLinearBitmapPipeline::BilerpProcessorInterface>
 using Clamp = BilerpProcessor<ClampStrategy, Next>;
 
+static SkScalar tile_mod(SkScalar x, SkScalar base) {
+    return x - std::floor(x / base) * base;
+}
+
 class RepeatStrategy {
 public:
     RepeatStrategy(X max) : fXMax{max}, fXInvMax{1.0f/max} { }
     RepeatStrategy(Y max) : fYMax{max}, fYInvMax{1.0f/max} { }
     RepeatStrategy(SkSize max)
         : fXMax{X(max)}
         , fXInvMax{1.0f / X(max)}
         , fYMax{Y(max)}
         , fYInvMax{1.0f / Y(max)} { }
 
-    void processPoints(Sk4f* xs, Sk4f* ys) {
-        Sk4f divX = (*xs * fXInvMax).floor();
-        Sk4f divY = (*ys * fYInvMax).floor();
-        Sk4f baseX = (divX * fXMax);
-        Sk4f baseY = (divY * fYMax);
+    void processPoints(Sk4s* xs, Sk4s* ys) {
+        Sk4s divX = (*xs * fXInvMax).floor();
+        Sk4s divY = (*ys * fYInvMax).floor();
+        Sk4s baseX = (divX * fXMax);
+        Sk4s baseY = (divY * fYMax);
         *xs = *xs - baseX;
         *ys = *ys - baseY;
     }
 
     template <typename Next>
     bool maybeProcessSpan(SkPoint start, SkScalar length, int count, Next* next) {
-        return false;
+        SkASSERT(count > 0);
+        SkASSERT(std::isfinite(length));
+        // Make x and y in range on the tile.
+        SkScalar x = tile_mod(X(start), fXMax[0]);
+        SkScalar y = tile_mod(Y(start), fYMax[0]);
+        SkScalar xMax = fXMax[0];
+        SkScalar xMin = 0.0f;
+        SkScalar dx = length / (count - 1);
+
+        if (SkScalarAbs(dx) >= xMax) {
+            return false;
+        }
+
+        //             A        B     C                  D                Z
+        // +-------+-------+-------++-------+-------+-------++     +-------+-------++------
+        // |       |   *---|*---*--||-*---*-|---*---|*---*--||     |--*---*|       ||
+        // |       |       |       ||       |       |       || ... |       |       ||
+        // |       |       |       ||       |       |       ||     |       |       ||
+        // +-------+-------+-------++-------+-------+-------++     +-------+-------++------
+        //                         ^^                       ^^                     ^^
+        //                    xMax || xMin             xMax || xMin           xMax || xMin
+        //
+        //     *---*---*---... - track of samples. * = sample
+        //
+        //     +-+                                 ||
+        //     | |  - pixels in source space.      || - tile border.
+        //     +-+                                 ||
+        //
+        //
+        // The given span starts at A and continues on through several tiles to sample point Z.
+        // The idea is to break this into several spans one on each tile the entire span
+        // intersects. The A to B span only covers a partial tile and has a count of 3 and the
+        // distance from A to B is (count - 1) * dx or 2 * dx. The distance from A to the start of
+        // the next span is count * dx or 3 * dx. Span C to D covers an entire tile has a count
+        // of 5 and a length of 4 * dx. Remember, count is the number of pixels needed for the
+        // destination and the number of samples.
+        //
+        // Overall Strategy:
+        // While the span hangs over the edge of the tile, draw the span covering the tile then
+        // slide the span over to the next tile.
+
+        // The guard could have been count > 0, but then a bunch of math would be done in the
+        // common case.
+
+        Span span{{x, y}, length, count};
+        if (dx > 0) {
+            while (!span.isEmpty() && span.endX() > xMax) {
+                Span toDraw = span.breakAt(xMax, dx);
+                toDraw.nextStage(next);
+                span.offset(-xMax);
+            }
+        } else {
+            while (!span.isEmpty() && span.endX() < xMin) {
+                Span toDraw = span.breakAt(xMin, dx);
+                toDraw.nextStage(next);
+                span.offset(xMax);
+            }
+        }
+
+        // All on a single tile.
+        if (!span.isEmpty()) {
+            span.nextStage(next);
+        }
+
+        return true;
     }
 
 private:
-    const Sk4f fXMax{0.0f};
-    const Sk4f fXInvMax{0.0f};
-    const Sk4f fYMax{0.0f};
-    const Sk4f fYInvMax{0.0f};
+    const Sk4s fXMax{0.0f};
+    const Sk4s fXInvMax{0.0f};
+    const Sk4s fYMax{0.0f};
+    const Sk4s fYInvMax{0.0f};
 };
 
 template <typename Next = SkLinearBitmapPipeline::BilerpProcessorInterface>
 using Repeat = BilerpProcessor<RepeatStrategy, Next>;
 
 static SkLinearBitmapPipeline::BilerpProcessorInterface* choose_tiler(
     SkLinearBitmapPipeline::BilerpProcessorInterface* next,
     SkSize dimensions,
     SkShader::TileMode xMode,
     SkShader::TileMode yMode,
@@ skipping 34 matching lines @@
             case SkShader::kMirror_TileMode:
                 SkFAIL("Not implemented.");
                 break;
         }
     }
     return tileProcXOrBoth->get();
 }
 
 class sRGBFast {
 public:
-    static Sk4f VECTORCALL sRGBToLinear(Sk4f pixel) {
-        Sk4f l = pixel * pixel;
-        return Sk4f{l[0], l[1], l[2], pixel[3]};
+    static Sk4s VECTORCALL sRGBToLinear(Sk4s pixel) {
+        Sk4s l = pixel * pixel;
+        return Sk4s{l[0], l[1], l[2], pixel[3]};
     }
 };
 
 template <SkColorProfileType colorProfile>
 class Passthrough8888 {
 public:
     Passthrough8888(int width, const uint32_t* src)
         : fSrc{src}, fWidth{width}{ }
 
-    void VECTORCALL getFewPixels(int n, Sk4f xs, Sk4f ys, Sk4f* px0, Sk4f* px1, Sk4f* px2) {
-        Sk4i XIs = SkNx_cast<int, float>(xs);
-        Sk4i YIs = SkNx_cast<int, float>(ys);
+    void VECTORCALL getFewPixels(int n, Sk4s xs, Sk4s ys, Sk4f* px0, Sk4f* px1, Sk4f* px2) {
+        Sk4i XIs = SkNx_cast<int, SkScalar>(xs);
+        Sk4i YIs = SkNx_cast<int, SkScalar>(ys);
         Sk4i bufferLoc = YIs * fWidth + XIs;
         switch (n) {
             case 3:
                 *px2 = getPixel(fSrc, bufferLoc[2]);
             case 2:
                 *px1 = getPixel(fSrc, bufferLoc[1]);
             case 1:
                 *px0 = getPixel(fSrc, bufferLoc[0]);
             default:
                 break;
         }
     }
 
-    void VECTORCALL get4Pixels(Sk4f xs, Sk4f ys, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) {
-        Sk4i XIs = SkNx_cast<int, float>(xs);
-        Sk4i YIs = SkNx_cast<int, float>(ys);
+    void VECTORCALL get4Pixels(Sk4s xs, Sk4s ys, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) {
+        Sk4i XIs = SkNx_cast<int, SkScalar>(xs);
+        Sk4i YIs = SkNx_cast<int, SkScalar>(ys);
         Sk4i bufferLoc = YIs * fWidth + XIs;
         *px0 = getPixel(fSrc, bufferLoc[0]);
         *px1 = getPixel(fSrc, bufferLoc[1]);
         *px2 = getPixel(fSrc, bufferLoc[2]);
         *px3 = getPixel(fSrc, bufferLoc[3]);
     }
 
     const uint32_t* row(int y) { return fSrc + y * fWidth[0]; }
 
 private:
@@ skipping 23 matching lines @@
 //           +--------+--------+
 //
 //
 // Given a pixelxy each is multiplied by a different factor derived from the fractional part of x
 // and y:
 // * px00 -> (1 - x)(1 - y) = 1 - x - y + xy
 // * px10 -> x(1 - y) = x - xy
 // * px01 -> (1 - x)y = y - xy
 // * px11 -> xy
 // So x * y is calculated first and then used to calculate all the other factors.
-static Sk4f VECTORCALL bilerp4(Sk4f xs, Sk4f ys, Sk4f px00, Sk4f px10,
+static Sk4s VECTORCALL bilerp4(Sk4s xs, Sk4s ys, Sk4f px00, Sk4f px10,
                                                  Sk4f px01, Sk4f px11) {
     // Calculate fractional xs and ys.
-    Sk4f fxs = xs - xs.floor();
-    Sk4f fys = ys - ys.floor();
-    Sk4f fxys{fxs * fys};
+    Sk4s fxs = xs - xs.floor();
+    Sk4s fys = ys - ys.floor();
+    Sk4s fxys{fxs * fys};
     Sk4f sum =  px11 * fxys;
     sum = sum + px01 * (fys - fxys);
     sum = sum + px10 * (fxs - fxys);
     sum = sum + px00 * (Sk4f{1.0f} - fxs - fys + fxys);
     return sum;
 }
 
 template <typename SourceStrategy>
 class Sampler final : public SkLinearBitmapPipeline::BilerpProcessorInterface {
 public:
     template <typename... Args>
     Sampler(SkLinearBitmapPipeline::PixelPlacerInterface* next, Args&&... args)
         : fNext{next}
         , fStrategy{std::forward<Args>(args)...} { }
 
-    void VECTORCALL pointListFew(int n, Sk4f xs, Sk4f ys) override {
+    void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
         SkASSERT(0 < n && n < 4);
         Sk4f px0, px1, px2;
         fStrategy.getFewPixels(n, xs, ys, &px0, &px1, &px2);
         if (n >= 1) fNext->placePixel(px0);
         if (n >= 2) fNext->placePixel(px1);
         if (n >= 3) fNext->placePixel(px2);
     }
 
-    void VECTORCALL pointList4(Sk4f xs, Sk4f ys) override {
+    void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
         Sk4f px0, px1, px2, px3;
         fStrategy.get4Pixels(xs, ys, &px0, &px1, &px2, &px3);
         fNext->place4Pixels(px0, px1, px2, px3);
     }
 
-    void VECTORCALL bilerpList(Sk4f xs, Sk4f ys) override {
+    void VECTORCALL bilerpList(Sk4s xs, Sk4s ys) override {
         Sk4f px00, px10, px01, px11;
         fStrategy.get4Pixels(xs, ys, &px00, &px10, &px01, &px11);
         Sk4f pixel = bilerp4(xs, ys, px00, px10, px01, px11);
         fNext->placePixel(pixel);
     }
 
     void pointSpan(SkPoint start, SkScalar length, int count) override {
         span_fallback(start, length, count, this);
     }
 
@@ skipping 97 matching lines @@
     auto samplerStage   = choose_pixel_sampler(placementStage, srcPixmap, &fSampleStage);
     auto tilerStage     = choose_tiler(samplerStage, size, xTile, yTile, &fTileXOrBothStage,
                                        &fTileYStage);
     auto filterStage    = choose_filter(tilerStage, filterQuality, &fFilterStage);
     fFirstStage         = choose_matrix(filterStage, inverse, &fMatrixStage);
 }
 
 void SkLinearBitmapPipeline::shadeSpan4f(int x, int y, SkPM4f* dst, int count) {
     SkASSERT(count > 0);
     fPixelStage->setDestination(dst);
-    // Adjust points by 0.5, 0.5 to sample from the center of the pixels.
-    if (count == 1) {
-        fFirstStage->pointListFew(1, Sk4f{x + 0.5f}, Sk4f{y + 0.5f});
-    } else {
-        // The count and length arguments start out in a precise relation in order to keep the
-        // math correct through the different stages. Count is the number of pixel to produce.
-        // Since the code samples at pixel centers, length is the distance from the center of the
-        // first pixel to the center of the last pixel. This implies that length is count-1.
-        fFirstStage->pointSpan(SkPoint{x + 0.5f, y + 0.5f}, count - 1, count);
-    }
+    // The count and length arguments start out in a precise relation in order to keep the
+    // math correct through the different stages. Count is the number of pixel to produce.
+    // Since the code samples at pixel centers, length is the distance from the center of the
+    // first pixel to the center of the last pixel. This implies that length is count-1.
+    fFirstStage->pointSpan(SkPoint{x + 0.5f, y + 0.5f}, count - 1, count);
 }