4f linear gradient shader blitters

src/effects/gradients/Sk4fGradientPriv.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 Sk4fGradientPriv_DEFINED
 #define Sk4fGradientPriv_DEFINED
 
 #include "SkColor.h"
+#include "SkHalf.h"
+#include "SkImageInfo.h"
 #include "SkNx.h"
 #include "SkPM4f.h"
+#include "SkPM4fPriv.h"
 
 // Templates shared by various 4f gradient flavors.
 
 namespace {
 
 inline Sk4f premul_4f(const Sk4f& c) {
     const float alpha = c[SkPM4f::A];
     // FIXME: portable swizzle?
     return c * Sk4f(alpha, alpha, alpha, 1);
 }
 
 template <bool do_premul>
 inline SkPMColor trunc_from_255(const Sk4f& c) {
     SkPMColor pmc;
     SkNx_cast<uint8_t>(c).store(&pmc);
     if (do_premul) {
         pmc = SkPreMultiplyARGB(SkGetPackedA32(pmc), SkGetPackedR32(pmc),
                                 SkGetPackedG32(pmc), SkGetPackedB32(pmc));
     }
     return pmc;
 }
 
-template<typename DstType, bool do_premul>
+template<typename DstType, SkColorProfileType, bool do_premul>
 void store(const Sk4f& color, DstType* dst);
 
 template<>
-inline void store<SkPM4f, false>(const Sk4f& c, SkPM4f* dst) {
+inline void store<SkPM4f, kLinear_SkColorProfileType, false>(const Sk4f& c, SkPM4f* dst) {

[reed1, 2016/03/18 14:28:59]

Getting hard to remember what true and false mean in all of these
specializations, Perhaps an enum? { kApplyPremul_True, False }

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

Done.

     c.store(dst);
 }
 
 template<>
-inline void store<SkPM4f, true>(const Sk4f& c, SkPM4f* dst) {
-    store<SkPM4f, false>(premul_4f(c), dst);
+inline void store<SkPM4f, kLinear_SkColorProfileType, true>(const Sk4f& c, SkPM4f* dst) {
+    store<SkPM4f, kLinear_SkColorProfileType, false>(premul_4f(c), dst);
 }
 
 template<>
-inline void store<SkPMColor, false>(const Sk4f& c, SkPMColor* dst) {
+inline void store<SkPMColor, kLinear_SkColorProfileType, false>(const Sk4f& c, SkPMColor* dst) {
     *dst = trunc_from_255<false>(c);
 }
 
 template<>
-inline void store<SkPMColor, true>(const Sk4f& c, SkPMColor* dst) {
+inline void store<SkPMColor, kLinear_SkColorProfileType, true>(const Sk4f& c, SkPMColor* dst) {
     *dst = trunc_from_255<true>(c);
 }
 
-template<typename DstType, bool do_premul>
+template<>
+inline void store<SkPMColor, kSRGB_SkColorProfileType, false>(const Sk4f& c, SkPMColor* dst) {
+    // FIXME: this assumes opaque colors.  Handle unpremultiplication.
+    *dst = Sk4f_toS32(c);
+}
+
+template<>
+inline void store<SkPMColor, kSRGB_SkColorProfileType, true>(const Sk4f& c, SkPMColor* dst) {
+    const SkPMColor s32 = Sk4f_toS32(c);
+    *dst = SkPreMultiplyARGB(SkGetPackedA32(s32), SkGetPackedR32(s32),

[reed1, 2016/03/18 14:28:59]

why not Sk4f_toS32(premul_4f(c)) ?

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

Done.

+                             SkGetPackedG32(s32), SkGetPackedB32(s32));
+}
+
+template<>
+inline void store<uint64_t, kLinear_SkColorProfileType, false>(const Sk4f& c, uint64_t* dst) {
+    *dst = SkFloatToHalf_01(c);
+}
+
+template<>
+inline void store<uint64_t, kLinear_SkColorProfileType, true>(const Sk4f& c, uint64_t* dst) {
+    store<uint64_t, kLinear_SkColorProfileType, false>(premul_4f(c), dst);
+}
+
+template<typename DstType, SkColorProfileType profile, bool do_premul>
 inline void store4x(const Sk4f& c0,
                     const Sk4f& c1,
                     const Sk4f& c2,
                     const Sk4f& c3,
                     DstType* dst) {
-    store<DstType, do_premul>(c0, dst++);
-    store<DstType, do_premul>(c1, dst++);
-    store<DstType, do_premul>(c2, dst++);
-    store<DstType, do_premul>(c3, dst++);
+    store<DstType, profile, do_premul>(c0, dst++);
+    store<DstType, profile, do_premul>(c1, dst++);
+    store<DstType, profile, do_premul>(c2, dst++);
+    store<DstType, profile, do_premul>(c3, dst++);
 }
 
 template<>
-inline void store4x<SkPMColor, false>(const Sk4f& c0,
-                                      const Sk4f& c1,
-                                      const Sk4f& c2,
-                                      const Sk4f& c3,
-                                      SkPMColor* dst) {
+inline void store4x<SkPMColor, kLinear_SkColorProfileType, false>(const Sk4f& c0,
+                                                                  const Sk4f& c1,
+                                                                  const Sk4f& c2,
+                                                                  const Sk4f& c3,
+                                                                  SkPMColor* dst) {
     Sk4f_ToBytes((uint8_t*)dst, c0, c1, c2, c3);
 }
 
-template<typename DstType>
-float dst_component_scale();
-
-template<>
-inline float dst_component_scale<SkPM4f>() {
-    return 1;
+template<typename DstType, SkColorProfileType>
+Sk4f scale_for_dest(const Sk4f& c)  {
+    return c;
 }
 
 template<>
-inline float dst_component_scale<SkPMColor>() {
-    return 255;
+inline Sk4f scale_for_dest<SkPMColor, kLinear_SkColorProfileType>(const Sk4f& c)  {
+    return c * 255;
 }
 
 template<typename DstType>
 Sk4f dst_swizzle(const SkPM4f&);
 
 template<>
 inline Sk4f dst_swizzle<SkPM4f>(const SkPM4f& c) {
     return c.to4f();
 }
 
 template<>
 inline Sk4f dst_swizzle<SkPMColor>(const SkPM4f& c) {
     return c.to4f_pmorder();
 }
 
+template<>
+inline Sk4f dst_swizzle<uint64_t>(const SkPM4f& c) {
+    return c.to4f();
+}
+
 }
 
 #endif // Sk4fGradientPriv_DEFINED