Introduce bilerp 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"
 
@@ skipping 114 matching lines @@
     void clampToSinglePixel(SkPoint pixel) {
         fStart = pixel;
         fLength = 0.0f;
     }
 
 private:
     SkPoint  fStart;
     SkScalar fLength;
     int      fCount;
 };
+
+// BilerpSpans are similar to Spans, but they represent four source samples converting to single
+// destination pixel per count. The pixels for the four samples are collect along two horizontal
+// lines; one starting at {x, y0} and the other starting at {x, y1}. There are two distinct lines
+// to deal with the edge case of the tile mode. For example, y0 may be at the last y position in
+// a tile while y1 would be at the first.
+// The step of a Bilerp (dx) is still length / (count - 1) and the start to the next sample is
+// still dx * count, but the bounds are complicated by the sampling kernel so that the pixels
+// touched are from x to x + length + 1.
+class BilerpSpan {
+public:
+    BilerpSpan(SkScalar x, SkScalar y0, SkScalar y1, SkScalar length, int count)
+        : fX{x}, fY0{y0}, fY1{y1}, fLength{length}, fCount{count} {
+        SkASSERT(count >= 0);
+        SkASSERT(std::isfinite(length));
+        SkASSERT(std::isfinite(x));
+        SkASSERT(std::isfinite(y0));
+        SkASSERT(std::isfinite(y1));
+    }
+
+    operator std::tuple<SkScalar&, SkScalar&, SkScalar&, SkScalar&, int&>() {
+        return std::tie(fX, fY0, fY1, fLength, fCount);
+    }
+
+    bool isEmpty() const { return 0 == fCount; }
+
+private:
+    SkScalar fX;
+    SkScalar fY0;
+    SkScalar fY1;
+    SkScalar fLength;
+    int      fCount;
+};
 }  // namespace
 
 class SkLinearBitmapPipeline::PointProcessorInterface {
 public:
     virtual ~PointProcessorInterface() { }
     virtual void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) = 0;
     virtual void VECTORCALL pointList4(Sk4s xs, Sk4s ys) = 0;
     virtual void pointSpan(Span span) = 0;
 };
 
 class SkLinearBitmapPipeline::BilerpProcessorInterface
     : public SkLinearBitmapPipeline::PointProcessorInterface {
 public:
     // The x's and y's are setup in the following order:
     // +--------+--------+
     // |        |        |
     // |  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(Sk4s xs, Sk4s ys) = 0;
+    virtual void bilerpSpan(BilerpSpan span) = 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;
 };
 
@@ skipping 19 matching lines @@
     while (count >= 4) {
         stage->pointList4(xs, ys);
         xs = xs + fourDx;
         count -= 4;
     }
     if (count > 0) {
         stage->pointListFew(count, xs, ys);
     }
 }
 
+template <typename Next>
+void bilerp_span_fallback(BilerpSpan span, Next* next) {
+    SkScalar x, y0, y1; SkScalar length; int count;
+    std::tie(x, y0, y1, length, count) = span;
+
+    SkASSERT(!span.isEmpty());
+    float dx = length / (count - 1);
+
+    Sk4f xs = Sk4f{x} + Sk4f{0.0f,  1.0f, 0.0f, 1.0f};
+    Sk4f ys = Sk4f{y0, y0,  y1, y1};
+
+    // If count == 1 then dx will be inf or NaN, but that is ok because the resulting addition is
+    // never used.
+    while (count > 0) {
+        next->bilerpList(xs, ys);
+        xs = xs + dx;
+        count -= 1;
+    }
+}
+
 // 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(span, next) - This represents a horizontal series of pixels
 //   to work over.
 //   span - encapsulation of span.
 //   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>
@@ skipping 51 matching lines @@
         fNext->bilerpList(xs, ys);
     }
 
     void pointSpan(Span span) override {
         SkASSERT(!span.isEmpty());
         if (!fStrategy.maybeProcessSpan(span, fNext)) {
             span_fallback(span, this);
         }
     }
 
+    void bilerpSpan(BilerpSpan bSpan) override {
+        SkASSERT(!bSpan.isEmpty());
+        if (!fStrategy.maybeProcessBilerpSpan(bSpan, fNext)) {
+            bilerp_span_fallback(bSpan, this);
+        }
+    }
+
 private:
     Next* const fNext;
     Strategy fStrategy;
 };
 
 class TranslateMatrixStrategy {
 public:
     TranslateMatrixStrategy(SkVector offset)
         : fXOffset{X(offset)}
         , fYOffset{Y(offset)} { }
@@ skipping 121 matching lines @@
         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(Span span) override {
         SkASSERT(!span.isEmpty());
         SkPoint start; SkScalar length; int count;
         std::tie(start, length, count) = span;
-        float dx = length / (count - 1);
-
-        Sk4f Xs = Sk4f{X(start)} + Sk4f{-0.5f,  0.5f, -0.5f, 0.5f};
-        Sk4f Ys = Sk4f{Y(start)} + Sk4f{-0.5f, -0.5f,  0.5f, 0.5f};
-
-        Sk4f dXs{dx};
-        while (count > 0) {
-            fNext->bilerpList(Xs, Ys);
-            Xs = Xs + dXs;
-            count -= 1;
-        }
+        // Adjust the span so that it is in the correct phase with the pixel.
+        BilerpSpan bSpan{X(start) - 0.5f, Y(start) - 0.5f, Y(start) + 0.5f, length, count};
+        fNext->bilerpSpan(bSpan);
     }
 
 private:
     Next* const fNext;
 };
 
 static SkLinearBitmapPipeline::PointProcessorInterface* choose_filter(
     SkLinearBitmapPipeline::BilerpProcessorInterface* next,
     SkFilterQuality filterQuailty,
     SkLinearBitmapPipeline::FilterStage* filterProc) {
@@ skipping 100 matching lines @@
                 next->pointSpan(middle);
             }
             if (!span.isEmpty()) {
                 span.clampToSinglePixel({xMin, y});
                 next->pointSpan(span);
             }
         }
         return true;
     }
 
+    template <typename Next>
+    bool maybeProcessBilerpSpan(BilerpSpan bSpan, Next* next) {
+        return false;
+    }
+
 private:
     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) {
@@ skipping 83 matching lines @@
         }
 
         // All on a single tile.
         if (!span.isEmpty()) {
             next->pointSpan(span);
         }
 
         return true;
     }
 
+    template <typename Next>
+    bool maybeProcessBilerpSpan(BilerpSpan bSpan, Next* next) {
+        return false;
+    }
+
 private:
     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>;
 
@@ skipping 261 matching lines @@
             count -= 1;
         }
     }
 
     // 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 pointSpanFastRate(Span span) {
         span_fallback(span, this);
     }
 
+    void bilerpSpan(BilerpSpan span) override {
+        bilerp_span_fallback(span, this);
+    }
+
 private:
     SkLinearBitmapPipeline::PixelPlacerInterface* const fNext;
     SourceStrategy fStrategy;
 };
 
 using Pixel8888SRGB = Pixel8888<kSRGB_SkColorProfileType, ColorOrder::kRGBA>;
 using Pixel8888LRGB = Pixel8888<kLinear_SkColorProfileType, ColorOrder::kRGBA>;
 using Pixel8888SBGR = Pixel8888<kSRGB_SkColorProfileType, ColorOrder::kBGRA>;
 using Pixel8888LBGR = Pixel8888<kLinear_SkColorProfileType, ColorOrder::kBGRA>;
 
@@ skipping 96 matching lines @@
 
 void SkLinearBitmapPipeline::shadeSpan4f(int x, int y, SkPM4f* dst, int count) {
     SkASSERT(count > 0);
     fPixelStage->setDestination(dst);
     // 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(Span{SkPoint{x + 0.5f, y + 0.5f}, count - 1.0f, count});
 }