Make SkColorSpace a public API

src/core/SkColorSpace.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 "SkAtomics.h"
 #include "SkColorSpace.h"
-#include "SkColorSpacePriv.h"
+#include "SkColorSpace_Base.h"
 #include "SkOnce.h"
 
 static bool color_space_almost_equal(float a, float b) {
     return SkTAbs(a - b) < 0.01f;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
-static int32_t gUniqueColorSpaceID;
-
-SkColorSpace::SkColorSpace(sk_sp<SkGammas> gammas, const SkMatrix44& toXYZD50, Named named)
-    : fGammas(gammas)
+SkColorSpace::SkColorSpace(GammaNamed gammaNamed, const SkMatrix44& toXYZD50, Named named)
+    : fGammaNamed(kNonStandard_GammaNamed)
     , fToXYZD50(toXYZD50)
-    , fUniqueID(sk_atomic_inc(&gUniqueColorSpaceID))
     , fNamed(named)
 {}
 
-SkColorSpace::SkColorSpace(SkColorLookUpTable* colorLUT, sk_sp<SkGammas> gammas,
-                           const SkMatrix44& toXYZD50)
-    : fColorLUT(colorLUT)
+SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkGammas> gammas, const SkMatrix44& toXYZD50,
+                                     Named named)
+    : INHERITED(kNonStandard_GammaNamed, toXYZD50, named)
     , fGammas(gammas)
-    , fToXYZD50(toXYZD50)
-    , fUniqueID(sk_atomic_inc(&gUniqueColorSpaceID))
-    , fNamed(kUnknown_Named)
+{}
+
+SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkGammas> gammas, GammaNamed gammaNamed,
+                                     const SkMatrix44& toXYZD50, Named named)
+    : INHERITED(gammaNamed, toXYZD50, named)
+    , fGammas(gammas)
+{}
+
+SkColorSpace_Base::SkColorSpace_Base(SkColorLookUpTable* colorLUT, sk_sp<SkGammas> gammas,
+                                     const SkMatrix44& toXYZD50)
+    : INHERITED(kNonStandard_GammaNamed, toXYZD50, kUnknown_Named)
+    , fColorLUT(colorLUT)
+    , fGammas(gammas)
 {}
 
 const float gSRGB_toXYZD50[] {
     0.4358f, 0.2224f, 0.0139f,    // * R
     0.3853f, 0.7170f, 0.0971f,    // * G
     0.1430f, 0.0606f, 0.7139f,    // * B
 };
 
 const float gAdobeRGB_toXYZD50[] {
     0.6098f, 0.3111f, 0.0195f,    // * R
@@ skipping 19 matching lines @@
            color_space_almost_equal(toXYZD50.getFloat(2, 2), standard[8]) &&
            color_space_almost_equal(toXYZD50.getFloat(0, 3), 0.0f) &&
            color_space_almost_equal(toXYZD50.getFloat(1, 3), 0.0f) &&
            color_space_almost_equal(toXYZD50.getFloat(2, 3), 0.0f) &&
            color_space_almost_equal(toXYZD50.getFloat(3, 0), 0.0f) &&
            color_space_almost_equal(toXYZD50.getFloat(3, 1), 0.0f) &&
            color_space_almost_equal(toXYZD50.getFloat(3, 2), 0.0f) &&
            color_space_almost_equal(toXYZD50.getFloat(3, 3), 1.0f);
 }
 
-static SkOnce gStandardGammasOnce;
-static SkGammas* gStandardGammas;
+static SkOnce g2Dot2CurveGammasOnce;
+static SkGammas* g2Dot2CurveGammas;
+static SkOnce gLinearGammasOnce;
+static SkGammas* gLinearGammas;
 
 sk_sp<SkColorSpace> SkColorSpace::NewRGB(float gammaVals[3], const SkMatrix44& toXYZD50) {
     sk_sp<SkGammas> gammas = nullptr;
+    GammaNamed gammaNamed = kNonStandard_GammaNamed;
 
     // Check if we really have sRGB or Adobe RGB
     if (color_space_almost_equal(2.2f, gammaVals[0]) &&
         color_space_almost_equal(2.2f, gammaVals[1]) &&
         color_space_almost_equal(2.2f, gammaVals[2]))
     {
-        gStandardGammasOnce([] {
-            gStandardGammas = new SkGammas(2.2f, 2.2f, 2.2f);
+        g2Dot2CurveGammasOnce([] {
+                g2Dot2CurveGammas = new SkGammas(2.2f, 2.2f, 2.2f);
         });
-        gammas = sk_ref_sp(gStandardGammas);
+        gammas = sk_ref_sp(g2Dot2CurveGammas);
+        gammaNamed = k2Dot2Curve_GammaNamed;
 
         if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
             return SkColorSpace::NewNamed(kSRGB_Named);
         } else if (xyz_almost_equal(toXYZD50, gAdobeRGB_toXYZD50)) {
             return SkColorSpace::NewNamed(kAdobeRGB_Named);
         }
+    } else if (color_space_almost_equal(1.0f, gammaVals[0]) &&
+               color_space_almost_equal(1.0f, gammaVals[1]) &&
+               color_space_almost_equal(1.0f, gammaVals[2]))
+    {
+        gLinearGammasOnce([] {
+            gLinearGammas = new SkGammas(1.0f, 1.0f, 1.0f);
+        });
+        gammas = sk_ref_sp(gLinearGammas);
+        gammaNamed = kLinear_GammaNamed;
     }
 
     if (!gammas) {
         gammas = sk_sp<SkGammas>(new SkGammas(gammaVals[0], gammaVals[1], gammaVals[2]));
     }
-    return sk_sp<SkColorSpace>(new SkColorSpace(gammas, toXYZD50, kUnknown_Named));
+    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammas, gammaNamed, toXYZD50, kUnknown_Named));
 }
 
 sk_sp<SkColorSpace> SkColorSpace::NewNamed(Named named) {
     static SkOnce sRGBOnce;
     static SkColorSpace* sRGB;
     static SkOnce adobeRGBOnce;
     static SkColorSpace* adobeRGB;
 
     switch (named) {
         case kSRGB_Named: {
-            gStandardGammasOnce([] {
-                gStandardGammas = new SkGammas(2.2f, 2.2f, 2.2f);
+            g2Dot2CurveGammasOnce([] {
+                g2Dot2CurveGammas = new SkGammas(2.2f, 2.2f, 2.2f);
             });
 
             sRGBOnce([] {
                 SkMatrix44 srgbToxyzD50(SkMatrix44::kUninitialized_Constructor);
                 srgbToxyzD50.set3x3ColMajorf(gSRGB_toXYZD50);
-                sRGB = new SkColorSpace(sk_ref_sp(gStandardGammas), srgbToxyzD50, kSRGB_Named);
+                sRGB = new SkColorSpace_Base(sk_ref_sp(g2Dot2CurveGammas), k2Dot2Curve_GammaNamed,
+                                             srgbToxyzD50, kSRGB_Named);
             });
             return sk_ref_sp(sRGB);
         }
         case kAdobeRGB_Named: {
-            gStandardGammasOnce([] {
-                gStandardGammas = new SkGammas(2.2f, 2.2f, 2.2f);
+            g2Dot2CurveGammasOnce([] {
+                g2Dot2CurveGammas = new SkGammas(2.2f, 2.2f, 2.2f);
             });
 
             adobeRGBOnce([] {
                 SkMatrix44 adobergbToxyzD50(SkMatrix44::kUninitialized_Constructor);
                 adobergbToxyzD50.set3x3ColMajorf(gAdobeRGB_toXYZD50);
-                adobeRGB = new SkColorSpace(sk_ref_sp(gStandardGammas), adobergbToxyzD50,
-                                            kAdobeRGB_Named);
+                adobeRGB = new SkColorSpace_Base(sk_ref_sp(g2Dot2CurveGammas),
+                                                 k2Dot2Curve_GammaNamed, adobergbToxyzD50,
+                                                 kAdobeRGB_Named);
             });
             return sk_ref_sp(adobeRGB);
         }
         default:
             break;
     }
     return nullptr;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ skipping 187 matching lines @@
     dst[0] = SkFixedToFloat(read_big_endian_int(src + 8));
     dst[1] = SkFixedToFloat(read_big_endian_int(src + 12));
     dst[2] = SkFixedToFloat(read_big_endian_int(src + 16));
     SkColorSpacePrintf("XYZ %g %g %g\n", dst[0], dst[1], dst[2]);
     return true;
 }
 
 static const uint32_t kTAG_CurveType     = SkSetFourByteTag('c', 'u', 'r', 'v');
 static const uint32_t kTAG_ParaCurveType = SkSetFourByteTag('p', 'a', 'r', 'a');
 
-bool SkColorSpace::LoadGammas(SkGammaCurve* gammas, uint32_t numGammas, const uint8_t* src,
-                              size_t len) {
+bool load_gammas(SkGammaCurve* gammas, uint32_t numGammas, const uint8_t* src, size_t len) {
     for (uint32_t i = 0; i < numGammas; i++) {
         if (len < 12) {
             // FIXME (msarett):
             // We could potentially return false here after correctly parsing *some* of the
             // gammas correctly.  Should we somehow try to indicate a partial success?
             SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
             return false;
         }
 
         // We need to count the number of bytes in the tag, so we are able to move to the
@@ skipping 121 matching lines @@
             src += tagBytes;
             len -= tagBytes;
         }
     }
 
     return true;
 }
 
 static const uint32_t kTAG_AtoBType = SkSetFourByteTag('m', 'A', 'B', ' ');
 
-bool SkColorSpace::LoadColorLUT(SkColorLookUpTable* colorLUT, uint32_t inputChannels,
-                                uint32_t outputChannels, const uint8_t* src, size_t len) {
+bool load_color_lut(SkColorLookUpTable* colorLUT, uint32_t inputChannels, uint32_t outputChannels,
+                    const uint8_t* src, size_t len) {
     if (len < 20) {
         SkColorSpacePrintf("Color LUT tag is too small (%d bytes).", len);
         return false;
     }
 
     SkASSERT(inputChannels <= SkColorLookUpTable::kMaxChannels && 3 == outputChannels);
     colorLUT->fInputChannels = inputChannels;
     colorLUT->fOutputChannels = outputChannels;
     uint32_t numEntries = 1;
     for (uint32_t i = 0; i < inputChannels; i++) {
@@ skipping 53 matching lines @@
     array[10] = SkFixedToFloat(read_big_endian_int(src + 32));
     array[11] = 0;
     array[12] = SkFixedToFloat(read_big_endian_int(src + 36));  // translate R
     array[13] = SkFixedToFloat(read_big_endian_int(src + 40));  // translate G
     array[14] = SkFixedToFloat(read_big_endian_int(src + 44));
     array[15] = 1;
     toXYZ->setColMajorf(array);
     return true;
 }
 
-bool SkColorSpace::LoadA2B0(SkColorLookUpTable* colorLUT, SkGammaCurve* gammas, SkMatrix44* toXYZ,
-                            const uint8_t* src, size_t len) {
+bool load_a2b0(SkColorLookUpTable* colorLUT, SkGammaCurve* gammas, SkMatrix44* toXYZ,
+               const uint8_t* src, size_t len) {
     if (len < 32) {
         SkColorSpacePrintf("A to B tag is too small (%d bytes).", len);
         return false;
     }
 
     uint32_t type = read_big_endian_uint(src);
     if (kTAG_AtoBType != type) {
         // FIXME (msarett): Need to support lut8Type and lut16Type.
         SkColorSpacePrintf("Unsupported A to B tag type.\n");
         return false;
@@ skipping 20 matching lines @@
     if ((0 != offsetToACurves) || (0 != offsetToBCurves)) {
         // FIXME (msarett): Handle A and B curves.
         // Note that the A curve is technically required in order to have a color LUT.
         // However, all the A curves I have seen so far have are just placeholders that
         // don't actually transform the data.
         SkColorSpacePrintf("Ignoring A and/or B curve.  Output may be wrong.\n");
     }
 
     uint32_t offsetToColorLUT = read_big_endian_int(src + 24);
     if (0 != offsetToColorLUT && offsetToColorLUT < len) {
-        if (!SkColorSpace::LoadColorLUT(colorLUT, inputChannels, outputChannels,
-                                        src + offsetToColorLUT, len - offsetToColorLUT)) {
+        if (!load_color_lut(colorLUT, inputChannels, outputChannels, src + offsetToColorLUT,
+                            len - offsetToColorLUT)) {
             SkColorSpacePrintf("Failed to read color LUT from A to B tag.\n");
         }
     }
 
     uint32_t offsetToMCurves = read_big_endian_int(src + 20);
     if (0 != offsetToMCurves && offsetToMCurves < len) {
-        if (!SkColorSpace::LoadGammas(gammas, outputChannels, src + offsetToMCurves,
-                                      len - offsetToMCurves)) {
+        if (!load_gammas(gammas, outputChannels, src + offsetToMCurves, len - offsetToMCurves)) {
             SkColorSpacePrintf("Failed to read M curves from A to B tag.\n");
         }
     }
 
     uint32_t offsetToMatrix = read_big_endian_int(src + 16);
     if (0 != offsetToMatrix && offsetToMatrix < len) {
         if (!load_matrix(toXYZ, src + offsetToMatrix, len - offsetToMatrix)) {
             SkColorSpacePrintf("Failed to read matrix from A to B tag.\n");
         }
     }
@@ skipping 58 matching lines @@
                 {
                     return_null("Need valid rgb tags for XYZ space");
                 }
 
                 // It is not uncommon to see missing or empty gamma tags.  This indicates
                 // that we should use unit gamma.
                 SkGammaCurve curves[3];
                 r = ICCTag::Find(tags.get(), tagCount, kTAG_rTRC);
                 g = ICCTag::Find(tags.get(), tagCount, kTAG_gTRC);
                 b = ICCTag::Find(tags.get(), tagCount, kTAG_bTRC);
-                if (!r || !SkColorSpace::LoadGammas(&curves[0], 1,
-                                                    r->addr((const uint8_t*) base), r->fLength)) {
+                if (!r || !load_gammas(&curves[0], 1, r->addr((const uint8_t*) base), r->fLength))
+                {
                     SkColorSpacePrintf("Failed to read R gamma tag.\n");
                 }
-                if (!g || !SkColorSpace::LoadGammas(&curves[1], 1,
-                                                    g->addr((const uint8_t*) base), g->fLength)) {
+                if (!g || !load_gammas(&curves[1], 1, g->addr((const uint8_t*) base), g->fLength))
+                {
                     SkColorSpacePrintf("Failed to read G gamma tag.\n");
                 }
-                if (!b || !SkColorSpace::LoadGammas(&curves[2], 1,
-                                                    b->addr((const uint8_t*) base), b->fLength)) {
+                if (!b || !load_gammas(&curves[2], 1, b->addr((const uint8_t*) base), b->fLength))
+                {
                     SkColorSpacePrintf("Failed to read B gamma tag.\n");
                 }
 
                 sk_sp<SkGammas> gammas(new SkGammas(std::move(curves[0]), std::move(curves[1]),
                                                     std::move(curves[2])));
                 SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
                 mat.set3x3ColMajorf(toXYZ);
                 if (gammas->isValues()) {
                     // When we have values, take advantage of the NewFromRGB initializer.
                     // This allows us to check for canonical sRGB and Adobe RGB.
                     float gammaVals[3];
                     gammaVals[0] = gammas->fRed.fValue;
                     gammaVals[1] = gammas->fGreen.fValue;
                     gammaVals[2] = gammas->fBlue.fValue;
                     return SkColorSpace::NewRGB(gammaVals, mat);
                 } else {
-                    return sk_sp<SkColorSpace>(new SkColorSpace(gammas, mat, kUnknown_Named));
+                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammas, mat, kUnknown_Named));
                 }
             }
 
             // Recognize color profile specified by A2B0 tag.
             const ICCTag* a2b0 = ICCTag::Find(tags.get(), tagCount, kTAG_A2B0);
             if (a2b0) {
                 SkAutoTDelete<SkColorLookUpTable> colorLUT(new SkColorLookUpTable());
                 SkGammaCurve curves[3];
                 SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
-                if (!SkColorSpace::LoadA2B0(colorLUT, curves, &toXYZ,
-                                            a2b0->addr((const uint8_t*) base), a2b0->fLength)) {
+                if (!load_a2b0(colorLUT, curves, &toXYZ, a2b0->addr((const uint8_t*) base),
+                               a2b0->fLength)) {
                     return_null("Failed to parse A2B0 tag");
                 }
 
                 sk_sp<SkGammas> gammas(new SkGammas(std::move(curves[0]), std::move(curves[1]),
                                                     std::move(curves[2])));
                 if (colorLUT->fTable) {
-                    return sk_sp<SkColorSpace>(new SkColorSpace(colorLUT.release(), gammas, toXYZ));
+                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(colorLUT.release(), gammas,
+                                                                     toXYZ));
                 } else if (gammas->isValues()) {
                     // When we have values, take advantage of the NewFromRGB initializer.
                     // This allows us to check for canonical sRGB and Adobe RGB.
                     float gammaVals[3];
                     gammaVals[0] = gammas->fRed.fValue;
                     gammaVals[1] = gammas->fGreen.fValue;
                     gammaVals[2] = gammas->fBlue.fValue;
                     return SkColorSpace::NewRGB(gammaVals, toXYZ);
                 } else {
-                    return sk_sp<SkColorSpace>(new SkColorSpace(gammas, toXYZ, kUnknown_Named));
+                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammas, toXYZ,
+                                                                     kUnknown_Named));
                 }
             }
 
         }
         default:
             break;
     }
 
     return_null("ICC profile contains unsupported colorspace");
 }