Add spans for matrix ops.

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 36 matching lines @@
     while (count >= 4) {
         stage->pointList4(Xs, Ys);
         Xs = Xs + fourDx;
         count -= 4;
     }
     if (count > 0) {
         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 PointProcessorInterface {
 public:
     template <typename... Args>
     PointProcessor(Next* next, Args&&... args)
         : fNext{next}
         , fStrategy{std::forward<Args>(args)...}{ }
 
     void pointListFew(int n, Sk4fArg xs, Sk4fArg ys) override {
         Sk4f newXs = xs;
         Sk4f newYs = ys;
         fStrategy.processPoints(&newXs, &newYs);
         fNext->pointListFew(n, newXs, newYs);
     }
 
     void pointList4(Sk4fArg xs, Sk4fArg ys) override {
         Sk4f newXs = xs;
         Sk4f newYs = ys;
         fStrategy.processPoints(&newXs, &newYs);
         fNext->pointList4(newXs, newYs);
     }
 
     void pointSpan(SkPoint start, SkScalar length, int count) override {
-        span_fallback(start, length, count, this);
+        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 BilerpProcessorInterface  {
 public:
     template <typename... Args>
     BilerpProcessor(Next* next, Args&&... args)
         : fNext{next}
         , fStrategy{std::forward<Args>(args)...}{ }
 
     void pointListFew(int n, Sk4fArg xs, Sk4fArg ys) override {
         Sk4f newXs = xs;
@@ skipping 10 matching lines @@
     }
 
     void bilerpList(Sk4fArg xs, Sk4fArg ys) override {
         Sk4f newXs = xs;
         Sk4f newYs = ys;
         fStrategy.processPoints(&newXs, &newYs);
         fNext->bilerpList(newXs, newYs);
     }
 
     void pointSpan(SkPoint start, SkScalar length, int count) override {
-        span_fallback(start, length, count, this);
+        if (!fStrategy.maybeProcessSpan(start, length, count, fNext)) {
+            span_fallback(start, length, count, this);
+        }
     }
 
 private:
     Next* const fNext;
     Strategy fStrategy;
 };
 
 class SkippedStage final : public BilerpProcessorInterface {
     void pointListFew(int n, Sk4fArg xs, Sk4fArg ys) override {
         SkFAIL("Skipped stage.");
     }
     void pointList4(Sk4fArg Xs, Sk4fArg Ys) override {
         SkFAIL("Skipped stage.");
     }
     void bilerpList(Sk4fArg xs, Sk4fArg 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) {
         *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;
 };
 template <typename Next = 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) {
         *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;
 };
 template <typename Next = 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;
 
         *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;
 };
 template <typename Next = PointProcessorInterface>
 using AffineMatrix = PointProcessor<AffineMatrixStrategy, Next>;
 
 static PointProcessorInterface* choose_matrix(
     PointProcessorInterface* next,
@@ skipping 81 matching lines @@
         : 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);
     }
 
+    template <typename Next>
+    bool maybeProcessSpan(SkPoint start, SkScalar length, int count, Next* next) {
+        return false;
+    }
+
 private:
     const Sk4f fXMin{SK_FloatNegativeInfinity};
     const Sk4f fYMin{SK_FloatNegativeInfinity};
     const Sk4f fXMax{SK_FloatInfinity};
     const Sk4f fYMax{SK_FloatInfinity};
 };
 template <typename Next = BilerpProcessorInterface>
 using Clamp = BilerpProcessor<ClampStrategy, Next>;
 
 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);
         *xs = *xs - baseX;
         *ys = *ys - baseY;
     }
 
+    template <typename Next>
+    bool maybeProcessSpan(SkPoint start, SkScalar length, int count, Next* next) {
+        return false;
+    }
+
 private:
     const Sk4f fXMax{0.0f};
     const Sk4f fXInvMax{0.0f};
     const Sk4f fYMax{0.0f};
     const Sk4f fYInvMax{0.0f};
 };
 
 template <typename Next = BilerpProcessorInterface>
 using Repeat = BilerpProcessor<RepeatStrategy, Next>;
 
@@ skipping 275 matching lines @@
     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);
     }
 }