centralize VECTORCALL as SK_VECTORCALL

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>
@@ skipping 74 matching lines @@
 public:
     template <typename... Args>
     MatrixStage(Next* next, Args&&... args)
         : fNext{next}
         , fStrategy{std::forward<Args>(args)...}{ }
 
     MatrixStage(Next* next, const MatrixStage& stage)
         : fNext{next}
         , fStrategy{stage.fStrategy} { }
 
-    void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
+    void SK_VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
         fStrategy.processPoints(&xs, &ys);
         fNext->pointListFew(n, xs, ys);
     }
 
-    void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
+    void SK_VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
         fStrategy.processPoints(&xs, &ys);
         fNext->pointList4(xs, ys);
     }
 
     // The span you pass must not be empty.
     void pointSpan(Span span) override {
         SkASSERT(!span.isEmpty());
         if (!fStrategy.maybeProcessSpan(span, fNext)) {
             span_fallback(span, this);
         }
@@ skipping 60 matching lines @@
     NearestTileStage(Next* next, SkISize dimensions)
         : fNext{next}
         , fXStrategy{dimensions.width()}
         , fYStrategy{dimensions.height()}{ }
 
     NearestTileStage(Next* next, const NearestTileStage& stage)
         : fNext{next}
         , fXStrategy{stage.fXStrategy}
         , fYStrategy{stage.fYStrategy} { }
 
-    void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
+    void SK_VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
         fXStrategy.tileXPoints(&xs);
         fYStrategy.tileYPoints(&ys);
         fNext->pointListFew(n, xs, ys);
     }
 
-    void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
+    void SK_VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
         fXStrategy.tileXPoints(&xs);
         fYStrategy.tileYPoints(&ys);
         fNext->pointList4(xs, ys);
     }
 
     // The span you pass must not be empty.
     void pointSpan(Span span) override {
         SkASSERT(!span.isEmpty());
         SkPoint start; SkScalar length; int count;
         std::tie(start, length, count) = span;
@@ skipping 22 matching lines @@
         , fXStrategy{dimensions.width()}
         , fYStrategy{dimensions.height()} { }
 
     BilerpTileStage(Next* next, const BilerpTileStage& stage)
         : fNext{next}
         , fXMax{stage.fXMax}
         , fYMax{stage.fYMax}
         , fXStrategy{stage.fXStrategy}
         , fYStrategy{stage.fYStrategy} { }
 
-    void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
+    void SK_VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
         fXStrategy.tileXPoints(&xs);
         fYStrategy.tileYPoints(&ys);
         // TODO: check to see if xs and ys are in range then just call pointListFew on next.
         if (n >= 1) this->bilerpPoint(xs[0], ys[0]);
         if (n >= 2) this->bilerpPoint(xs[1], ys[1]);
         if (n >= 3) this->bilerpPoint(xs[2], ys[2]);
     }
 
-    void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
+    void SK_VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
         fXStrategy.tileXPoints(&xs);
         fYStrategy.tileYPoints(&ys);
         // TODO: check to see if xs and ys are in range then just call pointList4 on next.
         this->bilerpPoint(xs[0], ys[0]);
         this->bilerpPoint(xs[1], ys[1]);
         this->bilerpPoint(xs[2], ys[2]);
         this->bilerpPoint(xs[3], ys[3]);
     }
 
     struct Wrapper {
@@ skipping 164 matching lines @@
 
 // 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} { }
 
-    void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
+    void SK_VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
         SkASSERT(fDest + n <= fEnd);
         // At this point xs and ys should be >= 0, so trunc is the same as floor.
         Sk4i iXs = SkNx_cast<int>(xs);
         Sk4i iYs = SkNx_cast<int>(ys);
 
         if (n >= 1) *fDest++ = *this->pixelAddress(iXs[0], iYs[0]);
         if (n >= 2) *fDest++ = *this->pixelAddress(iXs[1], iYs[1]);
         if (n >= 3) *fDest++ = *this->pixelAddress(iXs[2], iYs[2]);
     }
 
-    void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
+    void SK_VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
         SkASSERT(fDest + 4 <= fEnd);
         Sk4i iXs = SkNx_cast<int>(xs);
         Sk4i iYs = SkNx_cast<int>(ys);
         *fDest++ = *this->pixelAddress(iXs[0], iYs[0]);
         *fDest++ = *this->pixelAddress(iXs[1], iYs[1]);
         *fDest++ = *this->pixelAddress(iXs[2], iYs[2]);
         *fDest++ = *this->pixelAddress(iXs[3], iYs[3]);
     }
 
     void pointSpan(Span span) override {
@@ skipping 14 matching lines @@
         int32_t y = SkScalarTruncToInt(span.startY());
         const uint32_t* src = this->pixelAddress(x, y);
         uint32_t* dest = fDest;
         while (repeatCount --> 0) {
             memmove(dest, src, span.count() * sizeof(uint32_t));
             dest += span.count();
         }
         fDest = dest;
     }
 
-    void VECTORCALL bilerpEdge(Sk4s xs, Sk4s ys) override { SkFAIL("Not Implemented"); }
+    void SK_VECTORCALL bilerpEdge(Sk4s xs, Sk4s ys) override { SkFAIL("Not Implemented"); }
 
     void bilerpSpan(Span span, SkScalar y) override { SkFAIL("Not Implemented"); }
 
     void setDestination(void* dst, int count) override  {
         fDest = static_cast<uint32_t*>(dst);
         fEnd = fDest + count;
     }
 
 private:
     const uint32_t* pixelAddress(int32_t x, int32_t y) {
         return &fSrc[fWidth * y + x];
     }
     const uint32_t* const fSrc;
     const int32_t         fWidth;
     uint32_t*             fDest;
     uint32_t*             fEnd;
 };
 
 // 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 RGBA8888UnitRepeatSrcOver final : public SkLinearBitmapPipeline::SampleProcessorInterface,
                                         public SkLinearBitmapPipeline::DestinationInterface {
 public:
     RGBA8888UnitRepeatSrcOver(const uint32_t* src, int32_t width)
         : fSrc{src}, fWidth{width} { }
 
-    void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
+    void SK_VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
         SkASSERT(fDest + n <= fEnd);
         // At this point xs and ys should be >= 0, so trunc is the same as floor.
         Sk4i iXs = SkNx_cast<int>(xs);
         Sk4i iYs = SkNx_cast<int>(ys);
 
         if (n >= 1) blendPixelAt(iXs[0], iYs[0]);
         if (n >= 2) blendPixelAt(iXs[1], iYs[1]);
         if (n >= 3) blendPixelAt(iXs[2], iYs[2]);
     }
 
-    void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
+    void SK_VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
         SkASSERT(fDest + 4 <= fEnd);
         Sk4i iXs = SkNx_cast<int>(xs);
         Sk4i iYs = SkNx_cast<int>(ys);
         blendPixelAt(iXs[0], iYs[0]);
         blendPixelAt(iXs[1], iYs[1]);
         blendPixelAt(iXs[2], iYs[2]);
         blendPixelAt(iXs[3], iYs[3]);
     }
 
     void pointSpan(Span span) override {
@@ skipping 11 matching lines @@
         int32_t y = (int32_t)span.startY();
         const uint32_t* beginSpan = this->pixelAddress(x, y);
 
         SkOpts::srcover_srgb_srgb(fDest, beginSpan, span.count() * repeatCount, span.count());
 
         fDest += span.count() * repeatCount;
 
         SkASSERT(fDest <= fEnd);
     }
 
-    void VECTORCALL bilerpEdge(Sk4s xs, Sk4s ys) override { SkFAIL("Not Implemented"); }
+    void SK_VECTORCALL bilerpEdge(Sk4s xs, Sk4s ys) override { SkFAIL("Not Implemented"); }
 
     void bilerpSpan(Span span, SkScalar y) override { SkFAIL("Not Implemented"); }
 
     void setDestination(void* dst, int count) override  {
         SkASSERT(count > 0);
         fDest = static_cast<uint32_t*>(dst);
         fEnd = fDest + count;
     }
 
 private:
@@ skipping 89 matching lines @@
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Pixel Blender Stage
 template <SkAlphaType alphaType>
 class SrcFPPixel final : public SkLinearBitmapPipeline::BlendProcessorInterface {
 public:
     SrcFPPixel(float postAlpha) : fPostAlpha{postAlpha} { }
     SrcFPPixel(const SrcFPPixel& Blender) : fPostAlpha(Blender.fPostAlpha) {}
-    void VECTORCALL blendPixel(Sk4f pixel) override {
+    void SK_VECTORCALL blendPixel(Sk4f pixel) override {
         SkASSERT(fDst + 1 <= fEnd );
         SrcPixel(fDst, pixel, 0);
         fDst += 1;
     }
 
-    void VECTORCALL blend4Pixels(Sk4f p0, Sk4f p1, Sk4f p2, Sk4f p3) override {
+    void SK_VECTORCALL blend4Pixels(Sk4f p0, Sk4f p1, Sk4f p2, Sk4f p3) override {
         SkASSERT(fDst + 4 <= fEnd);
         SkPM4f* dst = fDst;
         SrcPixel(dst, p0, 0);
         SrcPixel(dst, p1, 1);
         SrcPixel(dst, p2, 2);
         SrcPixel(dst, p3, 3);
         fDst += 4;
     }
 
     void setDestination(void* dst, int count) override {
         fDst = static_cast<SkPM4f*>(dst);
         fEnd = fDst + count;
     }
 
 private:
-    void VECTORCALL SrcPixel(SkPM4f* dst, Sk4f pixel, int index) {
+    void SK_VECTORCALL SrcPixel(SkPM4f* dst, Sk4f pixel, int index) {
         Sk4f newPixel = pixel;
         if (alphaType == kUnpremul_SkAlphaType) {
             newPixel = Premultiply(pixel);
         }
         newPixel = newPixel * fPostAlpha;
         newPixel.store(dst + index);
     }
-    static Sk4f VECTORCALL Premultiply(Sk4f pixel) {
+    static Sk4f SK_VECTORCALL Premultiply(Sk4f pixel) {
         float alpha = pixel[3];
         return pixel * Sk4f{alpha, alpha, alpha, 1.0f};
     }
 
     SkPM4f* fDst;
     SkPM4f* fEnd;
     Sk4f fPostAlpha;
 };
 
 static SkLinearBitmapPipeline::BlendProcessorInterface* choose_blender_for_shading(
@@ skipping 129 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});
 }