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 {
@@ skipping 37 matching lines @@
         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 : public BilerpProcessorInterface {

[mtklein, 2016/02/17 20:25:09]

final (and PointProcessor too)?

[herb_g, 2016/02/17 23:40:43]

Done.

+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;

[mtklein, 2016/02/17 20:25:09]

This is so sad.  :(

[herb_g, 2016/02/17 23:40:44]

Acknowledged.

+        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 {

[mtklein, 2016/02/17 20:25:09]

I think override's plenty.

[herb_g, 2016/02/17 23:40:44]

Done.

+        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(n > 0 && n <= 4);

[mtklein, 2016/02/17 20:25:09]

This seems awkward.  It's a bug if we call pointListFew(4, ...) externally, but
we've made it valid so that self calls can work?  I think I'd prefer:

void pointListFew(...) {
  SkASSERT(n > 0 && n < 4);
  for (int i = 0; i < n; i++) {
      ...
  }
}

void pointList4(...) {
    for (int i = 0; i < 4; i++) {
        ...
    }
}

[herb_g, 2016/02/17 23:40:43]

Done.

+        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);
+        if (n == 4) fNext->bilerpList(Sk4f{xs[3]} + kXOffsets, Sk4f{ys[3]} + kYOffsets);
+    }
+
+    void pointList4(Sk4fArg xs, Sk4fArg ys) override {
+        pointListFew(4, xs, ys);

[mtklein, 2016/02/17 20:25:09]

self calls usually have a this->

[herb_g, 2016/02/17 23:40:44]

Removed

+    }

[mtklein, 2016/02/17 20:25:09]

Is this why we distinguish PointProcessor and BilerpProcessor, because there's
no sensible implementation of bilerpList() here?

[herb_g, 2016/02/17 23:40:44]

There is no sensible bilerp here or at the matrix level.

+
+private:
+    static const Sk4f kXOffsets;
+    static const Sk4f kYOffsets;
+    Next* const fNext;
+};
+
+template <typename Next>
+const Sk4f ExpandBilerp<Next>::kXOffsets = {0.0f, 1.0f, 0.0f, 1.0f};

[mtklein, 2016/02/17 20:25:09]

This is all sort of awkward and boilerplate-y.

Let's just write

const Sk4f xOffsets = { 0,1,0,1 },
           yOffsets = { 0,0,1,1 };

where needed?  The compiler will happily sort of the rest.

[herb_g, 2016/02/17 23:40:43]

Done.

+template <typename Next>
+const Sk4f ExpandBilerp<Next>::kYOffsets = {0.0f, 0.0f, 1.0f, 1.0f};
+
+static PointProcessorInterface* choose_filter(
+    BilerpProcessorInterface* next,
+    SkFilterQuality filterQuailty,
+    SkLinearBitmapPipeline::FilterStage* filterProc) {
+    if (filterQuailty >= SkFilterQuality::kLow_SkFilterQuality) {

[mtklein, 2016/02/17 20:25:09]

Might wanna write as:
   none -> skipped
   else -> bilerp
?

[herb_g, 2016/02/17 23:40:43]

Done.

+        filterProc->Initialize<ExpandBilerp<>>(next);
+        return filterProc->get();
+    } else {
+        filterProc->Initialize<SkippedStage>();
+        return next;
+    }
+}
+
 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;
 };
 
+inline Sk4f bilerp4(SkPoint pt, Sk4f pixel00, Sk4f pixel01,

[mtklein, 2016/02/17 20:25:09]

It's a good habit to get into writing static on all these.

Do you not need to use Sk4fArg?

Might be helpful to inline up the point arguments like they're laid out in
space, scooting over the second line a bit.

[herb_g, 2016/02/17 23:40:44]

Done.

+                    Sk4f pixel10, Sk4f pixel11) {
+    Sk4f Xs{X(pt) - std::floor(X(pt))};

[mtklein, 2016/02/17 20:25:09]

If we're using std:: stuff, might want to consider 
   Sk4f Xs { std::fmod(X(pt), 1) };
etc.

Might be nice for these names to reflect that they're only the fractional part
of X and Y.

[herb_g, 2016/02/17 23:40:43]

Redid whole function.

+    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);

[mtklein, 2016/02/17 20:25:09]

This would be a really great place for an ASCII art diagram and comments
explaining the math.

[herb_g, 2016/02/17 23:40:43]

Done.

+    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 {
+        SkPoint referencePoint{xs[0], ys[0]};

[mtklein, 2016/02/17 20:25:09]

Do these all have the same fractional parts?  I'm curious if we can avoid having
to pick a reference point at all.

[herb_g, 2016/02/17 23:40:43]

Done.

+        Sk4f px0, px1, px2, px3;
+        fStrategy.get4Pixels(xs, ys, &px0, &px1, &px2, &px3);
+        Sk4f pixel = bilerp4(referencePoint, px0, px1, px2, px3);
+        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);
     }
 }