Improve naive SkColorXform to half floats

src/opts/SkColorXform_opts.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 SkColorXform_opts_DEFINED
 #define SkColorXform_opts_DEFINED
 
@@ skipping 108 matching lines @@
                          | dstTables[1][indicesGreens[2]] << SK_G32_SHIFT
                          | dstTables[2][indicesBlues [2]] << SK_B32_SHIFT
                          | 0xFF                           << SK_A32_SHIFT;
                 dst32[3] = dstTables[0][indicesReds  [3]] << SK_R32_SHIFT
                          | dstTables[1][indicesGreens[3]] << SK_G32_SHIFT
                          | dstTables[2][indicesBlues [3]] << SK_B32_SHIFT
                          | 0xFF                           << SK_A32_SHIFT;
 
                 dst = SkTAddOffset<void>(dst, 4 * sizeof(uint32_t));
             } else {
-                // FIXME (msarett):
-                // Can we do better here?  Should we store half floats as planar?
-                // Should we write Intel/Arm specific code?  Should we add a transpose
-                // function to SkNx?  Should we rewrite the algorithm to be interleaved?
-                uint64_t* dst64 = (uint64_t*) dst;
-                dst64[0] = SkFloatToHalf_finite(Sk4f(dstReds[0], dstGreens[0], dstBlues[0], 1.0f));
-                dst64[1] = SkFloatToHalf_finite(Sk4f(dstReds[1], dstGreens[1], dstBlues[1], 1.0f));
-                dst64[2] = SkFloatToHalf_finite(Sk4f(dstReds[2], dstGreens[2], dstBlues[2], 1.0f));
-                dst64[3] = SkFloatToHalf_finite(Sk4f(dstReds[3], dstGreens[3], dstBlues[3], 1.0f));
+                Sk4h halfReds   = SkFloatToHalf_finite(dstReds);

[mtklein, 2016/07/19 15:37:47]

Might wanna just inline these instead of naming them?

Sk4h_store4(dst, SkFloatToHalf_finite(dstReds),
                 SkFloatToHalf_finite(dstGreens),
                 SkFloatToHalf_finite(dstBlues),
                 SK_Half1);

[msarett, 2016/07/19 15:47:20]

Woo cool.

+                Sk4h halfGreens = SkFloatToHalf_finite(dstGreens);
+                Sk4h halfBlues  = SkFloatToHalf_finite(dstBlues);
+                Sk4h halfAlphas = Sk4h(SK_Half1);
 
+                Sk4h_store4(dst, halfReds, halfGreens, halfBlues, halfAlphas);
                 dst = SkTAddOffset<void>(dst, 4 * sizeof(uint64_t));
             }
         };
 
         load_next_4();
 
         while (len >= 4) {
             transform_4();
             load_next_4();
             store_4();
@@ skipping 29 matching lines @@
 
             Sk4i indices = Sk4f_round(scaledPixel);
 
             *((uint32_t*) dst) = dstTables[0][indices[0]] << SK_R32_SHIFT
                                | dstTables[1][indices[1]] << SK_G32_SHIFT
                                | dstTables[2][indices[2]] << SK_B32_SHIFT
                                | 0xFF                     << SK_A32_SHIFT;
 
             dst = SkTAddOffset<void>(dst, sizeof(uint32_t));
         } else {
-            uint64_t rgba = SkFloatToHalf_finite(dstPixel);
-
-            // Set alpha to 1.0
-            rgba |= 0x3C00000000000000;
+            uint64_t rgba;
+            SkFloatToHalf_finite(dstPixel).store(&rgba);
+            rgba |= static_cast<uint64_t>(SK_Half1) << 48;
             *((uint64_t*) dst) = rgba;
             dst = SkTAddOffset<void>(dst, sizeof(uint64_t));
         }
 
         src += 1;
         len -= 1;
     }
 }
 
 static void color_xform_RGB1_to_2dot2(uint32_t* dst, const uint32_t* src, int len,
@@ skipping 13 matching lines @@
 }
 
 static void color_xform_RGB1_to_linear(uint64_t* dst, const uint32_t* src, int len,
                                        const float* const srcTables[3], const float matrix[12]) {
     color_xform_RGB1<kLinear_DstGamma>(dst, src, len, srcTables, matrix, nullptr);
 }
 
 }  // namespace SK_OPTS_NS
 
 #endif // SkColorXform_opts_DEFINED