Use common code from SkPM4fPriv

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 "SkFixed.h"
 #include "SkHalf.h"
 #include "SkLinearBitmapPipeline_core.h"
-#include <array>
-#include <tuple>
+#include "SkPM4fPriv.h"
 
 namespace {
 // Explaination of the math:
 //              1 - x      x
 //           +--------+--------+
 //           |        |        |
 //  1 - y    |  px00  |  px10  |
 //           |        |        |
 //           +--------+--------+
 //           |        |        |
@@ skipping 15 matching lines @@
     Sk4s fxs = xs - xs.floor();
     Sk4s fys = ys - ys.floor();
     Sk4s 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;
 }
 
-// The GeneralSampler class
 template<typename SourceStrategy, typename Next>
 class GeneralSampler {
 public:
     template<typename... Args>
     GeneralSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next, Args&& ... args)
         : fNext{next}, fStrategy{std::forward<Args>(args)...} { }
 
     GeneralSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next,
                    const GeneralSampler& sampler)
         : fNext{next}, fStrategy{sampler.fStrategy} { }
@@ skipping 491 matching lines @@
                 x += dx;
                 count -= 1;
             }
         }
     }
 
     Next* const fNext;
     SourceStrategy fStrategy;
 };
 
-class sRGBFast {
-public:
-    static Sk4s VECTORCALL sRGBToLinear(Sk4s pixel) {
-        Sk4s l = pixel * pixel;
-        return Sk4s{l[0], l[1], l[2], pixel[3]};
-    }
-};
-
 template <typename PixelGetter>
 class PixelAccessor {
 public:
     PixelAccessor(const SkPixmap& srcPixmap)
         : fWidth{srcPixmap.rowBytesAsPixels()}
         , fGetter{srcPixmap} { }
 
     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);
@@ skipping 42 matching lines @@
 
 template <SkColorProfileType colorProfile>
 class PixelGetter<kRGBA_8888_SkColorType, colorProfile> {
 public:
     PixelGetter(const SkPixmap& srcPixmap)
         : fSrc{srcPixmap.addr32()}
         , fWidth{srcPixmap.rowBytesAsPixels()} { }
 
     Sk4f getPixelFromRow(const void* row, int index) {
         const uint32_t* src = static_cast<const uint32_t*>(row);
-        Sk4b bytePixel = Sk4b::Load((uint8_t *)(&src[index]));
-        Sk4f pixel = SkNx_cast<float, uint8_t>(bytePixel);
+        Sk4f pixel = to_4f(*src);
         pixel = pixel * (1.0f/255.0f);

[f(malita), 2016/05/11 16:54:03]

Nit: these two lines are equivalent to Sk4f_fromL32().  I think we could
re-write this method as

  return colorProfile == kSRGB_SkColorProfileType
      ? Sk4f_fromS32(*src)
      : Sk4f_fromL32(*src);

[herb_g, 2016/05/11 18:15:17]

Done.

         if (colorProfile == kSRGB_SkColorProfileType) {
-            pixel = sRGBFast::sRGBToLinear(pixel);
+            pixel = srgb_to_linear(pixel);
         }
         return pixel;
     }
 
     Sk4f getPixelAt(int index) {
         return this->getPixelFromRow(fSrc, index);
     }
 
     const void* row(int y) { return fSrc + y * fWidth; }
 
 private:
     const uint32_t* const fSrc;
     const int             fWidth;
 };
 
 using Pixel8888SRGB = PixelAccessor<PixelGetter<kRGBA_8888_SkColorType, kSRGB_SkColorProfileType>>;
 using Pixel8888LRGB = PixelAccessor<PixelGetter<kRGBA_8888_SkColorType, kLinear_SkColorProfileType>>;
 
 template <SkColorProfileType colorProfile>
 class PixelGetter<kBGRA_8888_SkColorType, colorProfile> {
 public:
     PixelGetter(const SkPixmap& srcPixmap)
         : fSrc{srcPixmap.addr32()}
         , fWidth{srcPixmap.rowBytesAsPixels()} { }
 
     Sk4f getPixelFromRow(const void* row, int index) {
         const uint32_t* src = static_cast<const uint32_t*>(row);
-        Sk4b bytePixel = Sk4b::Load((uint8_t *)(&src[index]));
-        Sk4f pixel = SkNx_cast<float, uint8_t>(bytePixel);
+        Sk4f pixel = to_4f(*src);
         pixel = SkNx_shuffle<2, 1, 0, 3>(pixel);
         pixel = pixel * (1.0f/255.0f);
         if (colorProfile == kSRGB_SkColorProfileType) {
-            pixel = sRGBFast::sRGBToLinear(pixel);
+            pixel = srgb_to_linear(pixel);
         }

[f(malita), 2016/05/11 16:54:03]

Nit: maybe also rewrite as

  Sk4f pixel = colorProfile == kSRGB_SkColorProfileType
      ? Sk4f_fromS32(*src)
      : Sk4f_fromL32(*src);
  return SkNx_shuffle<2, 1, 0, 3>(pixel);

?

[herb_g, 2016/05/11 18:15:17]

Done.

         return pixel;
     }
 
     Sk4f getPixelAt(int index) {
         return this->getPixelFromRow(fSrc, index);
     }
 
     const void* row(int y) { return fSrc + y * fWidth; }
 
 private:
@@ skipping 36 matching lines @@
 
     Sk4f getPixelAt(int index) {
         return this->getPixelFromRow(fSrc, index);
     }
 
     const void* row(int y) { return fSrc + y * fWidth; }
 
 private:
     static const size_t kColorTableSize = sizeof(Sk4f[256]) + 12;
     Sk4f convertPixel(SkPMColor pmColor) {
-        Sk4b bPixel = Sk4b::Load(&pmColor);
-        Sk4f pixel = SkNx_cast<float, uint8_t>(bPixel);
-        float alpha = pixel[3];
+        Sk4f pixel = to_4f(pmColor);
+        float alpha = get_alpha(pixel);
         if (alpha != 0.0f) {
-            float invAlpha = 1.0f / pixel[3];
+            float invAlpha = 1.0f / alpha;
             Sk4f normalize = {invAlpha, invAlpha, invAlpha, 1.0f / 255.0f};
             pixel = pixel * normalize;
             if (colorProfile == kSRGB_SkColorProfileType) {
-                pixel = sRGBFast::sRGBToLinear(pixel);
+                pixel = linear_to_srgb(pixel);
             }
             return pixel;
         } else {
             return Sk4f{0.0f};
         }
     }
     const uint8_t* const fSrc;
     const int            fWidth;
     SkAutoMalloc         fColorTableStorage{kColorTableSize};
     Sk4f*                fColorTable;
@@ skipping 23 matching lines @@
 private:
     const uint64_t* const fSrc;
     const int             fWidth;
 };
 
 using PixelHalfLinear = PixelAccessor<PixelGetter<kRGBA_F16_SkColorType, kLinear_SkColorProfileType>>;
 
 }  // namespace
 
 #endif  // SkLinearBitmapPipeline_sampler_DEFINED