Add bilerp filtering.

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 Strategy, typename Next>
-class PointProcessor : public PointProcessorInterface {
+class PointProcessor final : public 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 {
         Sk4f newXs = xs;
         Sk4f newYs = ys;
         fStrategy.processPoints(&newXs, &newYs);
         fNext->pointListFew(n, newXs, newYs);
     }
 
     void pointList4(Sk4fArg xs, Sk4fArg ys) override {
         Sk4f newXs = xs;
         Sk4f newYs = ys;
         fStrategy.processPoints(&newXs, &newYs);
         fNext->pointList4(newXs, newYs);
     }
 
 private:
     Next* const fNext;
     Strategy fStrategy;
 };
 
-class SkippedStage final : public PointProcessorInterface {
+template<typename Strategy, typename Next>
+class BilerpProcessor final : public 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 {
-        SkFAIL("Abort tiler.");
+        Sk4f newXs = xs;
+        Sk4f newYs = ys;
+        fStrategy.processPoints(&newXs, &newYs);
+        fNext->pointListFew(n, newXs, newYs);
+    }
+
+    void pointList4(Sk4fArg xs, Sk4fArg ys) override {
+        Sk4f newXs = xs;
+        Sk4f newYs = ys;
+        fStrategy.processPoints(&newXs, &newYs);
+        fNext->pointList4(newXs, newYs);
+    }
+
+    void bilerpList(Sk4fArg xs, Sk4fArg ys) override {
+        Sk4f newXs = xs;
+        Sk4f newYs = ys;
+        fStrategy.processPoints(&newXs, &newYs);
+        fNext->bilerpList(newXs, newYs);
+    }
+
+private:
+    Next* const fNext;
+    Strategy fStrategy;
+};
+
+class SkippedStage final : public BilerpProcessorInterface {
+    void pointListFew(int n, Sk4fArg xs, Sk4fArg ys) override {
+        SkFAIL("Skipped stage.");
     }
     void pointList4(Sk4fArg Xs, Sk4fArg Ys) override {
-        SkFAIL("Abort point processor.");
+        SkFAIL("Skipped stage.");
+    }
+    virtual void bilerpList(Sk4fArg xs, Sk4fArg ys) 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;
@@ skipping 66 matching lines @@
         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 {
+public:
+    ExpandBilerp(Next* next) : fNext{next} { }
+
+    void pointListFew(int n, Sk4fArg xs, Sk4fArg ys) override {
+        SkASSERT(0 < n && n < 4);
+        //                   px00  px10  px01  px11
+        const Sk4f kXOffsets{0.0f, 1.0f, 0.0f, 1.0f},
+                   kYOffsets{0.0f, 0.0f, 1.0f, 1.0f};
+        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 {
+        //                   px00  px10  px01  px11
+        const Sk4f kXOffsets{0.0f, 1.0f, 0.0f, 1.0f},
+                   kYOffsets{0.0f, 0.0f, 1.0f, 1.0f};
+        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);
+    }
+
+private:
+    Next* const fNext;
+};
+
+static PointProcessorInterface* choose_filter(
+    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();
+    }
+}
+
 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(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>;
+template <typename Next = 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)}
         , fYInvMax{1.0f / Y(max)} { }
 
     void processPoints(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>;
+template <typename Next = BilerpProcessorInterface>
+using Repeat = BilerpProcessor<RepeatStrategy, Next>;
 
-static PointProcessorInterface* choose_tiler(
-    PointProcessorInterface* next,
+static BilerpProcessorInterface* choose_tiler(
+    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 81 matching lines @@
         pixel = pixel * Sk4f{1.0f/255.0f};
         if (colorProfile == kSRGB_SkColorProfileType) {
             pixel = sRGBFast::sRGBToLinear(pixel);
         }
         return pixel;
     }
     const uint32_t* const fSrc;
     const Sk4i fWidth;
 };
 
+// Explaination of the math:
+//              1 - x      x
+//           +--------+--------+
+//           |        |        |
+//  1 - y    |  px00  |  px10  |
+//           |        |        |
+//           +--------+--------+
+//           |        |        |
+//    y      |  px01  |  px11  |
+//           |        |        |
+//           +--------+--------+
+//
+//
+// 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.

[mtklein, 2016/02/17 23:46:55]

This is beautiful.  Nominated for favorite code snippet of the week.

[herb_g, 2016/02/18 03:49:06]

Acknowledged.

+static Sk4f bilerp4(Sk4fArg xs, Sk4fArg ys, Sk4fArg px00, Sk4fArg px10,
+                                            Sk4fArg px01, Sk4fArg 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 PointProcessorInterface {
+class Sampler final : public BilerpProcessorInterface {
 public:
     template <typename... Args>
     Sampler(PixelPlacerInterface* next, Args&&... args)
         : fNext{next}
         , fStrategy{std::forward<Args>(args)...} { }
 
     void pointListFew(int n, Sk4fArg xs, Sk4fArg 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 {
         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 {
+        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);
+    }
+
 private:
     PixelPlacerInterface* const fNext;
     SourceStrategy fStrategy;
 };
 
-static PointProcessorInterface* choose_pixel_sampler(
+static BilerpProcessorInterface* choose_pixel_sampler(
     PixelPlacerInterface* next,
     const SkImageInfo& imageInfo,
     const void* imageData,
     SkLinearBitmapPipeline::SampleStage* sampleStage) {
     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>>>(
@@ skipping 59 matching lines @@
         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,
+    SkFilterQuality filterQuality,
     SkShader::TileMode xTile, SkShader::TileMode yTile,
     const SkImageInfo& srcImageInfo,
     const void* srcImageData) {
     SkSize size;
     size = srcImageInfo.dimensions();
 
     // 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(srcImageInfo.alphaType(), &fPixelStage);
     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);
+    auto filterStage    = choose_filter(tilerStage, filterQuality, &fFilterStage);
+    fFirstStage         = choose_matrix(filterStage, inverse, &fMatrixStage);
 }
 
 void SkLinearBitmapPipeline::shadeSpan4f(int x, int y, SkPM4f* dst, int count) {
     fPixelStage->setDestination(dst);
 
     Sk4f Xs = Sk4f(x) + Sk4f{0.5f, 1.5f, 2.5f, 3.5f};
     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);
     }
 }