Move float<->byte conversions into Sk4f.

src/opts/SkColorCubeFilter_opts.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef SkColorCubeFilter_opts_DEFINED
 #define SkColorCubeFilter_opts_DEFINED
 
 #include "SkColor.h"
-#include "SkPMFloat.h"
+#include "SkNx.h"
 #include "SkUnPreMultiply.h"
 
 namespace SK_OPTS_NS {
 
 void color_cube_filter_span(const SkPMColor src[],
                             int count,
                             SkPMColor dst[],
                             const int* colorToIndex[2],
                             const SkScalar* colorToFactors[2],
                             int dim,
                             const SkColor* colorCube) {
-    uint8_t* ptr_dst = reinterpret_cast<uint8_t*>(dst);
     uint8_t r, g, b, a;
 
     for (int i = 0; i < count; ++i) {
         const SkPMColor input = src[i];
         a = input >> SK_A32_SHIFT;
 
         if (a != 255) {
             const SkColor source = SkUnPreMultiply::PMColorToColor(input);
             r = SkColorGetR(source);
             g = SkColorGetG(source);
@@ skipping 12 matching lines @@
         const Sk4f g0b0(g0*b0),
                    g0b1(g0*b1),
                    g1b0(g1*b0),
                    g1b1(g1*b1);
 
         const int i00 = (colorToIndex[0][g] + colorToIndex[0][b] * dim) * dim;
         const int i01 = (colorToIndex[0][g] + colorToIndex[1][b] * dim) * dim;
         const int i10 = (colorToIndex[1][g] + colorToIndex[0][b] * dim) * dim;
         const int i11 = (colorToIndex[1][g] + colorToIndex[1][b] * dim) * dim;
 
-        SkPMFloat color(0,0,0,0);
-
+        Sk4f color(0,0,0,0);
         for (int x = 0; x < 2; ++x) {
             const int ix = colorToIndex[x][r];
 
             const SkColor lutColor00 = colorCube[ix + i00];
             const SkColor lutColor01 = colorCube[ix + i01];
             const SkColor lutColor10 = colorCube[ix + i10];
             const SkColor lutColor11 = colorCube[ix + i11];
 
-            Sk4f  sum = SkPMFloat::FromOpaqueColor(lutColor00) * g0b0;
-            sum = sum + SkPMFloat::FromOpaqueColor(lutColor01) * g0b1;
-            sum = sum + SkPMFloat::FromOpaqueColor(lutColor10) * g1b0;
-            sum = sum + SkPMFloat::FromOpaqueColor(lutColor11) * g1b1;
-
+            Sk4f  sum = Sk4f::FromBytes((const uint8_t*)&lutColor00) * g0b0;
+            sum = sum + Sk4f::FromBytes((const uint8_t*)&lutColor01) * g0b1;
+            sum = sum + Sk4f::FromBytes((const uint8_t*)&lutColor10) * g1b0;
+            sum = sum + Sk4f::FromBytes((const uint8_t*)&lutColor11) * g1b1;
             color = color + sum * Sk4f((float)colorToFactors[x][r]);
         }
-
         if (a != 255) {
-            color = color * Sk4f(a * 1.0f/255);
+            color = color * Sk4f(a * (1.0f/255));
         }
 
-        dst[i] = color.round();
-

[Noel Gordon, 2015/09/01 04:00:05]

round() clamped as well.  Dose the new CL clamp?

-        ptr_dst[SK_A32_SHIFT / 8] = a;
-        ptr_dst += 4;
+        // color is BGRA (SkColor order), dst is SkPMColor order, so may need to swap R+B.
+    #if defined(SK_PMCOLOR_IS_RGBA)
+        color = Sk4f(color.kth<2>(), color.kth<1>(), color.kth<0>(), color.kth<3>());
+    #endif
+        uint8_t* dstBytes = (uint8_t*)(dst+i);
+        color.toBytes(dstBytes);
+        dstBytes[SK_A32_SHIFT/8] = a;
     }
 }
 
 }  // namespace SK_OPTS NS
 
 #endif  // SkColorCubeFilter_opts_DEFINED