Simplify code by breaking general sampler into Nearest and Bilerp.

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 <algorithm>
 #include <cmath>
 #include <limits>
 #include <tuple>
 
 #include "SkLinearBitmapPipeline_core.h"
 #include "SkLinearBitmapPipeline_matrix.h"
 #include "SkLinearBitmapPipeline_tile.h"
 #include "SkLinearBitmapPipeline_sample.h"
 #include "SkNx.h"
 #include "SkOpts.h"
 #include "SkPM4f.h"
 
-class SkLinearBitmapPipeline::PointProcessorInterface {
-public:
-    virtual ~PointProcessorInterface() { }
-    // Take the first n (where 0 < n && n < 4) items from xs and ys and sample those points. For
-    // nearest neighbor, that means just taking the floor xs and ys. For bilerp, this means
-    // to expand the bilerp filter around the point and sample using that filter.
-    virtual void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) = 0;
-    // Same as pointListFew, but n = 4.
-    virtual void VECTORCALL pointList4(Sk4s xs, Sk4s ys) = 0;
-    // A span is a compact form of sample points that are obtained by mapping points from
-    // destination space to source space. This is used for horizontal lines only, and is mainly
-    // used to take advantage of memory coherence for horizontal spans.
-    virtual void pointSpan(Span span) = 0;
-};
-
-class SkLinearBitmapPipeline::SampleProcessorInterface
-    : public SkLinearBitmapPipeline::PointProcessorInterface {
-public:
-    // Used for nearest neighbor when scale factor is 1.0. The span can just be repeated with no
-    // edge pixel alignment problems. This is for handling a very common case.
-    virtual void repeatSpan(Span span, int32_t repeatCount) = 0;
-
-    // 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 bilerpEdge(Sk4s xs, Sk4s ys) = 0;
-
-    // A span represents sample points that have been mapped from destination space to source
-    // space. Each sample point is then expanded to the four bilerp points by add +/- 0.5. The
-    // resulting Y values my be off the tile. When y +/- 0.5 are more than 1 apart because of
-    // tiling, the second Y is used to denote the retiled Y value.
-    virtual void bilerpSpan(Span span, SkScalar y) = 0;
-};
-
-class SkLinearBitmapPipeline::DestinationInterface {
-public:
-    virtual ~DestinationInterface() { }
-    // Count is normally not needed, but in these early stages of development it is useful to
-    // check bounds.
-    // TODO(herb): 4/6/2016 - remove count when code is stable.
-    virtual void setDestination(void* dst, int count) = 0;
-};
-
-class SkLinearBitmapPipeline::BlendProcessorInterface
-    : public SkLinearBitmapPipeline::DestinationInterface {
-public:
-    virtual void VECTORCALL blendPixel(Sk4f pixel0) = 0;
-    virtual void VECTORCALL blend4Pixels(Sk4f p0, Sk4f p1, Sk4f p2, Sk4f p3) = 0;
-};
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // SkLinearBitmapPipeline::Stage
 template<typename Base, size_t kSize, typename Next>
 SkLinearBitmapPipeline::Stage<Base, kSize, Next>::~Stage() {
     if (fIsInitialized) {
         this->get()->~Base();
     }
 }
 
 template<typename Base, size_t kSize, typename Next>
@@ skipping 370 matching lines @@
             break;
         case SkShader::kMirror_TileMode:
             choose_tiler_ymode<XMirrorStrategy>(yMode, filterQuality, dimensions, next, tileStage);
             break;
     }
 
     return tileStage->get();
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-// Source Sampling Stage
-template <SkColorType colorType, SkColorProfileType colorProfile, typename Next>
-class NearestNeighborSampler final : public SkLinearBitmapPipeline::SampleProcessorInterface {
-public:
-    template <typename... Args>
-    NearestNeighborSampler(Next* next, Args&&... args)
-    : fSampler{next, std::forward<Args>(args)...} { }
-
-    NearestNeighborSampler(Next* next, const NearestNeighborSampler& sampler)
-        : fSampler{next, sampler.fSampler} { }
-
-    void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
-        fSampler.nearestListFew(n, xs, ys);
-    }
-
-    void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
-        fSampler.nearestList4(xs, ys);
-    }
-
-    void pointSpan(Span span) override {
-        fSampler.nearestSpan(span);
-    }
-
-    void repeatSpan(Span span, int32_t repeatCount) override {
-        while (repeatCount > 0) {
-            fSampler.nearestSpan(span);
-            repeatCount--;
-        }
-    }
-
-    void VECTORCALL bilerpEdge(Sk4s xs, Sk4s ys) override {
-        SkFAIL("Using nearest neighbor sampler, but calling a bilerpEdge.");
-    }
-
-    void bilerpSpan(Span span, SkScalar y) override {
-        SkFAIL("Using nearest neighbor sampler, but calling a bilerpSpan.");
-    }
-
-private:
-    GeneralSampler<colorType, colorProfile, Next> fSampler;
-};
-
-template <SkColorType colorType, SkColorProfileType colorProfile, typename Next>
-class BilerpSampler final : public SkLinearBitmapPipeline::SampleProcessorInterface {
-public:
-    template <typename... Args>
-    BilerpSampler(Next* next, Args&&... args)
-        : fSampler{next, std::forward<Args>(args)...} { }
-
-    BilerpSampler(Next* next, const BilerpSampler& sampler)
-    : fSampler{next, sampler.fSampler} { }
-
-    void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
-        fSampler.bilerpListFew(n, xs, ys);
-    }
-
-    void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
-        fSampler.bilerpList4(xs, ys);
-    }
-
-    void pointSpan(Span span) override {
-        fSampler.bilerpSpan(span);
-    }
-
-    void repeatSpan(Span span, int32_t repeatCount) override {
-        while (repeatCount > 0) {
-            fSampler.bilerpSpan(span);
-            repeatCount--;
-        }
-    }
-
-    void VECTORCALL bilerpEdge(Sk4s xs, Sk4s ys) override {
-        fSampler.bilerpEdge(xs, ys);
-    }
-
-    void bilerpSpan(Span span, SkScalar y) override {
-        fSampler.bilerpSpanWithY(span, y);
-    }
-
-private:
-    GeneralSampler<colorType, colorProfile, Next> fSampler;
-};
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
 // Specialized Samplers
 
 // RGBA8888UnitRepeatSrc - A sampler that takes advantage of the fact the the src and destination
 // are the same format and do not need in transformations in pixel space. Therefore, there is no
 // need to convert them to HiFi pixel format.
 class RGBA8888UnitRepeatSrc final : public SkLinearBitmapPipeline::SampleProcessorInterface,
                                     public SkLinearBitmapPipeline::DestinationInterface {
 public:
     RGBA8888UnitRepeatSrc(const uint32_t* src, int32_t width)
         : fSrc{src}, fWidth{width} { }
@@ skipping 397 matching lines @@
 void SkLinearBitmapPipeline::blitSpan(int x, int y, void* dst, int count) {
     SkASSERT(count > 0);
     fLastStage->setDestination(dst, 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(Span{{x + 0.5f, y + 0.5f}, count - 1.0f, count});
 }