Better encapsulation and vector calling convention.

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
+     #define VECTORCALL __vectorcall
+ #elif defined(SK_CPU_ARM32) && defined(SK_ARM_HAS_NEON)
+     #define VECTORCALL __attribute__((pcs("aapcs-vfp")))
+ #else
+     #define VECTORCALL
+ #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;
+
+    // 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.
+    // * The mirror tiler can produce spans with negative length. This indicates that the source
+    //   should be traversed in the opposite direction to the destination pixels.
+    virtual void pointSpan(SkPoint start, SkScalar length, int count) = 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(Sk4f xs, Sk4f 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;}
 private:
     float fVal;
 };
 
@@ skipping 34 matching lines @@
 //   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 {
+class PointProcessor final : public SkLinearBitmapPipeline::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 {
+    void VECTORCALL pointListFew(int n, Sk4f xs, Sk4f ys) override {
         Sk4f newXs = xs;
         Sk4f newYs = ys;

[f(malita), 2016/02/22 22:48:08]

Are the locals still needed?

[mtklein, 2016/02/22 23:00:55]

Nope.

         fStrategy.processPoints(&newXs, &newYs);
         fNext->pointListFew(n, newXs, newYs);
     }
 
-    void pointList4(Sk4fArg xs, Sk4fArg ys) override {
+    void VECTORCALL pointList4(Sk4f xs, Sk4f 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 {
         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  {
+class BilerpProcessor final : public SkLinearBitmapPipeline::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 {
+    void VECTORCALL pointListFew(int n, Sk4f xs, Sk4f ys) override {
         Sk4f newXs = xs;
         Sk4f newYs = ys;
         fStrategy.processPoints(&newXs, &newYs);
         fNext->pointListFew(n, newXs, newYs);
     }
 
-    void pointList4(Sk4fArg xs, Sk4fArg ys) override {
+    void VECTORCALL pointList4(Sk4f xs, Sk4f ys) override {
         Sk4f newXs = xs;
         Sk4f newYs = ys;
         fStrategy.processPoints(&newXs, &newYs);
         fNext->pointList4(newXs, newYs);
     }
 
-    void bilerpList(Sk4fArg xs, Sk4fArg ys) override {
+    void VECTORCALL bilerpList(Sk4f xs, Sk4f 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 {
         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 {
+class SkippedStage final : public SkLinearBitmapPipeline::BilerpProcessorInterface {
+    void VECTORCALL pointListFew(int n, Sk4f xs, Sk4f ys) override {
         SkFAIL("Skipped stage.");
     }
-    void pointList4(Sk4fArg Xs, Sk4fArg Ys) override {
+    void VECTORCALL pointList4(Sk4f Xs, Sk4f Ys) override {
         SkFAIL("Skipped stage.");
     }
-    void bilerpList(Sk4fArg xs, Sk4fArg ys) override {
+    void VECTORCALL bilerpList(Sk4f xs, Sk4f 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>
+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) {
         *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>
+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;
 
         *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>
+template <typename Next = SkLinearBitmapPipeline::PointProcessorInterface>
 using AffineMatrix = PointProcessor<AffineMatrixStrategy, Next>;
 
-static PointProcessorInterface* choose_matrix(
-    PointProcessorInterface* next,
+static SkLinearBitmapPipeline::PointProcessorInterface* choose_matrix(
+    SkLinearBitmapPipeline::PointProcessorInterface* next,
     const SkMatrix& inverse,
     SkLinearBitmapPipeline::MatrixStage* matrixProc) {
     if (inverse.hasPerspective()) {
         SkFAIL("Not implemented.");
     } else if (inverse.getSkewX() != 0.0f || inverse.getSkewY() != 0.0f) {
         matrixProc->Initialize<AffineMatrix<>>(
             next,
             SkVector{inverse.getTranslateX(), inverse.getTranslateY()},
             SkVector{inverse.getScaleX(), inverse.getScaleY()},
             SkVector{inverse.getSkewX(), inverse.getSkewY()});
     } else if (inverse.getScaleX() != 1.0f || inverse.getScaleY() != 1.0f) {
         matrixProc->Initialize<ScaleMatrix<>>(
             next,
             SkVector{inverse.getTranslateX(), inverse.getTranslateY()},
             SkVector{inverse.getScaleX(), inverse.getScaleY()});
     } else if (inverse.getTranslateX() != 0.0f || inverse.getTranslateY() != 0.0f) {
         matrixProc->Initialize<TranslateMatrix<>>(
             next,
             SkVector{inverse.getTranslateX(), inverse.getTranslateY()});
     } else {
         matrixProc->Initialize<SkippedStage>();
         return next;
     }
     return matrixProc->get();
 }
 
-template <typename Next = BilerpProcessorInterface>
-class ExpandBilerp final : public PointProcessorInterface {
+template <typename Next = SkLinearBitmapPipeline::BilerpProcessorInterface>
+class ExpandBilerp final : public SkLinearBitmapPipeline::PointProcessorInterface {
 public:
     ExpandBilerp(Next* next) : fNext{next} { }
 
-    void pointListFew(int n, Sk4fArg xs, Sk4fArg ys) override {
+    void VECTORCALL pointListFew(int n, Sk4f xs, Sk4f ys) override {
         SkASSERT(0 < n && n < 4);
         //                    px00   px10   px01  px11
         const Sk4f 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);
     }
 
-    void pointList4(Sk4fArg xs, Sk4fArg ys) override {
+    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);
     }
 
     void pointSpan(SkPoint start, SkScalar length, int count) override {
         span_fallback(start, length, count, this);
     }
 
 private:
     Next* const fNext;
 };
 
-static PointProcessorInterface* choose_filter(
-    BilerpProcessorInterface* next,
+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();
     }
 }
@@ skipping 21 matching lines @@
     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>
+template <typename Next = SkLinearBitmapPipeline::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)}
@@ skipping 13 matching lines @@
         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>
+template <typename Next = SkLinearBitmapPipeline::BilerpProcessorInterface>
 using Repeat = BilerpProcessor<RepeatStrategy, Next>;
 
-static BilerpProcessorInterface* choose_tiler(
-    BilerpProcessorInterface* next,
+static SkLinearBitmapPipeline::BilerpProcessorInterface* choose_tiler(
+    SkLinearBitmapPipeline::BilerpProcessorInterface* next,
     SkSize dimensions,
     SkShader::TileMode xMode,
     SkShader::TileMode yMode,
     SkLinearBitmapPipeline::TileStage* tileProcXOrBoth,
     SkLinearBitmapPipeline::TileStage* tileProcY) {
     if (xMode == yMode) {
         switch (xMode) {
             case SkShader::kClamp_TileMode:
                 tileProcXOrBoth->Initialize<Clamp<>>(next, dimensions);
                 break;
@@ skipping 27 matching lines @@
             case SkShader::kMirror_TileMode:
                 SkFAIL("Not implemented.");
                 break;
         }
     }
     return tileProcXOrBoth->get();
 }
 
 class sRGBFast {
 public:
-    static Sk4f sRGBToLinear(Sk4fArg pixel) {
+    static Sk4f VECTORCALL sRGBToLinear(Sk4f pixel) {
         Sk4f l = pixel * pixel;
         return Sk4f{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 getFewPixels(int n, Sk4fArg xs, Sk4fArg ys, Sk4f* px0, Sk4f* px1, Sk4f* px2) {
+    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);
         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 get4Pixels(Sk4fArg xs, Sk4fArg ys, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) {
+    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);
         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]; }
@@ skipping 25 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 bilerp4(Sk4fArg xs, Sk4fArg ys, Sk4fArg px00, Sk4fArg px10,
-                                            Sk4fArg px01, Sk4fArg px11) {
+static Sk4f VECTORCALL bilerp4(Sk4f xs, Sk4f 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};
     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 BilerpProcessorInterface {
+class Sampler final : public SkLinearBitmapPipeline::BilerpProcessorInterface {
 public:
     template <typename... Args>
-    Sampler(PixelPlacerInterface* next, Args&&... args)
+    Sampler(SkLinearBitmapPipeline::PixelPlacerInterface* next, Args&&... args)
         : fNext{next}
         , fStrategy{std::forward<Args>(args)...} { }
 
-    void pointListFew(int n, Sk4fArg xs, Sk4fArg ys) override {
+    void VECTORCALL pointListFew(int n, Sk4f xs, Sk4f 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 pointList4(Sk4fArg xs, Sk4fArg ys) override {
+    void VECTORCALL pointList4(Sk4f xs, Sk4f ys) override {
         Sk4f px0, px1, px2, px3;
         fStrategy.get4Pixels(xs, ys, &px0, &px1, &px2, &px3);
         fNext->place4Pixels(px0, px1, px2, px3);
     }
 
-    void bilerpList(Sk4fArg xs, Sk4fArg ys) override {
+    void VECTORCALL bilerpList(Sk4f xs, Sk4f 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);
     }
 
 private:
-    PixelPlacerInterface* const fNext;
+    SkLinearBitmapPipeline::PixelPlacerInterface* const fNext;
     SourceStrategy fStrategy;
 };
 
-static BilerpProcessorInterface* choose_pixel_sampler(
-    PixelPlacerInterface* next,
+static SkLinearBitmapPipeline::BilerpProcessorInterface* choose_pixel_sampler(
+    SkLinearBitmapPipeline::PixelPlacerInterface* next,
     const SkPixmap& srcPixmap,
     SkLinearBitmapPipeline::SampleStage* sampleStage) {
     const SkImageInfo& imageInfo = srcPixmap.info();
     switch (imageInfo.colorType()) {
         case kRGBA_8888_SkColorType:
         case kBGRA_8888_SkColorType:
             if (kN32_SkColorType == imageInfo.colorType()) {
                 if (imageInfo.profileType() == kSRGB_SkColorProfileType) {
                     sampleStage->Initialize<Sampler<Passthrough8888<kSRGB_SkColorProfileType>>>(
                         next, static_cast<int>(srcPixmap.rowBytes() / 4),
                         srcPixmap.addr32());
                 } else {
                     sampleStage->Initialize<Sampler<Passthrough8888<kLinear_SkColorProfileType>>>(
                         next, static_cast<int>(srcPixmap.rowBytes() / 4),
                         srcPixmap.addr32());
                 }
             } else {
                 SkFAIL("Not implemented. No 8888 Swizzle");
             }
             break;
         default:
             SkFAIL("Not implemented. Unsupported src");
             break;
     }
     return sampleStage->get();
 }
 
 template <SkAlphaType alphaType>
-class PlaceFPPixel final : public PixelPlacerInterface {
+class PlaceFPPixel final : public SkLinearBitmapPipeline::PixelPlacerInterface {
 public:
-    void placePixel(Sk4fArg pixel) override {
+    void VECTORCALL placePixel(Sk4f pixel) override {
         PlacePixel(fDst, pixel, 0);
         fDst += 1;
     }
 
-    void place4Pixels(Sk4fArg p0, Sk4fArg p1, Sk4fArg p2, Sk4fArg p3) override {
+    void VECTORCALL place4Pixels(Sk4f p0, Sk4f p1, Sk4f p2, Sk4f p3) override {
         SkPM4f* dst = fDst;
         PlacePixel(dst, p0, 0);
         PlacePixel(dst, p1, 1);
         PlacePixel(dst, p2, 2);
         PlacePixel(dst, p3, 3);
         fDst += 4;
     }
 
     void setDestination(SkPM4f* dst) override {
         fDst = dst;
     }
 
 private:
-    static void PlacePixel(SkPM4f* dst, Sk4fArg pixel, int index) {
+    static void VECTORCALL PlacePixel(SkPM4f* dst, Sk4f pixel, int index) {
         Sk4f newPixel = pixel;
         if (alphaType == kUnpremul_SkAlphaType) {
             newPixel = Premultiply(pixel);
         }
         newPixel.store(dst + index);
     }
-    static Sk4f Premultiply(Sk4fArg pixel) {
+    static Sk4f VECTORCALL Premultiply(Sk4f pixel) {
         float alpha = pixel[3];
         return pixel * Sk4f{alpha, alpha, alpha, 1.0f};
     }
 
     SkPM4f* fDst;
 };
 
-static PixelPlacerInterface* choose_pixel_placer(
+static SkLinearBitmapPipeline::PixelPlacerInterface* choose_pixel_placer(
     SkAlphaType alphaType,
     SkLinearBitmapPipeline::PixelStage* placerStage) {
     if (alphaType == kUnpremul_SkAlphaType) {
         placerStage->Initialize<PlaceFPPixel<kUnpremul_SkAlphaType>>();
     } else {
         // kOpaque_SkAlphaType is treated the same as kPremul_SkAlphaType
         placerStage->Initialize<PlaceFPPixel<kPremul_SkAlphaType>>();
     }
     return placerStage->get();
 }
+}  // namespace
+
+SkLinearBitmapPipeline::~SkLinearBitmapPipeline() {}
 
 SkLinearBitmapPipeline::SkLinearBitmapPipeline(
     const SkMatrix& inverse,
     SkFilterQuality filterQuality,
     SkShader::TileMode xTile, SkShader::TileMode yTile,
     const SkPixmap& srcPixmap) {
     SkSize size = SkSize::Make(srcPixmap.width(), srcPixmap.height());
     const SkImageInfo& srcImageInfo = srcPixmap.info();
 
     // As the stages are built, the chooser function may skip a stage. For example, with the
@@ skipping 13 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);
     }
 }