Support Float32 output from SkColorSpaceXform

src/core/SkColorSpaceXform.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 "SkColorPriv.h"
 #include "SkColorSpace_Base.h"
 #include "SkColorSpacePriv.h"
@@ skipping 889 matching lines @@
 
 template <SwapRB kSwapRB>
 static inline void store_f16_1(void* dst, const uint32_t* src,
                                Sk4f& rgba, const Sk4f& a,
                                const uint8_t* const[3]) {
     rgba = Sk4f(rgba[0], rgba[1], rgba[2], a[3]);
     SkFloatToHalf_finite_ftz(rgba).store((uint64_t*) dst);
 }
 
 template <SwapRB kSwapRB>
+static inline void store_f32(void* dst, const uint32_t* src,

[msarett, 2016/09/14 20:20:35]

I originally wrote a "store_f32_opaque()" version as well...  But I'm not
convinced it would be noticeably faster than this.

+                             Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f& da,
+                             const uint8_t* const[3]) {
+    Sk4f_store4(dst, dr, dg, db, da);
+}
+
+template <SwapRB kSwapRB>
+static inline void store_f32_1(void* dst, const uint32_t* src,
+                               Sk4f& rgba, const Sk4f& a,
+                               const uint8_t* const[3]) {
+    rgba = Sk4f(rgba[0], rgba[1], rgba[2], a[3]);
+    rgba.store((float*) dst);
+}
+
+template <SwapRB kSwapRB>
 static inline void store_f16_opaque(void* dst, const uint32_t* src,
-                                    Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f& da,
+                                    Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f&,
                                     const uint8_t* const[3]) {
     Sk4h_store4(dst, SkFloatToHalf_finite_ftz(dr),
                      SkFloatToHalf_finite_ftz(dg),
                      SkFloatToHalf_finite_ftz(db),
                      SK_Half1);
 }
 
 template <SwapRB kSwapRB>
 static inline void store_f16_1_opaque(void* dst, const uint32_t* src,
-                                      Sk4f& rgba, const Sk4f& a,
+                                      Sk4f& rgba, const Sk4f&,
                                       const uint8_t* const[3]) {
     uint64_t tmp;
     SkFloatToHalf_finite_ftz(rgba).store(&tmp);
     tmp |= static_cast<uint64_t>(SK_Half1) << 48;
     *((uint64_t*) dst) = tmp;
 }
 
 template <SwapRB kSwapRB>
 static inline void store_generic(void* dst, const uint32_t* src,
                                  Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f&,
@@ skipping 149 matching lines @@
     kRGBA_8888_Linear_SrcFormat,
     kRGBA_8888_Table_SrcFormat,
 };
 
 enum DstFormat {
     k8888_Linear_DstFormat,
     k8888_SRGB_DstFormat,
     k8888_2Dot2_DstFormat,
     k8888_Table_DstFormat,
     kF16_Linear_DstFormat,
+    kF32_Linear_DstFormat,
 };
 
 template <SrcFormat kSrc,
           DstFormat kDst,
           SkAlphaType kAlphaType,
           ColorSpaceMatch kCSM,
           SwapRB kSwapRB>
 static void color_xform_RGBA(void* dst, const uint32_t* src, int len,
                              const float* const srcTables[3], const float matrix[16],
                              const uint8_t* const dstTables[3]) {
     LoadFn load;
     Load1Fn load_1;
+    static constexpr bool loadAlpha = (kPremul_SkAlphaType == kAlphaType) ||
+                                      (kF16_Linear_DstFormat == kDst) ||
+                                      (kF32_Linear_DstFormat == kDst);
     switch (kSrc) {
         case kRGBA_8888_Linear_SrcFormat:
-            if (kPremul_SkAlphaType == kAlphaType || kF16_Linear_DstFormat == kDst) {
+            if (loadAlpha) {
                 load = load_rgba_linear;
                 load_1 = load_rgba_linear_1;
             } else {
                 load = load_rgb_linear;
                 load_1 = load_rgb_linear_1;
             }
             break;
         case kRGBA_8888_Table_SrcFormat:
-            if (kPremul_SkAlphaType == kAlphaType || kF16_Linear_DstFormat == kDst) {
+            if (loadAlpha) {
                 load = load_rgba_from_tables;
                 load_1 = load_rgba_from_tables_1;
             } else {
                 load = load_rgb_from_tables;
                 load_1 = load_rgb_from_tables_1;
             }
             break;
     }
 
     StoreFn store;
@@ skipping 20 matching lines @@
             store_1 = store_generic_1<kSwapRB>;
             sizeOfDstPixel = 4;
             break;
         case kF16_Linear_DstFormat:
             store   = (kOpaque_SkAlphaType == kAlphaType) ? store_f16_opaque<kSwapRB> :
                                                             store_f16<kSwapRB>;
             store_1 = (kOpaque_SkAlphaType == kAlphaType) ? store_f16_1_opaque<kSwapRB> :
                                                             store_f16_1<kSwapRB>;
             sizeOfDstPixel = 8;
             break;
+        case kF32_Linear_DstFormat:
+            store   = store_f32<kSwapRB>;
+            store_1 = store_f32_1<kSwapRB>;
+            sizeOfDstPixel = 16;
+            break;
     }
 
     do_color_xform<kAlphaType, kCSM>
             (dst, src, len, srcTables, matrix, dstTables, load, load_1, store, store_1,
              sizeOfDstPixel);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static inline int num_tables(SkColorSpace* space) {
@@ skipping 72 matching lines @@
             return apply_set_alpha<kRGBA_8888_Linear_SrcFormat, kDst, kCSM, kSwap>
                     (dst, src, len, alphaType, nullptr, matrix, dstTables);
         case kTable_SrcGamma:
             return apply_set_alpha<kRGBA_8888_Table_SrcFormat, kDst, kCSM, kSwap>
                     (dst, src, len, alphaType, srcTables, matrix, dstTables);
     }
 }
 
 template <SrcGamma kSrc, DstGamma kDst, ColorSpaceMatch kCSM>
 void SkColorSpaceXform_Base<kSrc, kDst, kCSM>
-::apply(void* dst, const uint32_t* src, int len, SkColorType dstColorType, SkAlphaType alphaType)
+::apply(void* dst, const uint32_t* src, int len, ColorFormat dstColorFormat, SkAlphaType alphaType)
 const
 {
     if (kFull_ColorSpaceMatch == kCSM) {
         switch (alphaType) {
             case kPremul_SkAlphaType:
                 // We can't skip the xform since we need to perform a premultiply in the
                 // linear space.
                 break;
             default:
-                switch (dstColorType) {
-                    case kRGBA_8888_SkColorType:
+                switch (dstColorFormat) {
+                    case kRGBA_8888_ColorFormat:
                         return (void) memcpy(dst, src, len * sizeof(uint32_t));
-                    case kBGRA_8888_SkColorType:
+                    case kBGRA_8888_ColorFormat:
                         return SkOpts::RGBA_to_BGRA((uint32_t*) dst, src, len);
-                    case kRGBA_F16_SkColorType:
-                        // There's still work to do to xform to linear F16.
+                    case kRGBA_F16_ColorFormat:
+                    case kRGBA_F32_ColorFormat:
+                        // There's still work to do to xform to linear floats.
                         break;
                     default:
                         SkASSERT(false);
                         return;
                 }
         }
     }
 
     if (fColorLUT) {
         size_t storageBytes = len * sizeof(uint32_t);
 #if defined(GOOGLE3)
         // Stack frame size is limited in GOOGLE3.
         SkAutoSMalloc<256 * sizeof(uint32_t)> storage(storageBytes);
 #else
         SkAutoSMalloc<1024 * sizeof(uint32_t)> storage(storageBytes);
 #endif
 
         handle_color_lut((uint32_t*) storage.get(), src, len, fColorLUT.get());
         src = (const uint32_t*) storage.get();
     }
 
-    switch (dstColorType) {
-        case kRGBA_8888_SkColorType:
+    switch (dstColorFormat) {
+        case kRGBA_8888_ColorFormat:
             switch (kDst) {
                 case kLinear_DstGamma:
                     return apply_set_src<kSrc, k8888_Linear_DstFormat, kCSM, kNo_SwapRB>
                             (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
                 case kSRGB_DstGamma:
                     return apply_set_src<kSrc, k8888_SRGB_DstFormat, kCSM, kNo_SwapRB>
                             (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
                 case k2Dot2_DstGamma:
                     return apply_set_src<kSrc, k8888_2Dot2_DstFormat, kCSM, kNo_SwapRB>
                             (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
                 case kTable_DstGamma:
                     return apply_set_src<kSrc, k8888_Table_DstFormat, kCSM, kNo_SwapRB>
                             (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, fDstGammaTables);
             }
-        case kBGRA_8888_SkColorType:
+        case kBGRA_8888_ColorFormat:
             switch (kDst) {
                 case kLinear_DstGamma:
                     return apply_set_src<kSrc, k8888_Linear_DstFormat, kCSM, kYes_SwapRB>
                             (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
                 case kSRGB_DstGamma:
                     return apply_set_src<kSrc, k8888_SRGB_DstFormat, kCSM, kYes_SwapRB>
                             (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
                 case k2Dot2_DstGamma:
                     return apply_set_src<kSrc, k8888_2Dot2_DstFormat, kCSM, kYes_SwapRB>
                             (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
                 case kTable_DstGamma:
                     return apply_set_src<kSrc, k8888_Table_DstFormat, kCSM, kYes_SwapRB>
                             (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, fDstGammaTables);
             }
-        case kRGBA_F16_SkColorType:
+        case kRGBA_F16_ColorFormat:
             switch (kDst) {
                 case kLinear_DstGamma:
                     return apply_set_src<kSrc, kF16_Linear_DstFormat, kCSM, kNo_SwapRB>
                             (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
                 default:
                     SkASSERT(false);
                     return;
             }
+        case kRGBA_F32_ColorFormat:
+            switch (kDst) {
+                case kLinear_DstGamma:
+                    return apply_set_src<kSrc, kF32_Linear_DstFormat, kCSM, kNo_SwapRB>
+                            (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr);
+                default:
+                    SkASSERT(false);
+                    return;
+            }
         default:
             SkASSERT(false);
             return;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 std::unique_ptr<SkColorSpaceXform> SlowIdentityXform(const sk_sp<SkColorSpace>& space) {
         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
                 <kTable_SrcGamma, kTable_DstGamma, kNone_ColorSpaceMatch>
                 (space, SkMatrix::I(), space));
 }