Simplify code by breaking general sampler into Nearest and Bilerp.

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 248 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 strategy given a particular job. It ultimately uses PixelGetters to access
-// the pixels.
+// We're moving through source space at a rate of 1 source pixel per 1 dst pixel.
+// We'll never re-use pixels, but we can at least load contiguous pixels.
+template <typename Next, typename Strategy>
+static void src_strategy_blend(Span span, Next* next, Strategy* strategy) {
+    SkPoint start;
+    SkScalar length;
+    int count;
+    std::tie(start, length, count) = span;
+    int ix = SkScalarFloorToInt(X(start));
+    const void* row = strategy->row((int)std::floor(Y(start)));
+    if (length > 0) {
+        while (count >= 4) {
+            Sk4f px0, px1, px2, px3;
+            strategy->get4Pixels(row, ix, &px0, &px1, &px2, &px3);
+            next->blend4Pixels(px0, px1, px2, px3);
+            ix += 4;
+            count -= 4;
+        }
+
+        while (count > 0) {
+            next->blendPixel(strategy->getPixelFromRow(row, ix));
+            ix += 1;
+            count -= 1;
+        }
+    } else {
+        while (count >= 4) {
+            Sk4f px0, px1, px2, px3;
+            strategy->get4Pixels(row, ix - 3, &px3, &px2, &px1, &px0);
+            next->blend4Pixels(px0, px1, px2, px3);
+            ix -= 4;
+            count -= 4;
+        }
+
+        while (count > 0) {
+            next->blendPixel(strategy->getPixelFromRow(row, ix));
+            ix -= 1;
+            count -= 1;
+        }
+    }
+}
+
+// NearestNeighborSampler - use nearest neighbor filtering to create runs of destination pixels.
 template<SkColorType colorType, SkColorProfileType colorProfile, typename Next>
-class GeneralSampler {
+class NearestNeighborSampler : public SkLinearBitmapPipeline::SampleProcessorInterface {
 public:
     template<typename... Args>
-    GeneralSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next, Args&& ... args)
-        : fNext{next}, fStrategy{std::forward<Args>(args)...} { }
+    NearestNeighborSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next, Args&& ... args)
+    : fNext{next}, fStrategy{std::forward<Args>(args)...} { }
 
-    GeneralSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next,
-                   const GeneralSampler& sampler)
-        : fNext{next}, fStrategy{sampler.fStrategy} { }
+    NearestNeighborSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next,
+    const NearestNeighborSampler& sampler)
+    : fNext{next}, fStrategy{sampler.fStrategy} { }
 
-    void VECTORCALL nearestListFew(int n, Sk4s xs, Sk4s ys) {
+    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->blendPixel(px0);
         if (n >= 2) fNext->blendPixel(px1);
         if (n >= 3) fNext->blendPixel(px2);
     }
 
-    void VECTORCALL nearestList4(Sk4s xs, Sk4s ys) {
+    void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
         Sk4f px0, px1, px2, px3;
         fStrategy.get4Pixels(xs, ys, &px0, &px1, &px2, &px3);
         fNext->blend4Pixels(px0, px1, px2, px3);
     }
 
-    void nearestSpan(Span span) {
+    void pointSpan(Span span) override {
         SkASSERT(!span.isEmpty());
         SkPoint start;
         SkScalar length;
         int count;
         std::tie(start, length, count) = span;
         SkScalar absLength = SkScalarAbs(length);
         if (absLength < (count - 1)) {
-            this->nearestSpanSlowRate(span);
+            this->spanSlowRate(span);
         } else if (absLength == (count - 1)) {
-            this->nearestSpanUnitRate(span);
+            src_strategy_blend(span, fNext, &fStrategy);
         } else {
-            this->nearestSpanFastRate(span);
+            this->spanFastRate(span);
         }
     }
 
-    Sk4f bilerpNonEdgePixel(SkScalar x, SkScalar y) {
-        Sk4f px00, px10, px01, px11;
-        // 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 repeatSpan(Span span, int32_t repeatCount) override {
+        while (repeatCount > 0) {
+            this->pointSpan(span);
+            repeatCount--;
+        }
     }
 
-    void VECTORCALL bilerpListFew(int n, Sk4s xs, Sk4s ys) {
-        SkASSERT(0 < n && n < 4);
-        auto bilerpPixel = [&](int 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 bilerpEdge(Sk4s xs, Sk4s ys) override {
+        SkFAIL("Using nearest neighbor sampler, but calling a bilerpEdge.");
     }
 
-    void VECTORCALL bilerpList4(Sk4s xs, Sk4s ys) {
-        auto bilerpPixel = [&](int 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);
-        fNext->blendPixel(pixel);
-    }
-
-    void bilerpSpan(Span span) {
-        this->bilerpSpanWithY(span, span.startY());
-    }
-
-    void bilerpSpanWithY(Span span, SkScalar y) {
-        SkASSERT(!span.isEmpty());
-        SkPoint start;
-        SkScalar length;
-        int count;
-        std::tie(start, length, count) = span;
-        SkScalar absLength = SkScalarAbs(length);
-        if (absLength == 0.0f) {
-            this->bilerpSpanZeroRate(span, y);
-        } else if (absLength < (count - 1)) {
-            this->bilerpSpanSlowRate(span, y);
-        } else if (absLength == (count - 1)) {
-            if (std::fmod(span.startX() - 0.5f, 1.0f) == 0.0f) {
-                if (std::fmod(span.startY() - 0.5f, 1.0f) == 0.0f) {
-                    this->nearestSpanUnitRate(span);
-                } else {
-                    this->bilerpSpanUnitRateAlignedX(span, y);
-                }
-            } else {
-                this->bilerpSpanUnitRate(span, y);
-            }
-        } else {
-            this->bilerpSpanFastRate(span, y);
-        }
+    void bilerpSpan(Span span, SkScalar y) override {
+        SkFAIL("Using nearest neighbor sampler, but calling a bilerpSpan.");
     }
 
 private:
     // 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 nearestSpanSlowRate(Span span) {
+    void spanSlowRate(Span span) {
         SkPoint start;
         SkScalar length;
         int count;
         std::tie(start, length, count) = span;
         SkScalar x = X(start);
         SkFixed fx = SkScalarToFixed(x);
         SkScalar dx = length / (count - 1);
         SkFixed fdx = SkScalarToFixed(dx);
 
         const void* row = fStrategy.row((int)std::floor(Y(start)));
@@ skipping 25 matching lines @@
             count -= 4;
         }
         while (count > 0) {
             next->blendPixel(getNextPixel());
             count -= 1;
         }
     }
 
     // We're moving through source space at a rate of 1 source pixel per 1 dst pixel.
     // We'll never re-use pixels, but we can at least load contiguous pixels.
-    void nearestSpanUnitRate(Span span) {
+    void spanUnitRate(Span span) {
+        src_strategy_blend(span, fNext, &fStrategy);
+    }
+
+    // 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 spanFastRate(Span span) {
+        span_fallback(span, this);
+    }
+
+    Next* const                            fNext;
+    PixelAccessor<colorType, colorProfile> fStrategy;
+};
+
+// BilerpSampler - use a bilerp filter to create runs of destination pixels.
+template<SkColorType colorType, SkColorProfileType colorProfile, typename Next>
+class BilerpSampler : public SkLinearBitmapPipeline::SampleProcessorInterface {
+public:
+    template<typename... Args>
+    BilerpSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next, Args&& ... args)
+        : fNext{next}, fStrategy{std::forward<Args>(args)...} { }
+
+    BilerpSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next,
+                   const BilerpSampler& sampler)
+        : fNext{next}, fStrategy{sampler.fStrategy} { }
+
+    Sk4f bilerpNonEdgePixel(SkScalar x, SkScalar y) {
+        Sk4f px00, px10, px01, px11;
+
+        // 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 pointListFew(int n, Sk4s xs, Sk4s ys) override {
+        SkASSERT(0 < n && n < 4);
+        auto bilerpPixel = [&](int 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 pointList4(Sk4s xs, Sk4s ys) override {
+        auto bilerpPixel = [&](int index) {
+            return this->bilerpNonEdgePixel(xs[index], ys[index]);
+        };
+        fNext->blend4Pixels(bilerpPixel(0), bilerpPixel(1), bilerpPixel(2), bilerpPixel(3));
+    }
+
+    void pointSpan(Span span) override {
+        this->bilerpSpan(span, span.startY());
+    }
+
+    void repeatSpan(Span span, int32_t repeatCount) override {
+        while (repeatCount > 0) {
+            this->pointSpan(span);
+            repeatCount--;
+        }
+    }
+
+    void VECTORCALL bilerpEdge(Sk4s sampleXs, Sk4s sampleYs) override {
+        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);
+        fNext->blendPixel(pixel);
+    }
+
+    void bilerpSpan(Span span, SkScalar y) override {
+        SkASSERT(!span.isEmpty());
         SkPoint start;
         SkScalar length;
         int count;
         std::tie(start, length, count) = span;
-        int ix = SkScalarFloorToInt(X(start));
-        const void* row = fStrategy.row((int)std::floor(Y(start)));
-        Next* next = fNext;
-        if (length > 0) {
-            while (count >= 4) {
-                Sk4f px0, px1, px2, px3;
-                fStrategy.get4Pixels(row, ix, &px0, &px1, &px2, &px3);
-                next->blend4Pixels(px0, px1, px2, px3);
-                ix += 4;
-                count -= 4;
-            }
-
-            while (count > 0) {
-                next->blendPixel(fStrategy.getPixelFromRow(row, ix));
-                ix += 1;
-                count -= 1;
+        SkScalar absLength = SkScalarAbs(length);
+        if (absLength == 0.0f) {
+            this->spanZeroRate(span, y);
+        } else if (absLength < (count - 1)) {
+            this->spanSlowRate(span, y);
+        } else if (absLength == (count - 1)) {
+            if (std::fmod(span.startX() - 0.5f, 1.0f) == 0.0f) {
+                if (std::fmod(span.startY() - 0.5f, 1.0f) == 0.0f) {
+                    src_strategy_blend(span, fNext, &fStrategy);
+                } else {
+                    this->spanUnitRateAlignedX(span, y);
+                }
+            } else {
+                this->spanUnitRate(span, y);
             }
         } else {
-            while (count >= 4) {
-                Sk4f px0, px1, px2, px3;
-                fStrategy.get4Pixels(row, ix - 3, &px3, &px2, &px1, &px0);
-                next->blend4Pixels(px0, px1, px2, px3);
-                ix -= 4;
-                count -= 4;
-            }
-
-            while (count > 0) {
-                next->blendPixel(fStrategy.getPixelFromRow(row, ix));
-                ix -= 1;
-                count -= 1;
-            }
+            this->spanFastRate(span, y);
         }
     }
 
-    // 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 nearestSpanFastRate(Span span) {
-        struct NearestWrapper {
-            void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) {
-                fSampler.nearestListFew(n, xs, ys);
-            }
-
-            void VECTORCALL pointList4(Sk4s xs, Sk4s ys) {
-                fSampler.nearestList4(xs, ys);
-            }
-
-            GeneralSampler& fSampler;
-        };
-        NearestWrapper wrapper{*this};
-        span_fallback(span, &wrapper);
-    }
-
-    void bilerpSpanZeroRate(Span span, SkScalar y1) {
+private:
+    void spanZeroRate(Span span, SkScalar y1) {
         SkScalar y0 = span.startY() - 0.5f;
         y1 += 0.5f;
         int iy0 = SkScalarFloorToInt(y0);
         SkScalar filterY1 = y0 - iy0;
         SkScalar filterY0 = 1.0f - filterY1;
         int iy1 = SkScalarFloorToInt(y1);
         int ix = SkScalarFloorToInt(span.startX());
         Sk4f pixelY0 = fStrategy.getPixelFromRow(fStrategy.row(iy0), ix);
         Sk4f pixelY1 = fStrategy.getPixelFromRow(fStrategy.row(iy1), ix);
         Sk4f filterPixel = pixelY0 * filterY0 + pixelY1 * filterY1;
         int count = span.count();
         while (count >= 4) {
             fNext->blend4Pixels(filterPixel, filterPixel, filterPixel, filterPixel);
             count -= 4;
         }
         while (count > 0) {
             fNext->blendPixel(filterPixel);
             count -= 1;
         }
     }
 
     // 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) {
+    void spanSlowRate(Span span, SkScalar ry1) {
         SkPoint start;
         SkScalar length;
         int count;
         std::tie(start, length, count) = span;
         SkFixed fx = SkScalarToFixed(X(start)-0.5f);
 
         SkFixed fdx = SkScalarToFixed(length / (count - 1));
 
         Sk4f xAdjust;
         if (fdx >= 0) {
@@ skipping 48 matching lines @@
 
         while (count > 0) {
             fNext->blendPixel(getNextPixel());
 
             count -= 1;
         }
     }
 
     // We're moving through source space at a rate of 1 source pixel per 1 dst pixel.
     // We'll never re-use pixels, but we can at least load contiguous pixels.
-    void bilerpSpanUnitRate(Span span, SkScalar y1) {
+    void spanUnitRate(Span span, SkScalar y1) {
         y1 += 0.5f;
         SkScalar y0 = span.startY() - 0.5f;
         int iy0 = SkScalarFloorToInt(y0);
         SkScalar filterY1 = y0 - iy0;
         SkScalar filterY0 = 1.0f - filterY1;
         int iy1 = SkScalarFloorToInt(y1);
         const void* rowY0 = fStrategy.row(iy0);
         const void* rowY1 = fStrategy.row(iy1);
         SkScalar x0 = span.startX() - 0.5f;
         int ix0 = SkScalarFloorToInt(x0);
@@ skipping 84 matching lines @@
                 Sk4f pixelY0 = fStrategy.getPixelFromRow(rowY0, ix0);
                 Sk4f pixelY1 = fStrategy.getPixelFromRow(rowY1, ix0);
 
                 fNext->blendPixel(lerp(pixelY0, pixelY1));
                 ix0 -= 1;
                 count -= 1;
             }
         }
     }
 
-    void bilerpSpanUnitRateAlignedX(Span span, SkScalar y1) {
+    void spanUnitRateAlignedX(Span span, SkScalar y1) {
         SkScalar y0 = span.startY() - 0.5f;
         y1 += 0.5f;
         int iy0 = SkScalarFloorToInt(y0);
         SkScalar filterY1 = y0 - iy0;
         SkScalar filterY0 = 1.0f - filterY1;
         int iy1 = SkScalarFloorToInt(y1);
         int ix = SkScalarFloorToInt(span.startX());
         const void* rowY0 = fStrategy.row(iy0);
         const void* rowY1 = fStrategy.row(iy1);
         auto lerp = [&](Sk4f* pixelY0, Sk4f* pixelY1) {
@@ skipping 38 matching lines @@
 
                 fNext->blendPixel(lerp(&pixelY0, &pixelY1));
                 ix -= 1;
                 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 bilerpSpanFastRate(Span span, SkScalar y1) {
+    void spanFastRate(Span span, SkScalar y1) {
         SkPoint start;
         SkScalar length;
         int count;
         std::tie(start, length, count) = span;
         SkScalar x = X(start);
         SkScalar y = Y(start);
+
         // 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);
+            span_fallback(span, this);
         } 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