Simplified linear pipeline.

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"
+
+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;
+};
+
+struct Y {
+    explicit Y(SkScalar val) : fVal{val} { }
+    explicit Y(SkPoint pt) : fVal{pt.fY} { }
+    explicit Y(SkSize s) : fVal{s.fHeight} { }
+    explicit Y(SkISize s) : fVal(s.fHeight) { }
+
+    operator float () const {return fVal;}
+private:
+    float fVal;
+};
+
+template <typename Next>
+void SpanFallback(SkPoint start, SkScalar length, int count, Next* next) {

[mtklein, 2016/02/16 21:13:10]

suspiciously similar to shadeSpan

[herb_g, 2016/02/16 22:04:24]

removed

+    float dx = length / (count - 1);
+
+    Sk4f Xs = Sk4f(X(start)) + Sk4f{0.0f, 1.0f, 2.0f, 3.0f} * Sk4f{dx};
+    Sk4f Ys{Y(start)};
+    Sk4f fours = {4.0f * dx};
+
+    while (count >= 4) {
+        next->pointList4(Xs, Ys);
+        Xs = Xs + fours;
+        count -= 4;
+    }
+    if (count > 0) {
+        next->pointListFew(count, Xs, Ys);
+    }
+}
+
+template<typename Strategy, typename Next>
+class PointProcessor : public PointProcessorInterface {
+public:
+    template <typename... Args>
+    PointProcessor(Next* next, Args&&... args)
+        : fNext{next}
+        , fStrategy{std::forward<Args>(args)...}{ }
+
+    void pointListFew(int n, Sk4f xs, Sk4f ys) override {
+        fStrategy.processPoints(n, &xs, &ys);

[mtklein, 2016/02/16 21:13:10]

it looks like no strategy needs n

[herb_g, 2016/02/16 22:04:25]

Done.

+        fNext->pointListFew(n, xs, ys);
+    }
+
+    void pointList4(Sk4f xs, Sk4f ys) override {
+        fStrategy.processPoints(4, &xs, &ys);

[mtklein, 2016/02/16 21:13:10]

ditto

[herb_g, 2016/02/16 22:04:25]

Done.

+        fNext->pointList4(xs, ys);
+    }
+
+private:
+    Next* const fNext;
+    Strategy fStrategy;
+};
+
+class AbortPointProcessor final : public PointProcessorInterface {

[mtklein, 2016/02/16 21:13:10]

SkippedStage?

[herb_g, 2016/02/16 22:04:24]

Done.

+    void pointListFew(int n, Sk4f x, Sk4f y) override {
+        SkFAIL("Abort tiler.");
+    }
+    void pointList4(Sk4f Xs, Sk4f Ys) override {
+        SkFAIL("Abort point processor.");
+    }
+};
+
+class IdentityMatrixStrategy {

[mtklein, 2016/02/16 21:13:10]

dead code?

[herb_g, 2016/02/16 22:04:25]

Done.

+public:
+    void processPoints(int n, Sk4f* xs, Sk4f* ys) { }
+};
+template <typename Next = PointProcessorInterface>
+using IdentityMatrix = PointProcessor<IdentityMatrixStrategy, Next>;
+
+class TranslateMatrixStrategy {
+public:
+    TranslateMatrixStrategy(SkVector offset)
+        : fXOffset{X(offset)}
+        , fYOffset{Y(offset)} { }
+    void processPoints(int n, Sk4f* xs, Sk4f* ys) {
+        *xs = *xs + fXOffset;
+        *ys = *ys + fYOffset;
+    }
+
+private:
+    const Sk4f fXOffset, fYOffset;
+};
+template <typename Next = 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(int n, Sk4f* xs, Sk4f* ys) {
+        *xs = *xs * fXScale + fXOffset;
+        *ys = *ys * fYScale + fYOffset;
+    }
+
+private:
+    const Sk4f fXOffset, fYOffset;
+    const Sk4f fXScale, fYScale;
+};
+template <typename Next = 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(int n, Sk4f* xs, Sk4f* ys) {
+        Sk4f newXs = fXScale * *xs +  fXSkew * *ys + fXOffset;
+        Sk4f newYs =  fYSkew * *xs + fYScale * *ys + fYOffset;
+
+        *xs = newXs;
+        *ys = newYs;
+    }
+
+private:
+    const Sk4f fXOffset, fYOffset;
+    const Sk4f fXScale,  fYScale;
+    const Sk4f fXSkew,   fYSkew;
+};
+template <typename Next = PointProcessorInterface>
+using AffineMatrix = PointProcessor<AffineMatrixStrategy, Next>;
+
+static PointProcessorInterface* choose_matrix(
+    PointProcessorInterface* next,
+    const SkMatrix& inverse,
+    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<AbortPointProcessor>();
+        return next;
+    }
+    return matrixProc->get();
+}
+
+class ClampStrategy {
+public:
+    ClampStrategy(X max)
+        : fXMin{0.0f}
+        , fXMax{max - 1.0f} { }
+    ClampStrategy(Y max)
+        : fYMin{0.0f}
+        , fYMax{max - 1.0f} { }
+    ClampStrategy(SkSize max)
+        : fXMin{0.0f}
+        , fYMin{0.0f}
+        , fXMax{X(max) - 1.0f}
+        , fYMax{Y(max) - 1.0f} { }
+
+    void processPoints(int n, Sk4f* xs, Sk4f* ys) {
+        *xs = Sk4f::Min(Sk4f::Max(*xs, fXMin), fXMax);
+        *ys = Sk4f::Min(Sk4f::Max(*ys, fYMin), fYMax);
+    }
+
+private:
+    const Sk4f fXMin{SK_FloatNegativeInfinity};
+    const Sk4f fYMin{SK_FloatNegativeInfinity};
+    const Sk4f fXMax{SK_FloatInfinity};
+    const Sk4f fYMax{SK_FloatInfinity};
+};
+template <typename Next = PointProcessorInterface>
+using Clamp = PointProcessor<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)}
+        , fYInvMax{1.0f / Y(max)} { }
+
+    void processPoints(int n, Sk4f* xs, Sk4f* ys) {
+        Sk4f divX = (*xs * fXInvMax).floor();
+        Sk4f divY = (*ys * fYInvMax).floor();
+        Sk4f baseX = (divX * fXMax);
+        Sk4f baseY = (divY * fYMax);
+        *xs = *xs - baseX;
+        *ys = *ys - baseY;
+    }
+
+private:
+    const Sk4f fXMax{0.0f};
+    const Sk4f fXInvMax{0.0f};
+    const Sk4f fYMax{0.0f};
+    const Sk4f fYInvMax{0.0f};
+};
+
+template <typename Next = PointProcessorInterface>
+using Repeat = PointProcessor<RepeatStrategy, Next>;
+
+static PointProcessorInterface* choose_tiler(
+    PointProcessorInterface* next,
+    SkSize dimensions,
+    SkShader::TileMode xMode,
+    SkShader::TileMode yMode,
+    TileStage* tileProcXOrBoth,
+    TileStage* tileProcY) {
+    if (xMode == yMode) {
+        switch (xMode) {
+            case SkShader::kClamp_TileMode:
+                tileProcXOrBoth->Initialize<Clamp<>>(next, dimensions);
+                break;
+            case SkShader::kRepeat_TileMode:
+                tileProcXOrBoth->Initialize<Repeat<>>(next, dimensions);
+                break;
+            case SkShader::kMirror_TileMode:
+                SkFAIL("Not implemented.");
+                break;
+        }
+        tileProcY->Initialize<AbortPointProcessor>();
+    } else {
+        switch (yMode) {
+            case SkShader::kClamp_TileMode:
+                tileProcY->Initialize<Clamp<>>(next, Y(dimensions));
+                break;
+            case SkShader::kRepeat_TileMode:
+                tileProcY->Initialize<Repeat<>>(next, Y(dimensions));
+                break;
+            case SkShader::kMirror_TileMode:
+                SkFAIL("Not implemented.");
+                break;
+        }
+        switch (xMode) {
+            case SkShader::kClamp_TileMode:
+                tileProcXOrBoth->Initialize<Clamp<>>(tileProcY->get(), X(dimensions));
+                break;
+            case SkShader::kRepeat_TileMode:
+                tileProcXOrBoth->Initialize<Repeat<>>(tileProcY->get(), X(dimensions));
+                break;
+            case SkShader::kMirror_TileMode:
+                SkFAIL("Not implemented.");
+                break;
+        }
+    }
+    return tileProcXOrBoth->get();
+}
+
+inline Sk4f bilerp4(SkPoint pt, Sk4f pixel00, Sk4f pixel01,

[mtklein, 2016/02/16 21:13:10]

die

[herb_g, 2016/02/16 22:04:25]

Done.

+                    Sk4f pixel10, Sk4f pixel11) {
+    Sk4f Xs{X(pt) - std::floor(X(pt))};
+    Sk4f Ys{Y(pt) - std::floor(Y(pt))};
+    Sk4f XYs{Xs * Ys};
+    Sk4f sum = pixel11 * XYs;
+    sum = sum + pixel01 * (Xs - XYs);
+    sum = sum + pixel10 * (Ys - XYs);
+    sum = sum + pixel00 * (Sk4f{1.0f} - Xs - Ys + XYs);
+    return sum;
+}
+
+class sRGBFast {
+public:
+    static Sk4f 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}{ }
+
+    Sk4f getPixel(const uint32_t* src, int index) {

[mtklein, 2016/02/16 21:13:10]

private?

[herb_g, 2016/02/16 22:04:25]

Done.

+        Sk4b bytePixel = Sk4b::Load((uint8_t *)(&src[index]));
+        Sk4f pixel = SkNx_cast<float, uint8_t>(bytePixel);
+        pixel = pixel * Sk4f{1.0f/255.0f};
+        if (colorProfile == kSRGB_SkColorProfileType) {
+            pixel = sRGBFast::sRGBToLinear(pixel);
+        }
+        return pixel;
+    }
+
+    void getFewPixels(int n, 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;
+        switch (n) {
+            case 4:
+                *px3 = getPixel(fSrc, bufferLoc[3]);
+            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(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]; }
+
+private:
+    const uint32_t* const fSrc;
+    const Sk4i fWidth;
+};
+
+template <typename SourceStrategy>
+class Sampler final : public PointProcessorInterface {
+public:
+    template <typename... Args>
+    Sampler(PixelPlacerInterface* next, Args&&... args)
+        : fNext{next}
+        , fStrategy{std::forward<Args>(args)...} { }
+
+    void pointListFew(int n, Sk4f xs, Sk4f ys) override {
+        Sk4f px0, px1, px2, px3;
+        fStrategy.getFewPixels(n, xs, ys, &px0, &px1, &px2, &px3);

[mtklein, 2016/02/16 21:13:10]

should not need px3?

[herb_g, 2016/02/16 22:04:25]

Done.

+        if (0 == n) return;

[mtklein, 2016/02/16 21:13:10]

assert n < 4 && n > 0?

[herb_g, 2016/02/16 22:04:24]

Done.

+        fNext->placePixel(px0);

[mtklein, 2016/02/16 21:13:10]

if (n > 0) { fNext->placePixel(px0); }
if (n > 1) { fNext->placePixel(px1); }
if (n > 2) { fNext->placePixel(px2); }

[herb_g, 2016/02/16 22:04:25]

Done.

+        if (1 == n) return;
+        fNext->placePixel(px1);
+        if (2 == n) return;
+        fNext->placePixel(px2);
+        if (3 == n) return;
+
+        fNext->placePixel(px3);
+    }
+
+    void 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);
+    }
+
+private:
+    PixelPlacerInterface* const fNext;
+    SourceStrategy fStrategy;
+};
+
+template <SkAlphaType alphaType>
+class PlaceFPPixel final : public PixelPlacerInterface {
+public:
+    void placePixel(Sk4f pixel) override {
+        PlacePixel(fDst, pixel, 0);
+        fDst += 1;
+    }
+
+    void 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, Sk4f pixel, int index) {
+        if (alphaType == kUnpremul_SkAlphaType) {
+            pixel = Premultiply(pixel);
+        }
+        pixel.store(dst + index);
+    }
+    static Sk4f Premultiply(Sk4f pixel) {
+        float alpha = pixel[3];
+        return pixel * Sk4f{alpha, alpha, alpha, 1.0f};
+    }
+
+    SkPM4f* fDst;
+};
+
+static PointProcessorInterface* choose_pixel_sampler(
+    PixelPlacerInterface* next,
+    const SkImageInfo& imageInfo,
+    const void* imageData,
+    SampleStage* sampleStage) {
+    switch (imageInfo.colorType()) {
+        case kRGBA_8888_SkColorType:
+            if (imageInfo.profileType() == kSRGB_SkColorProfileType) {
+                sampleStage->Initialize<Sampler<Passthrough8888<kSRGB_SkColorProfileType>>>(
+                    next, imageInfo.width(),
+                    (uint32_t *)imageData);
+            } else {
+                sampleStage->Initialize<Sampler<Passthrough8888<kLinear_SkColorProfileType>>>(
+                    next, imageInfo.width(),
+                    (uint32_t *)imageData);
+            }
+            break;
+        default:
+            SkFAIL("Not implemented. Unsupported src");
+            break;
+    }
+    return sampleStage->get();
+}
+
+static PixelPlacerInterface* choose_pixel_placer(SkAlphaType alphaType, 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();
+}
+
+SkLinearBitmapPipeline::SkLinearBitmapPipeline(
+    const SkMatrix& inverse,
+    SkShader::TileMode xTile, SkShader::TileMode yTile,
+    const SkImageInfo& srcImageInfo,
+    const void* srcImageData) {
+    SkSize size;
+    size = srcImageInfo.dimensions();
+    auto placementStage = choose_pixel_placer(srcImageInfo.alphaType(), &fPixelStage);

[mtklein, 2016/02/16 21:13:10]

Let's explain how the stages may be missing, etc.

[herb_g, 2016/02/16 22:04:25]

Done.

+    auto samplerStage   = choose_pixel_sampler(placementStage, srcImageInfo,
+                                               srcImageData, &fSampleStage);
+    auto tilerStage     = choose_tiler(samplerStage, size, xTile, yTile, &fTileXOrBothStage,
+                                       &fTileYStage);
+    fFirstStage         = choose_matrix(tilerStage, inverse, &fMatrixStage);
+}
+
+void SkLinearBitmapPipeline::shadeSpan4f(int x, int y, SkPM4f* dst, int count) {
+    fPixelStage->setDestination(dst);
+
+    Sk4f Xs = Sk4f(x) + Sk4f{0.0f, 1.0f, 2.0f, 3.0f};

[mtklein, 2016/02/16 21:13:10]

+ 0.5?

[herb_g, 2016/02/16 22:04:25]

Done.

+    Sk4f Ys(y);
+    Sk4f fours{4.0f};
+
+    while (count >= 4) {
+        fFirstStage->pointList4(Xs, Ys);
+        Xs = Xs + fours;
+        count -= 4;
+    }
+    if (count > 0) {
+        fFirstStage->pointListFew(count, Xs, Ys);
+    }
+}