Refactor of SkColorSpaceXformOpts

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"
+#include "SkColorSpaceXformOpts.h"
 #include "SkSRGB.h"
 
 static constexpr float sk_linear_from_2dot2[256] = {
         0.000000000000000000f, 0.000005077051900662f, 0.000023328004666099f, 0.000056921765712193f,
         0.000107187362341244f, 0.000175123977503027f, 0.000261543754548491f, 0.000367136269815943f,
         0.000492503787191433f, 0.000638182842167022f, 0.000804658499513058f, 0.000992374304074325f,
         0.001201739522438400f, 0.001433134589671860f, 0.001686915316789280f, 0.001963416213396470f,
         0.002262953160706430f, 0.002585825596234170f, 0.002932318323938360f, 0.003302703032003640f,
         0.003697239578900130f, 0.004116177093282750f, 0.004559754922526020f, 0.005028203456855540f,
         0.005521744850239660f, 0.006040593654849810f, 0.006584957382581690f, 0.007155037004573030f,
@@ skipping 49 matching lines @@
         0.751895080583051000f, 0.759299550695091000f, 0.766743616862161000f, 0.774227314218442000f,
         0.781750677773962000f, 0.789313742415586000f, 0.796916542907978000f, 0.804559113894567000f,
         0.812241489898490000f, 0.819963705323528000f, 0.827725794455034000f, 0.835527791460841000f,
         0.843369730392169000f, 0.851251645184515000f, 0.859173569658532000f, 0.867135537520905000f,
         0.875137582365205000f, 0.883179737672745000f, 0.891262036813419000f, 0.899384513046529000f,
         0.907547199521614000f, 0.915750129279253000f, 0.923993335251873000f, 0.932276850264543000f,
         0.940600707035753000f, 0.948964938178195000f, 0.957369576199527000f, 0.965814653503130000f,
         0.974300202388861000f, 0.982826255053791000f, 0.991392843592940000f, 1.000000000000000000f,
 };
 
-static void build_table_linear_from_gamma(float* outTable, float exponent) {
-    for (float x = 0.0f; x <= 1.0f; x += (1.0f/255.0f)) {
-        *outTable++ = powf(x, exponent);
-    }
-}
-
-// Interpolating lookup in a variably sized table.
-static float interp_lut(float input, const float* table, int tableSize) {
-    float index = input * (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;
-}
-
-// outTable is always 256 entries, inTable may be larger or smaller.
-static void build_table_linear_from_gamma(float* outTable, const float* inTable,
-                                          int inTableSize) {
-    if (256 == inTableSize) {
-        memcpy(outTable, inTable, sizeof(float) * 256);
-        return;
-    }
-
-    for (float x = 0.0f; x <= 1.0f; x += (1.0f/255.0f)) {
-        *outTable++ = interp_lut(x, inTable, inTableSize);
-    }
-}
-
-static void build_table_linear_from_gamma(float* outTable, float g, float a, float b, float c,
-                                          float d, float e, float f) {
-    // Y = (aX + b)^g + c  for X >= d
-    // Y = eX + f          otherwise
-    for (float x = 0.0f; x <= 1.0f; x += (1.0f/255.0f)) {
-        if (x >= d) {
-            *outTable++ = powf(a * x + b, g) + c;
-        } else {
-            *outTable++ = e * x + f;
-        }
-    }
-}
-
-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;
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static constexpr uint8_t linear_to_srgb[1024] = {
           0,   3,   6,  10,  13,  15,  18,  20,  22,  23,  25,  27,  28,  30,  31,  32,  34,  35,
          36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  49,  50,  51,  52,
          53,  53,  54,  55,  56,  56,  57,  58,  58,  59,  60,  61,  61,  62,  62,  63,  64,  64,
          65,  66,  66,  67,  67,  68,  68,  69,  70,  70,  71,  71,  72,  72,  73,  73,  74,  74,
          75,  76,  76,  77,  77,  78,  78,  79,  79,  79,  80,  80,  81,  81,  82,  82,  83,  83,
          84,  84,  85,  85,  85,  86,  86,  87,  87,  88,  88,  88,  89,  89,  90,  90,  91,  91,
          91,  92,  92,  93,  93,  93,  94,  94,  95,  95,  95,  96,  96,  97,  97,  97,  98,  98,
@@ skipping 42 matching lines @@
         239, 239, 239, 239, 239, 239, 240, 240, 240, 240, 240, 240, 240, 240, 241, 241, 241, 241,
         241, 241, 241, 241, 241, 242, 242, 242, 242, 242, 242, 242, 242, 243, 243, 243, 243, 243,
         243, 243, 243, 243, 244, 244, 244, 244, 244, 244, 244, 244, 245, 245, 245, 245, 245, 245,
         245, 245, 245, 246, 246, 246, 246, 246, 246, 246, 246, 246, 247, 247, 247, 247, 247, 247,
         247, 247, 248, 248, 248, 248, 248, 248, 248, 248, 248, 249, 249, 249, 249, 249, 249, 249,
         249, 249, 250, 250, 250, 250, 250, 250, 250, 250, 250, 251, 251, 251, 251, 251, 251, 251,
         251, 251, 252, 252, 252, 252, 252, 252, 252, 252, 252, 253, 253, 253, 253, 253, 253, 253,
         253, 253, 254, 254, 254, 254, 254, 254, 254, 254, 254, 255, 255, 255, 255, 255
 };
 
-static constexpr uint8_t linear_to_2dot2[1024] = {
+static constexpr uint8_t linear_to_2dot2_table[1024] = {
           0,  11,  15,  18,  21,  23,  25,  26,  28,  30,  31,  32,  34,  35,  36,  37,  39,  40,
          41,  42,  43,  44,  45,  45,  46,  47,  48,  49,  50,  50,  51,  52,  53,  54,  54,  55,
          56,  56,  57,  58,  58,  59,  60,  60,  61,  62,  62,  63,  63,  64,  65,  65,  66,  66,
          67,  68,  68,  69,  69,  70,  70,  71,  71,  72,  72,  73,  73,  74,  74,  75,  75,  76,
          76,  77,  77,  78,  78,  79,  79,  80,  80,  81,  81,  81,  82,  82,  83,  83,  84,  84,
          84,  85,  85,  86,  86,  87,  87,  87,  88,  88,  89,  89,  89,  90,  90,  91,  91,  91,
          92,  92,  93,  93,  93,  94,  94,  94,  95,  95,  96,  96,  96,  97,  97,  97,  98,  98,
          98,  99,  99,  99, 100, 100, 101, 101, 101, 102, 102, 102, 103, 103, 103, 104, 104, 104,
         105, 105, 105, 106, 106, 106, 107, 107, 107, 108, 108, 108, 108, 109, 109, 109, 110, 110,
         110, 111, 111, 111, 112, 112, 112, 112, 113, 113, 113, 114, 114, 114, 115, 115, 115, 115,
@@ skipping 39 matching lines @@
         238, 238, 239, 239, 239, 239, 239, 239, 239, 239, 240, 240, 240, 240, 240, 240, 240, 240,
         241, 241, 241, 241, 241, 241, 241, 241, 242, 242, 242, 242, 242, 242, 242, 242, 243, 243,
         243, 243, 243, 243, 243, 243, 243, 244, 244, 244, 244, 244, 244, 244, 244, 245, 245, 245,
         245, 245, 245, 245, 245, 245, 246, 246, 246, 246, 246, 246, 246, 246, 247, 247, 247, 247,
         247, 247, 247, 247, 248, 248, 248, 248, 248, 248, 248, 248, 248, 249, 249, 249, 249, 249,
         249, 249, 249, 249, 250, 250, 250, 250, 250, 250, 250, 250, 251, 251, 251, 251, 251, 251,
         251, 251, 251, 252, 252, 252, 252, 252, 252, 252, 252, 252, 253, 253, 253, 253, 253, 253,
         253, 253, 254, 254, 254, 254, 254, 254, 254, 254, 254, 255, 255, 255, 255, 255,
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+static void build_table_linear_from_gamma(float* outTable, float exponent) {
+    for (float x = 0.0f; x <= 1.0f; x += (1.0f/255.0f)) {
+        *outTable++ = powf(x, exponent);
+    }
+}
+
+// Interpolating lookup in a variably sized table.
+static float interp_lut(float input, const float* table, int tableSize) {
+    float index = input * (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;
+}
+
+// outTable is always 256 entries, inTable may be larger or smaller.
+static void build_table_linear_from_gamma(float* outTable, const float* inTable,
+                                          int inTableSize) {
+    if (256 == inTableSize) {
+        memcpy(outTable, inTable, sizeof(float) * 256);
+        return;
+    }
+
+    for (float x = 0.0f; x <= 1.0f; x += (1.0f/255.0f)) {
+        *outTable++ = interp_lut(x, inTable, inTableSize);
+    }
+}
+
+static void build_table_linear_from_gamma(float* outTable, float g, float a, float b, float c,
+                                          float d, float e, float f) {
+    // Y = (aX + b)^g + c  for X >= d
+    // Y = eX + f          otherwise
+    for (float x = 0.0f; x <= 1.0f; x += (1.0f/255.0f)) {
+        if (x >= d) {
+            *outTable++ = powf(a * x + b, g) + c;
+        } else {
+            *outTable++ = e * x + f;
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
 // Expand range from 0-1 to 0-255, then convert.
 static 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) {
         return (uint8_t) (v + 0.5f);
     } else {
@@ skipping 103 matching lines @@
 static const GammaFns<float> kToLinear {
     sk_linear_from_srgb,
     sk_linear_from_2dot2,
     &build_table_linear_from_gamma,
     &build_table_linear_from_gamma,
     &build_table_linear_from_gamma,
 };
 
 static const GammaFns<uint8_t> kFromLinear {
     linear_to_srgb,
-    linear_to_2dot2,
+    linear_to_2dot2_table,
     &build_table_linear_to_gamma,
     &build_table_linear_to_gamma,
     &build_table_linear_to_gamma,
 };
 
 // Build tables to transform src gamma to linear.
 template <typename T>
 static void build_gamma_tables(const T* outGammaTables[3], T* gammaTableStorage, int gammaTableSize,
                                const sk_sp<SkColorSpace>& space, const GammaFns<T>& fns) {
     switch (space->gammaNamed()) {
@@ skipping 55 matching lines @@
                                            params.fF);
                     outGammaTables[i] = &gammaTableStorage[i * gammaTableSize];
                 }
             }
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+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(dstSpace)->colorLUT()) {
         // It would be really weird for a dst profile to have a color LUT.  I don't think
         // we need to support this.
@@ skipping 146 matching lines @@
         b = sk_float_round2int(255.0f * clamp_normalized_float(out[2]));
         *dst = SkPackARGB_as_RGBA(0xFF, r, g, b);
 
         src++;
         dst++;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-template <SkColorSpace::GammaNamed Dst>
-SkColorSpaceXform_Base<Dst>::SkColorSpaceXform_Base(const sk_sp<SkColorSpace>& srcSpace,
+template <SkColorSpace::GammaNamed kDst>
+SkColorSpaceXform_Base<kDst>::SkColorSpaceXform_Base(const sk_sp<SkColorSpace>& srcSpace,
                                                     const SkMatrix44& srcToDst,
                                                     const sk_sp<SkColorSpace>& dstSpace)
     : fColorLUT(sk_ref_sp((SkColorLookUpTable*) as_CSB(srcSpace)->colorLUT()))
 {
     srcToDst.asRowMajorf(fSrcToDst);
     build_gamma_tables(fSrcGammaTables, fSrcGammaTableStorage, 256, srcSpace, kToLinear);
     build_gamma_tables(fDstGammaTables, fDstGammaTableStorage, kDstGammaTableSize,
                        dstSpace, kFromLinear);
 }
 
 template <>
 void SkColorSpaceXform_Base<SkColorSpace::kSRGB_GammaNamed>
 ::applyToRGBA(RGBA32* dst, const RGBA32* src, int len) const
 {
     if (fColorLUT) {
         handle_color_lut(dst, src, len, fColorLUT.get());
         src = dst;
     }
 
-    SkOpts::color_xform_RGB1_to_srgb(dst, src, len, fSrcGammaTables, fSrcToDst);
+    color_xform_RGBA<SkColorSpace::kSRGB_GammaNamed, false, false>
+            (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
 }
 
 template <>
 void SkColorSpaceXform_Base<SkColorSpace::k2Dot2Curve_GammaNamed>
 ::applyToRGBA(RGBA32* dst, const RGBA32* src, int len) const
 {
     if (fColorLUT) {
         handle_color_lut(dst, src, len, fColorLUT.get());
         src = dst;
     }
 
-    SkOpts::color_xform_RGB1_to_2dot2(dst, src, len, fSrcGammaTables, fSrcToDst);
+    color_xform_RGBA<SkColorSpace::k2Dot2Curve_GammaNamed, false, false>
+            (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
 }
 
 template <>
 void SkColorSpaceXform_Base<SkColorSpace::kNonStandard_GammaNamed>
 ::applyToRGBA(RGBA32* dst, const RGBA32* src, int len) const
 {
     if (fColorLUT) {
         handle_color_lut(dst, src, len, fColorLUT.get());
         src = dst;
     }
 
-    SkOpts::color_xform_RGB1_to_table(dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
+    color_xform_RGBA<SkColorSpace::kNonStandard_GammaNamed, false, false>
+            (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
 }
 
 template <>
 void SkColorSpaceXform_Base<SkColorSpace::kSRGB_GammaNamed>
 ::applyToBGRA(BGRA32* dst, const RGBA32* src, int len) const
 {
     if (fColorLUT) {
         handle_color_lut(dst, src, len, fColorLUT.get());
         src = dst;
     }
 
-    SkOpts::color_xform_RGB1_to_srgb_swaprb(dst, src, len, fSrcGammaTables, fSrcToDst);
+    color_xform_RGBA<SkColorSpace::kSRGB_GammaNamed, false, true>
+            (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
 }
 
 template <>
 void SkColorSpaceXform_Base<SkColorSpace::k2Dot2Curve_GammaNamed>
 ::applyToBGRA(BGRA32* dst, const RGBA32* src, int len) const
 {
     if (fColorLUT) {
         handle_color_lut(dst, src, len, fColorLUT.get());
         src = dst;
     }
 
-    SkOpts::color_xform_RGB1_to_2dot2_swaprb(dst, src, len, fSrcGammaTables, fSrcToDst);
+    color_xform_RGBA<SkColorSpace::k2Dot2Curve_GammaNamed, false, true>
+            (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
 }
 
 template <>
 void SkColorSpaceXform_Base<SkColorSpace::kNonStandard_GammaNamed>
 ::applyToBGRA(BGRA32* dst, const RGBA32* src, int len) const
 {
     if (fColorLUT) {
         handle_color_lut(dst, src, len, fColorLUT.get());
         src = dst;
     }
 
-    SkOpts::color_xform_RGB1_to_table_swaprb(dst, src, len, fSrcGammaTables, fSrcToDst,
-                                             fDstGammaTables);
+    color_xform_RGBA<SkColorSpace::kNonStandard_GammaNamed, false, true>
+            (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
 }
 
 template <SkColorSpace::GammaNamed T>
 void SkColorSpaceXform_Base<T>
 ::applyToF16(RGBAF16* dst, const RGBA32* src, int len) const
 {
     if (fColorLUT) {
         size_t storageBytes = len * sizeof(RGBA32);
 #if defined(GOOGLE3)
         // Stack frame size is limited in GOOGLE3.
         SkAutoSMalloc<256 * sizeof(RGBA32)> storage(storageBytes);
 #else
         SkAutoSMalloc<1024 * sizeof(RGBA32)> storage(storageBytes);
 #endif
 
         handle_color_lut((RGBA32*) storage.get(), src, len, fColorLUT.get());
         src = (const RGBA32*) storage.get();
     }
 
-    SkOpts::color_xform_RGB1_to_linear(dst, src, len, fSrcGammaTables, fSrcToDst);
+    color_xform_RGBA<SkColorSpace::kLinear_GammaNamed, false, false>
+            (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
 }