All source types working for linear pipeline.

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
 
 #include <tuple>
 
+#include "SkColor.h"
+#include "SkColorPriv.h"
 #include "SkFixed.h"
 #include "SkHalf.h"
 #include "SkLinearBitmapPipeline_core.h"
+#include "SkNx.h"
 #include "SkPM4fPriv.h"
 
 namespace {
 // Explaination of the math:
 //              1 - x      x
 //           +--------+--------+
 //           |        |        |
 //  1 - y    |  px00  |  px10  |
 //           |        |        |
 //           +--------+--------+
@@ skipping 21 matching lines @@
     sum = sum + px10 * (fxs - fxys);
     sum = sum + px00 * (Sk4f{1.0f} - fxs - fys + fxys);
     return sum;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // PixelGetter is the lowest level interface to the source data. There is a PixelGetter for each
 // of the different SkColorTypes.
 template <SkColorType colorType, SkColorProfileType colorProfile> class PixelGetter;
 
+// Alpha handling:
+//   The alpha from the paint (tintColor) is used in the blend part of the pipeline to modulate
+// the entire bitmap. So, the tint color is given an alpha of 1.0 so that the later alpha can
+// modulate this color later.
+template <>
+class PixelGetter<kAlpha_8_SkColorType, kLinear_SkColorProfileType> {
+public:
+    using Element = uint8_t;
+    PixelGetter(const SkPixmap& srcPixmap, SkColor tintColor)
+        : fTintColor{set_alpha(Sk4f_from_SkColor(tintColor), 1.0f)} { }
+
+    Sk4f getPixelAt(const uint8_t* src) {
+        return fTintColor * (*src * (1.0f/255.0f));
+    }
+
+private:
+    const Sk4f fTintColor;
+};
+
+template <SkColorProfileType colorProfile>
+class PixelGetter<kRGB_565_SkColorType, colorProfile> {
+public:
+    using Element = uint16_t;
+    PixelGetter(const SkPixmap& srcPixmap) { }
+
+    Sk4f getPixelAt(const uint16_t* src) {
+        SkPMColor pixel = SkPixel16ToPixel32(*src);
+        return colorProfile == kSRGB_SkColorProfileType
+               ? Sk4f_fromS32(pixel)
+               : Sk4f_fromL32(pixel);
+    }
+};
+
+template <SkColorProfileType colorProfile>
+class PixelGetter<kARGB_4444_SkColorType, colorProfile> {
+public:
+    using Element = uint16_t;
+    PixelGetter(const SkPixmap& srcPixmap) { }
+
+    Sk4f getPixelAt(const uint16_t* src) {
+        SkPMColor pixel = SkPixel4444ToPixel32(*src);
+        return colorProfile == kSRGB_SkColorProfileType
+               ? Sk4f_fromS32(pixel)
+               : Sk4f_fromL32(pixel);
+    }
+};
+
 template <SkColorProfileType colorProfile>
 class PixelGetter<kRGBA_8888_SkColorType, colorProfile> {
 public:
     using Element = uint32_t;
     PixelGetter(const SkPixmap& srcPixmap) { }
 
     Sk4f getPixelAt(const uint32_t* src) {
         return colorProfile == kSRGB_SkColorProfileType
                ? Sk4f_fromS32(*src)
                : Sk4f_fromL32(*src);
     }
 };
 
 template <SkColorProfileType colorProfile>
 class PixelGetter<kBGRA_8888_SkColorType, colorProfile> {
 public:
     using Element = uint32_t;
     PixelGetter(const SkPixmap& srcPixmap) { }
 
     Sk4f getPixelAt(const uint32_t* src) {
         Sk4f pixel = colorProfile == kSRGB_SkColorProfileType
                      ? Sk4f_fromS32(*src)
                      : Sk4f_fromL32(*src);
-        return SkNx_shuffle<2, 1, 0, 3>(pixel);
+        return swizzle_rb(pixel);
     }
 };
 
 template <SkColorProfileType colorProfile>
 class PixelGetter<kIndex_8_SkColorType, colorProfile> {
 public:
     using Element = uint8_t;
     PixelGetter(const SkPixmap& srcPixmap) {
         SkColorTable* skColorTable = srcPixmap.ctable();
         SkASSERT(skColorTable != nullptr);
@@ skipping 30 matching lines @@
             }
             return pixel;
         } else {
             return Sk4f{0.0f};
         }
     }
     SkAutoMalloc         fColorTableStorage{kColorTableSize};
     Sk4f*                fColorTable;
 };
 
+template <SkColorProfileType colorProfile>
+class PixelGetter<kGray_8_SkColorType, colorProfile> {
+public:
+    using Element = uint8_t;
+    PixelGetter(const SkPixmap& srcPixmap) { }
+
+    Sk4f getPixelAt(const uint8_t* src) {
+        float gray = *src * (1.0f/255.0f);
+        Sk4f pixel = Sk4f{gray, gray, gray, 1.0f};
+        return colorProfile == kSRGB_SkColorProfileType
+               ? srgb_to_linear(pixel)
+               : pixel;
+    }
+};
+
 template <>
 class PixelGetter<kRGBA_F16_SkColorType, kLinear_SkColorProfileType> {
 public:
     using Element = uint64_t;
     PixelGetter(const SkPixmap& srcPixmap) { }
 
     Sk4f getPixelAt(const uint64_t* src) {
         return SkHalfToFloat_01(*src);
     }
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // PixelAccessor handles all the same plumbing for all the PixelGetters.
 template <SkColorType colorType, SkColorProfileType colorProfile>
 class PixelAccessor {
     using Element = typename PixelGetter<colorType, colorProfile>::Element;
 public:
-    PixelAccessor(const SkPixmap& srcPixmap)
+    template <typename... Args>
+    PixelAccessor(const SkPixmap& srcPixmap, Args&&... args)
         : fSrc{static_cast<const Element*>(srcPixmap.addr())}
         , fWidth{srcPixmap.rowBytesAsPixels()}
-        , fGetter{srcPixmap} { }
+        , fGetter{srcPixmap, std::move<Args>(args)...} { }
 
     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(bufferLoc[2]);
             case 2:
                 *px1 = this->getPixelAt(bufferLoc[1]);
@@ skipping 542 matching lines @@
             Sk4f ys = {y - 0.5f, y - 0.5f, y1 + 0.5f, y1 + 0.5f};
             while (count > 0) {
                 Sk4f xs = Sk4f{-0.5f, 0.5f, -0.5f, 0.5f} + Sk4f{x};
                 this->bilerpEdge(xs, ys);
                 x += dx;
                 count -= 1;
             }
         }
     }
 
-    Next* const fNext;
+    Next* const                            fNext;
     PixelAccessor<colorType, colorProfile> fStrategy;
 };
 
-
 }  // namespace
 
 #endif  // SkLinearBitmapPipeline_sampler_DEFINED