Optimize color xforms with 2.2 gammas for SSE2

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 "SkColorSpaceXform.h"
+#include "SkOpts.h"
 
 static inline bool compute_gamut_xform(SkMatrix44* srcToDst, const SkMatrix44& srcToXYZ,
                                        const SkMatrix44& dstToXYZ) {
     if (!dstToXYZ.invert(srcToDst)) {
         return false;
     }
 
     srcToDst->postConcat(srcToXYZ);
     return true;
 }
 
 std::unique_ptr<SkColorSpaceXform> SkColorSpaceXform::New(const sk_sp<SkColorSpace>& srcSpace,
                                                           const sk_sp<SkColorSpace>& dstSpace) {
     if (!srcSpace || !dstSpace) {
         // Invalid input
         return nullptr;
     }
 
     if (as_CSB(srcSpace)->colorLUT() || as_CSB(dstSpace)->colorLUT()) {
         // Unimplemented
         return nullptr;
     }
 
     SkMatrix44 srcToDst(SkMatrix44::kUninitialized_Constructor);
     if (!compute_gamut_xform(&srcToDst, srcSpace->xyz(), dstSpace->xyz())) {
         return nullptr;
     }
 
-    if (as_CSB(srcSpace)->gammas()->isValues() && as_CSB(dstSpace)->gammas()->isValues()) {
-        float srcGammas[3];
-        float dstGammas[3];
-        srcGammas[0] = as_CSB(srcSpace)->gammas()->fRed.fValue;
-        srcGammas[1] = as_CSB(srcSpace)->gammas()->fGreen.fValue;
-        srcGammas[2] = as_CSB(srcSpace)->gammas()->fBlue.fValue;
-        dstGammas[0] = 1.0f / as_CSB(dstSpace)->gammas()->fRed.fValue;
-        dstGammas[1] = 1.0f / as_CSB(dstSpace)->gammas()->fGreen.fValue;
-        dstGammas[2] = 1.0f / as_CSB(dstSpace)->gammas()->fBlue.fValue;
-
-        return std::unique_ptr<SkColorSpaceXform>(
-                new SkGammaByValueXform(srcGammas, srcToDst, dstGammas));
+    if (SkColorSpace::k2Dot2Curve_GammaNamed == srcSpace->gammaNamed() &&
+        SkColorSpace::k2Dot2Curve_GammaNamed == dstSpace->gammaNamed())
+    {
+        return std::unique_ptr<SkColorSpaceXform>(new Sk2Dot2Xform(srcToDst));
     }
 
     return std::unique_ptr<SkColorSpaceXform>(
             new SkDefaultXform(as_CSB(srcSpace)->gammas(), srcToDst, as_CSB(dstSpace)->gammas()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+Sk2Dot2Xform::Sk2Dot2Xform(const SkMatrix44& srcToDst)
+{
+    // Build row major 4x4 matrix:
+    //   rX gX bX 0
+    //   rY gY bY 0
+    //   rZ gZ bZ 0
+    //   rQ gQ bQ 0
+    fSrcToDst[0] = srcToDst.getFloat(0, 0);
+    fSrcToDst[1] = srcToDst.getFloat(0, 1);
+    fSrcToDst[2] = srcToDst.getFloat(0, 2);
+    fSrcToDst[3] = 0.0f;
+    fSrcToDst[4] = srcToDst.getFloat(1, 0);
+    fSrcToDst[5] = srcToDst.getFloat(1, 1);
+    fSrcToDst[6] = srcToDst.getFloat(1, 2);
+    fSrcToDst[7] = 0.0f;
+    fSrcToDst[8] = srcToDst.getFloat(2, 0);
+    fSrcToDst[9] = srcToDst.getFloat(2, 1);
+    fSrcToDst[10] = srcToDst.getFloat(2, 2);
+    fSrcToDst[11] = 0.0f;
+    fSrcToDst[12] = srcToDst.getFloat(3, 0);
+    fSrcToDst[13] = srcToDst.getFloat(3, 1);
+    fSrcToDst[14] = srcToDst.getFloat(3, 2);
+    fSrcToDst[15] = 0.0f;
+}
+
+void Sk2Dot2Xform::xform_RGBA_8888(uint32_t* dst, const uint32_t* src, uint32_t len) const {
+    SkOpts::color_xform_2Dot2_RGBA_to_8888(dst, src, len, fSrcToDst);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
 static inline float byte_to_float(uint8_t v) {
     return ((float) v) * (1.0f / 255.0f);
 }
 
-static inline uint8_t clamp_float_to_byte(float v) {
+// Expand range from 0-1 to 0-255, then convert.
+static inline uint8_t clamp_normalized_float_to_byte(float v) {
     v = v * 255.0f;
-    if (v > 255.0f) {
+    if (v >= 254.5f) {
         return 255;
-    } else if (v <= 0.0f) {
+    } else if (v < 0.5f) {
         return 0;
     } else {
         return (uint8_t) (v + 0.5f);
     }
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-SkGammaByValueXform::SkGammaByValueXform(float srcGammas[3], const SkMatrix44& srcToDst,
-                                         float dstGammas[3])
-    : fSrcToDst(srcToDst)
-{
-    memcpy(fSrcGammas, srcGammas, 3 * sizeof(float));
-    memcpy(fDstGammas, dstGammas, 3 * sizeof(float));
-}
-
-void SkGammaByValueXform::xform_RGBA_8888(uint32_t* dst, const uint32_t* src, uint32_t len) const {
-    while (len-- > 0) {
-        float srcFloats[3];
-        srcFloats[0] = byte_to_float((*src >>  0) & 0xFF);
-        srcFloats[1] = byte_to_float((*src >>  8) & 0xFF);
-        srcFloats[2] = byte_to_float((*src >> 16) & 0xFF);
-
-        // Convert to linear.
-        srcFloats[0] = pow(srcFloats[0], fSrcGammas[0]);
-        srcFloats[1] = pow(srcFloats[1], fSrcGammas[1]);
-        srcFloats[2] = pow(srcFloats[2], fSrcGammas[2]);
-
-        // Convert to dst gamut.
-        float dstFloats[3];
-        dstFloats[0] = srcFloats[0] * fSrcToDst.getFloat(0, 0) +
-                       srcFloats[1] * fSrcToDst.getFloat(1, 0) +
-                       srcFloats[2] * fSrcToDst.getFloat(2, 0) + fSrcToDst.getFloat(3, 0);
-        dstFloats[1] = srcFloats[0] * fSrcToDst.getFloat(0, 1) +
-                       srcFloats[1] * fSrcToDst.getFloat(1, 1) +
-                       srcFloats[2] * fSrcToDst.getFloat(2, 1) + fSrcToDst.getFloat(3, 1);
-        dstFloats[2] = srcFloats[0] * fSrcToDst.getFloat(0, 2) +
-                       srcFloats[1] * fSrcToDst.getFloat(1, 2) +
-                       srcFloats[2] * fSrcToDst.getFloat(2, 2) + fSrcToDst.getFloat(3, 2);
-
-        // Convert to dst gamma.
-        dstFloats[0] = pow(dstFloats[0], fDstGammas[0]);
-        dstFloats[1] = pow(dstFloats[1], fDstGammas[1]);
-        dstFloats[2] = pow(dstFloats[2], fDstGammas[2]);
-
-        *dst = SkPackARGB32NoCheck(((*src >> 24) & 0xFF),
-                                   clamp_float_to_byte(dstFloats[0]),
-                                   clamp_float_to_byte(dstFloats[1]),
-                                   clamp_float_to_byte(dstFloats[2]));
-
-        dst++;
-        src++;
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
 // Interpolating lookup in a variably sized table.
 static inline float interp_lut(uint8_t byte, float* table, size_t tableSize) {
     float index = byte_to_float(byte) * (tableSize - 1);
     float diff = index - sk_float_floor2int(index);
     return table[(int) sk_float_floor2int(index)] * (1.0f - diff) +
             table[(int) sk_float_ceil2int(index)] * diff;
 }
 
 // Inverse table lookup.  Ex: what index corresponds to the input value?  This will
 // have strange results when the table is non-increasing.  But any sane gamma
@@ skipping 119 matching lines @@
                         dstFloats[i] = 0.0f;
                     } else {
                         dstFloats[i] = (pow(dstFloats[i] - gamma.fC, 1.0f / gamma.fG) - gamma.fB)
                                        / gamma.fA;
                     }
                 }
             }
         }
 
         *dst = SkPackARGB32NoCheck(((*src >> 24) & 0xFF),
-                                   clamp_float_to_byte(dstFloats[0]),
-                                   clamp_float_to_byte(dstFloats[1]),
-                                   clamp_float_to_byte(dstFloats[2]));
+                                   clamp_normalized_float_to_byte(dstFloats[0]),
+                                   clamp_normalized_float_to_byte(dstFloats[1]),
+                                   clamp_normalized_float_to_byte(dstFloats[2]));
 
         dst++;
         src++;
     }
 }