Support sRGB dsts in opt code

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 149 matching lines @@
     __m128 x64 = _mm_rsqrt_ps(x32);
 
     // x^(+29/64) = x^(+1/2) * x^(-1/32) * x^(-1/64)
     // Note that we also scale to the 0-255 range.
     // These terms can be combined more minimally with 3 muls and 1 reciprocal.  However, this
     // is faster, because it allows us to start the muls in parallel with the rsqrts.
     __m128 scale = _mm_set1_ps(255.0f);
     return _mm_mul_ps(_mm_mul_ps(_mm_mul_ps(scale, _mm_rcp_ps(x2)), x32), _mm_rcp_ps(x64));
 }
 
+static __m128 if_then_else(__m128 mask, __m128 a, __m128 b) {
+#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE41
+    return _mm_blendv_ps(b, a, mask);
+#else
+    return _mm_or_ps(_mm_and_ps(a, mask), _mm_andnot_ps(b, mask));

[mtklein, 2016/06/17 17:19:40]

and(mask, a) or andnot(mask, b)

[msarett, 2016/06/17 20:10:11]

Let's just use Sk4f haha :).

+#endif
+}
+
+// Below is a good approximation of the sRGB gamma curve (within 1 when scaled to 8-bit pixels).
+// For 0.00000f <= x <  0.00349f,    12.92 * x
+// For 0.00349f <= x <= 1.00000f,    0.679*(x.^0.5) + 0.423*x.^(0.25) - 0.101
+// Note that the intersection was selected to be a point where both functions produce the
+// same pixel value when rounded.
+static __m128 linear_to_srgb(__m128 x) {
+    __m128 rsqrt = _mm_rsqrt_ps(x);
+    __m128 sqrt  = _mm_rcp_ps(rsqrt);
+    __m128 ftrt  = _mm_rsqrt_ps(rsqrt);
+
+    __m128 hi = _mm_add_ps(_mm_add_ps(                 _mm_set1_ps(-0.101115084998961f * 255.0f),
+                                      _mm_mul_ps(sqrt, _mm_set1_ps(+0.678513029959381f * 255.0f))),
+                                      _mm_mul_ps(ftrt, _mm_set1_ps(+0.422602055039580f * 255.0f)));
+
+    __m128 lo = _mm_mul_ps(x, _mm_set1_ps(12.92f * 255.0f));
+
+    __m128 mask = _mm_cmplt_ps(x, _mm_set1_ps(0.00349f));
+    return if_then_else(mask, lo, hi);
+}
+
 static __m128 clamp_0_to_255(__m128 x) {
     // The order of the arguments is important here.  We want to make sure that NaN
     // clamps to zero.  Note that max(NaN, 0) = 0, while max(0, NaN) = NaN.
     return _mm_min_ps(_mm_max_ps(x, _mm_setzero_ps()), _mm_set1_ps(255.0f));
 }
 
-template <const float (&linear_from_curve)[256]>
+template <const float (&linear_from_curve)[256], __m128 (*linear_to_curve)(__m128)>
 static void color_xform_RGB1(uint32_t* dst, const uint32_t* src, int len,
                              const float matrix[16]) {
     // Load transformation matrix.
     __m128 rXgXbX = _mm_loadu_ps(&matrix[0]);
     __m128 rYgYbY = _mm_loadu_ps(&matrix[4]);
     __m128 rZgZbZ = _mm_loadu_ps(&matrix[8]);
 
     while (len >= 4) {
         // Convert to linear.  The look-up table has perfect accuracy.
         __m128 reds   = _mm_setr_ps(linear_from_curve[(src[0] >>  0) & 0xFF],
@@ skipping 34 matching lines @@
         __m128 bX = _mm_shuffle_ps(rXgXbX, rXgXbX, 0xAA);
         __m128 bY = _mm_shuffle_ps(rYgYbY, rYgYbY, 0xAA);
         __m128 bZ = _mm_shuffle_ps(rZgZbZ, rZgZbZ, 0xAA);
 
         // dstBlues = bX * reds + bY * greens + bZ * blues
         __m128 dstBlues =                      _mm_mul_ps(reds,   bX);
                dstBlues = _mm_add_ps(dstBlues, _mm_mul_ps(greens, bY));
                dstBlues = _mm_add_ps(dstBlues, _mm_mul_ps(blues,  bZ));
 
         // Convert to dst gamma.
-        dstReds   = linear_to_2dot2(dstReds);
-        dstGreens = linear_to_2dot2(dstGreens);
-        dstBlues  = linear_to_2dot2(dstBlues);
+        dstReds   = linear_to_curve(dstReds);
+        dstGreens = linear_to_curve(dstGreens);
+        dstBlues  = linear_to_curve(dstBlues);
 
         // Clamp floats.
         dstReds   = clamp_0_to_255(dstReds);
         dstGreens = clamp_0_to_255(dstGreens);
         dstBlues  = clamp_0_to_255(dstBlues);
 
         // Convert to bytes and store to memory.
         __m128i rgba = _mm_set1_epi32(0xFF000000);
         rgba = _mm_or_si128(rgba,                _mm_cvtps_epi32(dstReds)       );
         rgba = _mm_or_si128(rgba, _mm_slli_epi32(_mm_cvtps_epi32(dstGreens),  8));
@@ skipping 10 matching lines @@
         __m128 r = _mm_set1_ps(linear_from_curve[(src[0] >>  0) & 0xFF]),
                g = _mm_set1_ps(linear_from_curve[(src[0] >>  8) & 0xFF]),
                b = _mm_set1_ps(linear_from_curve[(src[0] >> 16) & 0xFF]);
 
         // Apply the transformation matrix to dst gamut.
         __m128 dstPixel =                      _mm_mul_ps(r, rXgXbX);
                dstPixel = _mm_add_ps(dstPixel, _mm_mul_ps(g, rYgYbY));
                dstPixel = _mm_add_ps(dstPixel, _mm_mul_ps(b, rZgZbZ));
 
         // Convert to dst gamma.
-        dstPixel = linear_to_2dot2(dstPixel);
+        dstPixel = linear_to_curve(dstPixel);
 
         // Clamp floats to 0-255 range.
         dstPixel = clamp_0_to_255(dstPixel);
 
         // Convert to bytes and store to memory.
         __m128i dstInts = _mm_cvtps_epi32(dstPixel);
         __m128i dstBytes = _mm_packus_epi16(_mm_packus_epi16(dstInts, dstInts), dstInts);
         dstBytes = _mm_or_si128(_mm_set1_epi32(0xFF000000), dstBytes);
         _mm_store_ss((float*) dst, _mm_castsi128_ps(dstBytes));
 
         dst += 1;
         src += 1;
         len -= 1;
     }
 }
 
 #else
 
+static float linear_to_2dot2(float v) {
+    return powf(v, (1.0f / 2.2f)) * 255.0f;
+}
+
+static void linear_to_srgb(float v) {
+    if (v < 0031308f) {
+        return (12.92f * v) * 255.0f;
+    } else {
+        return ((1.055f * powf(v, (1.0f / 2.4f))) - 0.055f) * 255.0f;
+    }
+}
+
 static uint8_t clamp_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.
     if (v >= 254.5f) {
         return 255;
     } else if (v >= 0.5f) {
         return (uint8_t) (v + 0.5f);
     } else {
         return 0;
     }
 }
 
-template <const float (&linear_from_curve)[256]>
+template <const float (&linear_from_curve)[256], float(*linear_to_curve)(float)>
 static void color_xform_RGB1(uint32_t* dst, const uint32_t* src, int len,
                              const float matrix[16]) {
     while (len-- > 0) {
         // Convert to linear.
         float srcFloats[3];
         srcFloats[0] = linear_from_curve[(*src >>  0) & 0xFF];
         srcFloats[1] = linear_from_curve[(*src >>  8) & 0xFF];
         srcFloats[2] = linear_from_curve[(*src >> 16) & 0xFF];
 
         // Convert to dst gamut.
         float dstFloats[3];
         dstFloats[0] = srcFloats[0] * matrix[0] + srcFloats[1] * matrix[4] +
                        srcFloats[2] * matrix[8];
         dstFloats[1] = srcFloats[0] * matrix[1] + srcFloats[1] * matrix[5] +
                        srcFloats[2] * matrix[9];
         dstFloats[2] = srcFloats[0] * matrix[2] + srcFloats[1] * matrix[6] +
                        srcFloats[2] * matrix[10];
 
         // Convert to dst gamma.
         // Note: pow is really, really slow.  We will suffer when SSE2 is not supported.
-        dstFloats[0] = powf(dstFloats[0], (1/2.2f)) * 255.0f;
-        dstFloats[1] = powf(dstFloats[1], (1/2.2f)) * 255.0f;
-        dstFloats[2] = powf(dstFloats[2], (1/2.2f)) * 255.0f;
+        dstFloats[0] = linear_to_curve(dstFloats[0]);
+        dstFloats[1] = linear_to_curve(dstFloats[1]);
+        dstFloats[2] = linear_to_curve(dstFloats[2]);
 
         *dst = (0xFF                              << 24) |
                (clamp_float_to_byte(dstFloats[2]) << 16) |
                (clamp_float_to_byte(dstFloats[1]) <<  8) |
                (clamp_float_to_byte(dstFloats[0]) <<  0);
 
         dst++;
         src++;
     }
 }
 
 #endif
 
 static void color_xform_RGB1_srgb_to_2dot2(uint32_t* dst, const uint32_t* src, int len,
                                            const float matrix[16]) {
-    color_xform_RGB1<linear_from_srgb>(dst, src, len, matrix);
+    color_xform_RGB1<linear_from_srgb, linear_to_2dot2>(dst, src, len, matrix);
 }
 
 static void color_xform_RGB1_2dot2_to_2dot2(uint32_t* dst, const uint32_t* src, int len,
                                            const float matrix[16]) {
-    color_xform_RGB1<linear_from_2dot2>(dst, src, len, matrix);
+    color_xform_RGB1<linear_from_2dot2, linear_to_2dot2>(dst, src, len, matrix);
+}
+
+static void color_xform_RGB1_srgb_to_srgb(uint32_t* dst, const uint32_t* src, int len,
+                                           const float matrix[16]) {
+    color_xform_RGB1<linear_from_srgb, linear_to_srgb>(dst, src, len, matrix);
+}
+
+static void color_xform_RGB1_2dot2_to_srgb(uint32_t* dst, const uint32_t* src, int len,
+                                           const float matrix[16]) {
+    color_xform_RGB1<linear_from_2dot2, linear_to_srgb>(dst, src, len, matrix);
 }
 
 }
 
 #endif // SkColorXform_opts_DEFINED