Implement fast, correct gamma conversion for color xforms

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"
@@ skipping 19 matching lines @@
     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 (SkColorSpace::k2Dot2Curve_GammaNamed == srcSpace->gammaNamed() &&
-        SkColorSpace::k2Dot2Curve_GammaNamed == dstSpace->gammaNamed())
+    if (SkColorSpace::k2Dot2Curve_GammaNamed == dstSpace->gammaNamed() &&
+        0.0f == srcToDst.getFloat(3, 0) &&
+        0.0f == srcToDst.getFloat(3, 1) &&
+        0.0f == srcToDst.getFloat(3, 2))
     {
-        return std::unique_ptr<SkColorSpaceXform>(new Sk2Dot2Xform(srcToDst));
+        if (SkColorSpace::kSRGB_GammaNamed == srcSpace->gammaNamed()) {
+            return std::unique_ptr<SkColorSpaceXform>(new SkSRGBTo2Dot2Xform(srcToDst));
+        } else if (SkColorSpace::k2Dot2Curve_GammaNamed == srcSpace->gammaNamed()) {
+            return std::unique_ptr<SkColorSpaceXform>(new Sk2Dot2To2Dot2Xform(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:
+static void build_src_to_dst(float srcToDstArray[12], const SkMatrix44& srcToDstMatrix) {
+    // Build the following row major 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;
+    // Swap R and B if necessary to make sure that we output SkPMColor order.
+#ifdef SK_PMCOLOR_IS_BGRA
+    srcToDstArray[0] = srcToDstMatrix.getFloat(0, 2);
+    srcToDstArray[1] = srcToDstMatrix.getFloat(0, 1);
+    srcToDstArray[2] = srcToDstMatrix.getFloat(0, 0);
+    srcToDstArray[3] = 0.0f;
+    srcToDstArray[4] = srcToDstMatrix.getFloat(1, 2);
+    srcToDstArray[5] = srcToDstMatrix.getFloat(1, 1);
+    srcToDstArray[6] = srcToDstMatrix.getFloat(1, 0);
+    srcToDstArray[7] = 0.0f;
+    srcToDstArray[8] = srcToDstMatrix.getFloat(2, 2);
+    srcToDstArray[9] = srcToDstMatrix.getFloat(2, 1);
+    srcToDstArray[10] = srcToDstMatrix.getFloat(2, 0);
+    srcToDstArray[11] = 0.0f;
+#else
+    srcToDstArray[0] = srcToDstMatrix.getFloat(0, 0);
+    srcToDstArray[1] = srcToDstMatrix.getFloat(0, 1);
+    srcToDstArray[2] = srcToDstMatrix.getFloat(0, 2);
+    srcToDstArray[3] = 0.0f;
+    srcToDstArray[4] = srcToDstMatrix.getFloat(1, 0);
+    srcToDstArray[5] = srcToDstMatrix.getFloat(1, 1);
+    srcToDstArray[6] = srcToDstMatrix.getFloat(1, 2);
+    srcToDstArray[7] = 0.0f;
+    srcToDstArray[8] = srcToDstMatrix.getFloat(2, 0);
+    srcToDstArray[9] = srcToDstMatrix.getFloat(2, 1);
+    srcToDstArray[10] = srcToDstMatrix.getFloat(2, 2);
+    srcToDstArray[11] = 0.0f;
+#endif
 }
 
-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);
+SkSRGBTo2Dot2Xform::SkSRGBTo2Dot2Xform(const SkMatrix44& srcToDst)
+{
+    build_src_to_dst(fSrcToDst, srcToDst);
+}
+
+void SkSRGBTo2Dot2Xform::xform_RGB1_8888(uint32_t* dst, const uint32_t* src, uint32_t len) const {
+    SkOpts::color_xform_RGB1_srgb_to_2dot2(dst, src, len, fSrcToDst);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
+
+Sk2Dot2To2Dot2Xform::Sk2Dot2To2Dot2Xform(const SkMatrix44& srcToDst)
+{
+    build_src_to_dst(fSrcToDst, srcToDst);
+}
+
+void Sk2Dot2To2Dot2Xform::xform_RGB1_8888(uint32_t* dst, const uint32_t* src, uint32_t len) const {
+    SkOpts::color_xform_RGB1_2dot2_to_2dot2(dst, src, len, fSrcToDst);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static inline float byte_to_float(uint8_t v) {
     return ((float) v) * (1.0f / 255.0f);
 }
 
 // Expand range from 0-1 to 0-255, then convert.
 static inline uint8_t clamp_normalized_float_to_byte(float v) {
+    // The ordering of the logic is a little strange here in order
+    // to make sure we convert NaNs to 0.
     v = v * 255.0f;
     if (v >= 254.5f) {
         return 255;
-    } else if (v < 0.5f) {
+    } else if (v >= 0.5f) {
+        return (uint8_t) (v + 0.5f);
+    } else {
         return 0;
-    } else {
-        return (uint8_t) (v + 0.5f);
     }
 }
 
 // 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;
 }
@@ skipping 29 matching lines @@
     return 0.0f;
 }
 
 SkDefaultXform::SkDefaultXform(const sk_sp<SkGammas>& srcGammas, const SkMatrix44& srcToDst,
                                const sk_sp<SkGammas>& dstGammas)
     : fSrcGammas(srcGammas)
     , fSrcToDst(srcToDst)
     , fDstGammas(dstGammas)
 {}
 
-void SkDefaultXform::xform_RGBA_8888(uint32_t* dst, const uint32_t* src, uint32_t len) const {
+void SkDefaultXform::xform_RGB1_8888(uint32_t* dst, const uint32_t* src, uint32_t len) const {
     while (len-- > 0) {
         // Convert to linear.
         // FIXME (msarett):
         // Rather than support three different strategies of transforming gamma, QCMS
         // builds a 256 entry float lookup table from the gamma info.  This handles
         // the gamma transform and the conversion from bytes to floats.  This may
         // be simpler and faster than our current approach.
         float srcFloats[3];
         for (int i = 0; i < 3; i++) {
             const SkGammaCurve& gamma = (*fSrcGammas)[i];
@@ skipping 80 matching lines @@
 
         *dst = SkPackARGB32NoCheck(((*src >> 24) & 0xFF),
                                    clamp_normalized_float_to_byte(dstFloats[0]),
                                    clamp_normalized_float_to_byte(dstFloats[1]),
                                    clamp_normalized_float_to_byte(dstFloats[2]));
 
         dst++;
         src++;
     }
 }