Add clone to Stage. Rename place to mix and PolymorphicUnion to Stage. Cleanup.

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 47 matching lines @@
     // 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() { }
-    virtual void setDestination(void* dst, int count) = 0;
-};
-
-class SkLinearBitmapPipeline::PixelPlacerInterface
-    : public SkLinearBitmapPipeline::DestinationInterface {
-public:
-    virtual ~PixelPlacerInterface() { }
     // 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;
-    virtual void VECTORCALL placePixel(Sk4f pixel0) = 0;
-    virtual void VECTORCALL place4Pixels(Sk4f p0, Sk4f p1, Sk4f p2, Sk4f p3) = 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>
+template<typename Variant, typename... Args>
+void SkLinearBitmapPipeline::Stage<Base, kSize, Next>::initStage(Next* next, Args&& ... args) {
+    SkASSERTF(sizeof(Variant) <= sizeof(fSpace),
+              "Size Variant: %d, Space: %d", sizeof(Variant), sizeof(fSpace));
+
+    new (&fSpace) Variant(next, std::forward<Args>(args)...);
+    fStageCloner = [this](Next* nextClone, void* addr) {
+        new (addr) Variant(nextClone, (const Variant&)*this->get());
+    };
+    fIsInitialized = true;
+};
+
+template<typename Base, size_t kSize, typename Next>
+template<typename Variant, typename... Args>
+void SkLinearBitmapPipeline::Stage<Base, kSize, Next>::initSink(Args&& ... args) {
+    SkASSERTF(sizeof(Variant) <= sizeof(fSpace),
+              "Size Variant: %d, Space: %d", sizeof(Variant), sizeof(fSpace));
+    new (&fSpace) Variant(std::forward<Args>(args)...);
+    fIsInitialized = true;
+};
+
+template<typename Base, size_t kSize, typename Next>
+template <typename To, typename From>
+To* SkLinearBitmapPipeline::Stage<Base, kSize, Next>::getInterface() {
+    From* down = static_cast<From*>(this->get());
+    return static_cast<To*>(down);
+}
+
+template<typename Base, size_t kSize, typename Next>
+Base* SkLinearBitmapPipeline::Stage<Base, kSize, Next>::cloneStageTo(
+    Next* next, Stage* cloneToStage) const
+{
+    if (!fIsInitialized) return nullptr;
+    fStageCloner(next, &cloneToStage->fSpace);
+    return cloneToStage->get();
+}
+
 namespace  {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Matrix Stage
 // 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(span, next) - This represents a horizontal series of pixels
 //   to work over.
 //   span - encapsulation of span.
 //   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 MatrixStage final : public SkLinearBitmapPipeline::PointProcessorInterface {
 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 {
         fStrategy.processPoints(&xs, &ys);
         fNext->pointListFew(n, xs, ys);
     }
 
     void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
         fStrategy.processPoints(&xs, &ys);
         fNext->pointList4(xs, ys);
     }
 
@@ skipping 21 matching lines @@
 
 template <typename Next = SkLinearBitmapPipeline::PointProcessorInterface>
 using PerspectiveMatrix = MatrixStage<PerspectiveMatrixStrategy, Next>;
 
 
 static SkLinearBitmapPipeline::PointProcessorInterface* choose_matrix(
     SkLinearBitmapPipeline::PointProcessorInterface* next,
     const SkMatrix& inverse,
     SkLinearBitmapPipeline::MatrixStage* matrixProc) {
     if (inverse.hasPerspective()) {
-        matrixProc->Initialize<PerspectiveMatrix<>>(
+        matrixProc->initStage<PerspectiveMatrix<>>(
             next,
             SkVector{inverse.getTranslateX(), inverse.getTranslateY()},
             SkVector{inverse.getScaleX(), inverse.getScaleY()},
             SkVector{inverse.getSkewX(), inverse.getSkewY()},
             SkVector{inverse.getPerspX(), inverse.getPerspY()},
             inverse.get(SkMatrix::kMPersp2));
     } else if (inverse.getSkewX() != 0.0f || inverse.getSkewY() != 0.0f) {
-        matrixProc->Initialize<AffineMatrix<>>(
+        matrixProc->initStage<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<>>(
+        matrixProc->initStage<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<>>(
+        matrixProc->initStage<TranslateMatrix<>>(
             next,
             SkVector{inverse.getTranslateX(), inverse.getTranslateY()});
     } else {
         return next;
     }
     return matrixProc->get();
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Tile Stage
 
 template<typename XStrategy, typename YStrategy, typename Next>
 class NearestTileStage final : public SkLinearBitmapPipeline::PointProcessorInterface {
 public:
     template <typename... Args>
     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 {
         fXStrategy.tileXPoints(&xs);
         fYStrategy.tileYPoints(&ys);
         fNext->pointListFew(n, xs, ys);
     }
 
     void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
         fXStrategy.tileXPoints(&xs);
         fYStrategy.tileYPoints(&ys);
         fNext->pointList4(xs, ys);
@@ skipping 16 matching lines @@
     Next* const fNext;
     XStrategy fXStrategy;
     YStrategy fYStrategy;
 };
 
 template<typename XStrategy, typename YStrategy, typename Next>
 class BilerpTileStage final : public SkLinearBitmapPipeline::PointProcessorInterface {
 public:
     template <typename... Args>
     BilerpTileStage(Next* next, SkISize dimensions)
-        : fXMax(dimensions.width())
+        : fNext{next}
+        , fXMax(dimensions.width())
         , fYMax(dimensions.height())
-        , fNext{next}
         , fXStrategy{dimensions.width()}
-        , fYStrategy{dimensions.height()}{ }
+        , 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 {
         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]);
     }
 
@@ skipping 96 matching lines @@
                     this->yProcessSpan(center);
                 }
                 if (!leftEdge.isEmpty()) {
                     this->handleEdges(leftEdge, dx);
                 }
 
             }
         }
     }
 
+    Next* const fNext;
     SkScalar fXMax;
     SkScalar fYMax;
-    Next* const fNext;
     XStrategy fXStrategy;
     YStrategy fYStrategy;
 };
 
 template <typename XStrategy, typename YStrategy, typename Next>
 void make_tile_stage(
     SkFilterQuality filterQuality, SkISize dimensions,
     Next* next, SkLinearBitmapPipeline::TileStage* tileStage) {
     if (filterQuality == kNone_SkFilterQuality) {
-        tileStage->Initialize<NearestTileStage<XStrategy, YStrategy, Next>>(next, dimensions);
+        tileStage->initStage<NearestTileStage<XStrategy, YStrategy, Next>>(next, dimensions);
     } else {
-        tileStage->Initialize<BilerpTileStage<XStrategy, YStrategy, Next>>(next, dimensions);
+        tileStage->initStage<BilerpTileStage<XStrategy, YStrategy, Next>>(next, dimensions);
     }
 }
 template <typename XStrategy>
 void choose_tiler_ymode(
     SkShader::TileMode yMode, SkFilterQuality filterQuality, SkISize dimensions,
     SkLinearBitmapPipeline::SampleProcessorInterface* next,
     SkLinearBitmapPipeline::TileStage* tileStage) {
     switch (yMode) {
         case SkShader::kClamp_TileMode:
             make_tile_stage<XStrategy, YClampStrategy>(filterQuality, dimensions, next, tileStage);
@@ skipping 39 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Source Sampling Stage
 template <typename SourceStrategy, 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);
@@ skipping 18 matching lines @@
     GeneralSampler<SourceStrategy, Next> fSampler;
 };
 
 template <typename SourceStrategy, 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);
@@ skipping 83 matching lines @@
 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;
 };
 
-using Placer = SkLinearBitmapPipeline::PixelPlacerInterface;
+using Blender = SkLinearBitmapPipeline::BlendProcessorInterface;
 
 template<template <typename, typename> class Sampler>
 static SkLinearBitmapPipeline::SampleProcessorInterface* choose_pixel_sampler_base(
-    Placer* next,
+    Blender* next,
     const SkPixmap& srcPixmap,
     SkLinearBitmapPipeline::SampleStage* sampleStage) {
     const SkImageInfo& imageInfo = srcPixmap.info();
     switch (imageInfo.colorType()) {
         case kRGBA_8888_SkColorType:
             if (imageInfo.profileType() == kSRGB_SkColorProfileType) {
-                sampleStage->Initialize<Sampler<Pixel8888SRGB, Placer>>(next, srcPixmap);
+                sampleStage->initStage<Sampler<Pixel8888SRGB, Blender>>(next, srcPixmap);
             } else {
-                sampleStage->Initialize<Sampler<Pixel8888LRGB, Placer>>(next, srcPixmap);
+                sampleStage->initStage<Sampler<Pixel8888LRGB, Blender>>(next, srcPixmap);
             }
             break;
         case kBGRA_8888_SkColorType:
             if (imageInfo.profileType() == kSRGB_SkColorProfileType) {
-                sampleStage->Initialize<Sampler<Pixel8888SBGR, Placer>>(next, srcPixmap);
+                sampleStage->initStage<Sampler<Pixel8888SBGR, Blender>>(next, srcPixmap);
             } else {
-                sampleStage->Initialize<Sampler<Pixel8888LBGR, Placer>>(next, srcPixmap);
+                sampleStage->initStage<Sampler<Pixel8888LBGR, Blender>>(next, srcPixmap);
             }
             break;
         case kIndex_8_SkColorType:
             if (imageInfo.profileType() == kSRGB_SkColorProfileType) {
-                sampleStage->Initialize<Sampler<PixelIndex8SRGB, Placer>>(next, srcPixmap);
+                sampleStage->initStage<Sampler<PixelIndex8SRGB, Blender>>(next, srcPixmap);
             } else {
-                sampleStage->Initialize<Sampler<PixelIndex8LRGB, Placer>>(next, srcPixmap);
+                sampleStage->initStage<Sampler<PixelIndex8LRGB, Blender>>(next, srcPixmap);
             }
             break;
         default:
             SkFAIL("Not implemented. Unsupported src");
             break;
     }
     return sampleStage->get();
 }
 
 SkLinearBitmapPipeline::SampleProcessorInterface* choose_pixel_sampler(
-    Placer* next,
+    Blender* next,
     SkFilterQuality filterQuality,
     const SkPixmap& srcPixmap,
-    SkLinearBitmapPipeline::SampleStage* sampleStage) {
+    SkLinearBitmapPipeline::SampleStage* sampleStage)
+{
     if (filterQuality == kNone_SkFilterQuality) {
         return choose_pixel_sampler_base<NearestNeighborSampler>(next, srcPixmap, sampleStage);
     } else {
         return choose_pixel_sampler_base<BilerpSampler>(next, srcPixmap, sampleStage);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-// Pixel Placement Stage
+// Pixel Blender Stage
 template <SkAlphaType alphaType>
-class PlaceFPPixel final : public SkLinearBitmapPipeline::PixelPlacerInterface {
+class SrcFPPixel final : public SkLinearBitmapPipeline::BlendProcessorInterface {
 public:
-    PlaceFPPixel(float postAlpha) : fPostAlpha{postAlpha} { }
-
-    void VECTORCALL placePixel(Sk4f pixel) override {
+    SrcFPPixel(float postAlpha) : fPostAlpha{postAlpha} { }
+    SrcFPPixel(const SrcFPPixel& Blender) : fPostAlpha(Blender.fPostAlpha) {}
+    void VECTORCALL blendPixel(Sk4f pixel) override {
         SkASSERT(fDst + 1 <= fEnd );
-        PlacePixel(fDst, pixel, 0);
+        SrcPixel(fDst, pixel, 0);
         fDst += 1;
     }
 
-    void VECTORCALL place4Pixels(Sk4f p0, Sk4f p1, Sk4f p2, Sk4f p3) override {
+    void VECTORCALL blend4Pixels(Sk4f p0, Sk4f p1, Sk4f p2, Sk4f p3) override {
         SkASSERT(fDst + 4 <= fEnd);
         SkPM4f* dst = fDst;
-        PlacePixel(dst, p0, 0);
-        PlacePixel(dst, p1, 1);
-        PlacePixel(dst, p2, 2);
-        PlacePixel(dst, p3, 3);
+        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 PlacePixel(SkPM4f* dst, Sk4f pixel, int index) {
+    void 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) {
         float alpha = pixel[3];
         return pixel * Sk4f{alpha, alpha, alpha, 1.0f};
     }
 
     SkPM4f* fDst;
     SkPM4f* fEnd;
     Sk4f fPostAlpha;
 };
 
-static SkLinearBitmapPipeline::PixelPlacerInterface* choose_pixel_placer(
+static SkLinearBitmapPipeline::BlendProcessorInterface* choose_blender(
     SkAlphaType alphaType,
     float postAlpha,
-    SkLinearBitmapPipeline::PixelStage* placerStage) {
+    SkLinearBitmapPipeline::BlenderStage* blenderStage) {
     if (alphaType == kUnpremul_SkAlphaType) {
-        placerStage->Initialize<PlaceFPPixel<kUnpremul_SkAlphaType>>(postAlpha);
+        blenderStage->initSink<SrcFPPixel<kUnpremul_SkAlphaType>>(postAlpha);
     } else {
         // kOpaque_SkAlphaType is treated the same as kPremul_SkAlphaType
-        placerStage->Initialize<PlaceFPPixel<kPremul_SkAlphaType>>(postAlpha);
+        blenderStage->initSink<SrcFPPixel<kPremul_SkAlphaType>>(postAlpha);
     }
-    return placerStage->get();
+    return blenderStage->get();
 }
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
+// SkLinearBitmapPipeline
 SkLinearBitmapPipeline::~SkLinearBitmapPipeline() {}
 
 SkLinearBitmapPipeline::SkLinearBitmapPipeline(
     const SkMatrix& inverse,
     SkFilterQuality filterQuality,
     SkShader::TileMode xTile, SkShader::TileMode yTile,
     float postAlpha,
     const SkPixmap& srcPixmap)
 {
     SkISize dimensions = srcPixmap.info().dimensions();
@@ skipping 14 matching lines @@
     SkScalar dx = adjustedInverse.getScaleX();
 
     // If it is an index 8 color type, the sampler converts to unpremul for better fidelity.
     SkAlphaType alphaType = srcImageInfo.alphaType();
     if (srcPixmap.colorType() == kIndex_8_SkColorType) {
         alphaType = kUnpremul_SkAlphaType;
     }
 
     // As the stages are built, the chooser function may skip a stage. For example, with the
     // identity matrix, the matrix stage is skipped, and the tilerStage is the first stage.
-    auto placementStage = choose_pixel_placer(alphaType, postAlpha, &fPixelStage);
-    auto samplerStage   = choose_pixel_sampler(placementStage,
-                                               filterQuality, srcPixmap, &fSampleStage);
-    auto tilerStage     = choose_tiler(samplerStage,
-                                       dimensions, xTile, yTile, filterQuality, dx, &fTiler);
-    fFirstStage         = choose_matrix(tilerStage, adjustedInverse, &fMatrixStage);
-    fLastStage          = placementStage;
-
+    auto blenderStage = choose_blender(alphaType, postAlpha, &fBlenderStage);
+    auto samplerStage = choose_pixel_sampler(blenderStage, filterQuality, srcPixmap, &fSampleStage);
+    auto tilerStage   = choose_tiler(samplerStage, dimensions, xTile, yTile,
+                                     filterQuality, dx, &fTileStage);
+    fFirstStage       = choose_matrix(tilerStage, adjustedInverse, &fMatrixStage);
+    fLastStage        = blenderStage;
 }
 
 void SkLinearBitmapPipeline::shadeSpan4f(int x, int y, SkPM4f* 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});
 }