Add bilerp filtering.

src/core/SkLinearBitmapPipeline.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_DEFINED
 #define SkLinearBitmapPipeline_DEFINED
 
@@ skipping 10 matching lines @@
 
 using Sk4fArg = const Sk4f&;
 
 class PointProcessorInterface {
 public:
     virtual ~PointProcessorInterface() { }
     virtual void pointListFew(int n, Sk4fArg xs, Sk4fArg ys) = 0;
     virtual void pointList4(Sk4fArg xs, Sk4fArg ys) = 0;
 };
 
+class BilerpProcessorInterface : public PointProcessorInterface {
+public:
+    // The x's and y's are setup in the following order:
+    // +--------+--------+
+    // |        |        |
+    // |  px00  |  px10  |
+    // |    0   |    1   |
+    // +--------+--------+
+    // |        |        |
+    // |  px01  |  px11  |
+    // |    2   |    3   |
+    // +--------+--------+
+    // These pixels coordinates are arranged in the following order in xs and ys:
+    // px00  px10  px01  px11
+    virtual void bilerpList(Sk4fArg xs, Sk4fArg ys) = 0;
+};
+
 class PixelPlacerInterface {
 public:
     virtual ~PixelPlacerInterface() { }
     virtual void setDestination(SkPM4f* dst) = 0;
     virtual void placePixel(Sk4fArg pixel0) = 0;
     virtual void place4Pixels(Sk4fArg p0, Sk4fArg p1, Sk4fArg p2, Sk4fArg p3) = 0;
 };
 
 class SkLinearBitmapPipeline {
 public:
     SkLinearBitmapPipeline(
         const SkMatrix& inverse,
+        SkFilterQuality filterQuality,
         SkShader::TileMode xTile, SkShader::TileMode yTile,
         const SkImageInfo& srcImageInfo,
         const void* srcImageData);
 
     void shadeSpan4f(int x, int y, SkPM4f* dst, int count);
 
     template<typename Base, size_t kSize>
     class PolymorphicUnion {
     public:
         PolymorphicUnion() {}
@@ skipping 13 matching lines @@
         Base& operator*() const { return *get(); }
 
     private:
         struct SK_STRUCT_ALIGN(16) Space {
             char space[kSize];
         };
         mutable Space fSpace;
     };
 
     using MatrixStage = PolymorphicUnion<PointProcessorInterface, 112>;
-    using TileStage   = PolymorphicUnion<PointProcessorInterface,  96>;
-    using SampleStage = PolymorphicUnion<PointProcessorInterface,  80>;
+    using FilterStage = PolymorphicUnion<PointProcessorInterface,   8>;
+    using TileStage   = PolymorphicUnion<BilerpProcessorInterface, 96>;
+    using SampleStage = PolymorphicUnion<BilerpProcessorInterface, 80>;
     using PixelStage  = PolymorphicUnion<PixelPlacerInterface,     80>;
 
 private:
     PointProcessorInterface* fFirstStage;
     MatrixStage fMatrixStage;
+    FilterStage fFilterStage;
     TileStage   fTileXOrBothStage;
     TileStage   fTileYStage;
     SampleStage fSampleStage;
     PixelStage  fPixelStage;
 };
 
 #endif  // SkLinearBitmapPipeline_DEFINED