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

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 34 matching lines @@
     sum = sum + px10 * (fxs - fxys);
     sum = sum + px00 * (Sk4f{1.0f} - fxs - fys + fxys);
     return sum;
 }
 
 // The GeneralSampler class
 template<typename SourceStrategy, typename Next>
 class GeneralSampler {
 public:
     template<typename... Args>
-    GeneralSampler(SkLinearBitmapPipeline::PixelPlacerInterface* next, Args&& ... args)
+    GeneralSampler(SkLinearBitmapPipeline::MixProcessorInterface* next, Args&& ... args)
         : fNext{next}, fStrategy{std::forward<Args>(args)...} { }
 
+    GeneralSampler(SkLinearBitmapPipeline::MixProcessorInterface* next,
+                   const GeneralSampler& sampler)
+        : fNext{next}, fStrategy{sampler.fStrategy} { }
+
     void VECTORCALL nearestListFew(int n, Sk4s xs, Sk4s ys) {
         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);
+        if (n >= 1) fNext->mixPixel(px0);
+        if (n >= 2) fNext->mixPixel(px1);
+        if (n >= 3) fNext->mixPixel(px2);
     }
 
     void VECTORCALL nearestList4(Sk4s xs, Sk4s ys) {
         Sk4f px0, px1, px2, px3;
         fStrategy.get4Pixels(xs, ys, &px0, &px1, &px2, &px3);
-        fNext->place4Pixels(px0, px1, px2, px3);
+        fNext->mix4Pixels(px0, px1, px2, px3);
     }
 
     void nearestSpan(Span span) {
         SkASSERT(!span.isEmpty());
         SkPoint start;
         SkScalar length;
         int count;
         std::tie(start, length, count) = span;
         SkScalar absLength = SkScalarAbs(length);
         if (absLength < (count - 1)) {
@@ skipping 14 matching lines @@
         fStrategy.get4Pixels(sampleXs, sampleYs, &px00, &px10, &px01, &px11);
         return bilerp4(xs, ys, px00, px10, px01, px11);
     }
 
     void VECTORCALL bilerpListFew(int n, Sk4s xs, Sk4s ys) {
         SkASSERT(0 < n && n < 4);
         auto bilerpPixel = [&](int index) {
             return this->bilerNonEdgePixel(xs[index], ys[index]);
         };
 
-        if (n >= 1) fNext->placePixel(bilerpPixel(0));
-        if (n >= 2) fNext->placePixel(bilerpPixel(1));
-        if (n >= 3) fNext->placePixel(bilerpPixel(2));
+        if (n >= 1) fNext->mixPixel(bilerpPixel(0));
+        if (n >= 2) fNext->mixPixel(bilerpPixel(1));
+        if (n >= 3) fNext->mixPixel(bilerpPixel(2));
     }
 
     void VECTORCALL bilerpList4(Sk4s xs, Sk4s ys) {
         auto bilerpPixel = [&](int index) {
             return this->bilerNonEdgePixel(xs[index], ys[index]);
         };
-        fNext->place4Pixels(bilerpPixel(0), bilerpPixel(1), bilerpPixel(2), bilerpPixel(3));
+        fNext->mix4Pixels(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->placePixel(pixel);
+        fNext->mixPixel(pixel);
     }
 
     void bilerpSpan(Span span) {
         this->bilerpSpanWithY(span, span.startY());
     }
 
     void bilerpSpanWithY(Span span, SkScalar y) {
         SkASSERT(!span.isEmpty());
         SkPoint start;
         SkScalar length;
@@ skipping 50 matching lines @@
             fx += fdx;
             ix = SkFixedFloorToInt(fx);
             return fpixel;
         };
 
         while (count >= 4) {
             Sk4f px0 = getNextPixel();
             Sk4f px1 = getNextPixel();
             Sk4f px2 = getNextPixel();
             Sk4f px3 = getNextPixel();
-            next->place4Pixels(px0, px1, px2, px3);
+            next->mix4Pixels(px0, px1, px2, px3);
             count -= 4;
         }
         while (count > 0) {
-            next->placePixel(getNextPixel());
+            next->mixPixel(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) {
         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->place4Pixels(px0, px1, px2, px3);
+                next->mix4Pixels(px0, px1, px2, px3);
                 ix += 4;
                 count -= 4;
             }
 
             while (count > 0) {
-                next->placePixel(fStrategy.getPixelAt(row, ix));
+                next->mixPixel(fStrategy.getPixelAt(row, ix));
                 ix += 1;
                 count -= 1;
             }
         } else {
             while (count >= 4) {
                 Sk4f px0, px1, px2, px3;
                 fStrategy.get4Pixels(row, ix - 3, &px3, &px2, &px1, &px0);
-                next->place4Pixels(px0, px1, px2, px3);
+                next->mix4Pixels(px0, px1, px2, px3);
                 ix -= 4;
                 count -= 4;
             }
 
             while (count > 0) {
-                next->placePixel(fStrategy.getPixelAt(row, ix));
+                next->mixPixel(fStrategy.getPixelAt(row, ix));
                 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 nearestSpanFastRate(Span span) {
         struct NearestWrapper {
@@ skipping 17 matching lines @@
         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.getPixelAt(fStrategy.row(iy0), ix);
         Sk4f pixelY1 = fStrategy.getPixelAt(fStrategy.row(iy1), ix);
         Sk4f filterPixel = pixelY0 * filterY0 + pixelY1 * filterY1;
         int count = span.count();
         while (count >= 4) {
-            fNext->place4Pixels(filterPixel, filterPixel, filterPixel, filterPixel);
+            fNext->mix4Pixels(filterPixel, filterPixel, filterPixel, filterPixel);
             count -= 4;
         }
         while (count > 0) {
-            fNext->placePixel(filterPixel);
+            fNext->mixPixel(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) {
         SkPoint start;
         SkScalar length;
         int count;
@@ skipping 44 matching lines @@
             x = x + dx;
             return fpixel;
         };
 
         while (count >= 4) {
             Sk4f fpixel0 = getNextPixel();
             Sk4f fpixel1 = getNextPixel();
             Sk4f fpixel2 = getNextPixel();
             Sk4f fpixel3 = getNextPixel();
 
-            fNext->place4Pixels(fpixel0, fpixel1, fpixel2, fpixel3);
+            fNext->mix4Pixels(fpixel0, fpixel1, fpixel2, fpixel3);
             count -= 4;
         }
 
         while (count > 0) {
-            fNext->placePixel(getNextPixel());
+            fNext->mixPixel(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) {
         y1 += 0.5f;
         SkScalar y0 = span.startY() - 0.5f;
@@ skipping 49 matching lines @@
                 get4PixelsY1(ix0, &px01, &px11, &px21, &px31);
                 Sk4f pxS0 = px00 + px01;
                 Sk4f px0 = lerp(pxB, pxS0);
                 Sk4f pxS1 = px10 + px11;
                 Sk4f px1 = lerp(pxS0, pxS1);
                 Sk4f pxS2 = px20 + px21;
                 Sk4f px2 = lerp(pxS1, pxS2);
                 Sk4f pxS3 = px30 + px31;
                 Sk4f px3 = lerp(pxS2, pxS3);
                 pxB = pxS3;
-                fNext->place4Pixels(
-                    px0,
-                    px1,
-                    px2,
-                    px3);
+                fNext->mix4Pixels(px0, px1, px2, px3);
                 ix0 += 4;
                 count -= 4;
             }
             while (count > 0) {
                 Sk4f pixelY0 = fStrategy.getPixelAt(rowY0, ix0);
                 Sk4f pixelY1 = fStrategy.getPixelAt(rowY1, ix0);
 
-                fNext->placePixel(lerp(pixelY0, pixelY1));
+                fNext->mixPixel(lerp(pixelY0, pixelY1));
                 ix0 += 1;
                 count -= 1;
             }
         } else {
             int count = span.count();
             while (count >= 4) {
                 Sk4f px00, px10, px20, px30;
                 get4PixelsY0(ix0 - 3, &px00, &px10, &px20, &px30);
                 Sk4f px01, px11, px21, px31;
                 get4PixelsY1(ix0 - 3, &px01, &px11, &px21, &px31);
                 Sk4f pxS3 = px30 + px31;
                 Sk4f px0 = lerp(pxS3, pxB);
                 Sk4f pxS2 = px20 + px21;
                 Sk4f px1 = lerp(pxS2, pxS3);
                 Sk4f pxS1 = px10 + px11;
                 Sk4f px2 = lerp(pxS1, pxS2);
                 Sk4f pxS0 = px00 + px01;
                 Sk4f px3 = lerp(pxS0, pxS1);
                 pxB = pxS0;
-                fNext->place4Pixels(
-                    px0,
-                    px1,
-                    px2,
-                    px3);
+                fNext->mix4Pixels(px0, px1, px2, px3);
                 ix0 -= 4;
                 count -= 4;
             }
             while (count > 0) {
                 Sk4f pixelY0 = fStrategy.getPixelAt(rowY0, ix0);
                 Sk4f pixelY1 = fStrategy.getPixelAt(rowY1, ix0);
 
-                fNext->placePixel(lerp(pixelY0, pixelY1));
+                fNext->mixPixel(lerp(pixelY0, pixelY1));
                 ix0 -= 1;
                 count -= 1;
             }
         }
     }
 
     void bilerpSpanUnitRateAlignedX(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) {
             return *pixelY0 * filterY0 + *pixelY1 * filterY1;
         };
 
         if (span.length() > 0) {
             int count = span.count();
             while (count >= 4) {
                 Sk4f px00, px10, px20, px30;
                 fStrategy.get4Pixels(rowY0, ix, &px00, &px10, &px20, &px30);
                 Sk4f px01, px11, px21, px31;
                 fStrategy.get4Pixels(rowY1, ix, &px01, &px11, &px21, &px31);
-                fNext->place4Pixels(
+                fNext->mix4Pixels(
                     lerp(&px00, &px01), lerp(&px10, &px11), lerp(&px20, &px21), lerp(&px30, &px31));
                 ix += 4;
                 count -= 4;
             }
             while (count > 0) {
                 Sk4f pixelY0 = fStrategy.getPixelAt(rowY0, ix);
                 Sk4f pixelY1 = fStrategy.getPixelAt(rowY1, ix);
 
-                fNext->placePixel(lerp(&pixelY0, &pixelY1));
+                fNext->mixPixel(lerp(&pixelY0, &pixelY1));
                 ix += 1;
                 count -= 1;
             }
         } else {
             int count = span.count();
             while (count >= 4) {
                 Sk4f px00, px10, px20, px30;
                 fStrategy.get4Pixels(rowY0, ix - 3, &px30, &px20, &px10, &px00);
                 Sk4f px01, px11, px21, px31;
                 fStrategy.get4Pixels(rowY1, ix - 3, &px31, &px21, &px11, &px01);
-                fNext->place4Pixels(
+                fNext->mix4Pixels(
                     lerp(&px00, &px01), lerp(&px10, &px11), lerp(&px20, &px21), lerp(&px30, &px31));
                 ix -= 4;
                 count -= 4;
             }
             while (count > 0) {
                 Sk4f pixelY0 = fStrategy.getPixelAt(rowY0, ix);
                 Sk4f pixelY1 = fStrategy.getPixelAt(rowY1, ix);
 
-                fNext->placePixel(lerp(&pixelY0, &pixelY1));
+                fNext->mixPixel(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) {
         SkPoint start;
@@ skipping 119 matching lines @@
         SkASSERT(srcPixmap.colorType() == kIndex_8_SkColorType);
         SkColorTable* skColorTable = srcPixmap.ctable();
         SkASSERT(skColorTable != nullptr);
 
         fColorTable = (Sk4f*)SkAlign16((intptr_t)fColorTableStorage.get());
         for (int i = 0; i < skColorTable->count(); i++) {
             fColorTable[i] = this->convertPixel((*skColorTable)[i]);
         }
     }
 
+    PixelIndex8(const PixelIndex8& strategy)
+        : fSrc{strategy.fSrc}, fWidth{strategy.fWidth} {
+        fColorTable = (Sk4f*)SkAlign16((intptr_t)fColorTableStorage.get());
+        // TODO: figure out the count.
+        for (int i = 0; i < 256; i++) {
+            fColorTable[i] = strategy.fColorTable[i];
+        }
+    }
+
     void VECTORCALL getFewPixels(int n, Sk4s xs, Sk4s ys, Sk4f* px0, Sk4f* px1, Sk4f* px2) {
         Sk4i XIs = SkNx_cast<int, SkScalar>(xs);
         Sk4i YIs = SkNx_cast<int, SkScalar>(ys);
         Sk4i bufferLoc = YIs * fWidth + XIs;
         switch (n) {
             case 3:
                 *px2 = this->getPixelAt(fSrc, bufferLoc[2]);
             case 2:
                 *px1 = this->getPixelAt(fSrc, bufferLoc[1]);
             case 1:
@@ skipping 55 matching lines @@
     SkAutoMalloc         fColorTableStorage{kColorTableSize};
     Sk4f*                fColorTable;
 };
 
 using PixelIndex8SRGB = PixelIndex8<kSRGB_SkColorProfileType>;
 using PixelIndex8LRGB = PixelIndex8<kLinear_SkColorProfileType>;
 
 }  // namespace
 
 #endif  // SkLinearBitmapPipeline_sampler_DEFINED