Add SkColorSpace to SkImageInfo

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 "SkColorSpace.h"
 #include "SkColorSpacePriv.h"
 #include "SkOnce.h"
 
 static bool color_space_almost_equal(float a, float b) {
     return SkTAbs(a - b) < 0.01f;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
 SkColorSpace::SkColorSpace(sk_sp<SkGammas> gammas, const SkMatrix44& toXYZD50, Named named)
     : fGammas(gammas)
+    , fGammaNamed(kNonStandard_GammaNamed)
     , fToXYZD50(toXYZD50)
     , fNamed(named)
 {}
+
+SkColorSpace::SkColorSpace(sk_sp<SkGammas> gammas, GammaNamed gammaNamed,
+                           const SkMatrix44& toXYZD50, Named named)
+    : fGammas(gammas)
+    , fGammaNamed(gammaNamed)
+    , fToXYZD50(toXYZD50)
+    , fNamed(named)
+{}
 
 SkColorSpace::SkColorSpace(SkColorLookUpTable* colorLUT, sk_sp<SkGammas> gammas,
                            const SkMatrix44& toXYZD50)
     : fColorLUT(colorLUT)
     , fGammas(gammas)
+    , fGammaNamed(kNonStandard_GammaNamed)
     , fToXYZD50(toXYZD50)
     , fNamed(kUnknown_Named)
 {}
 
 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
 };
 
@@ skipping 21 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 gSRGBCurveGammasOnce;
+static SkGammas* gSRGBCurveGammas;
+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);
+        gSRGBCurveGammasOnce([] {
+            gSRGBCurveGammas = new SkGammas(2.2f, 2.2f, 2.2f);
         });
-        gammas = sk_ref_sp(gStandardGammas);
+        gammas = sk_ref_sp(gSRGBCurveGammas);
+        gammaNamed = kSRGBCurve_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(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);
+            gSRGBCurveGammasOnce([] {
+                gSRGBCurveGammas = 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(sk_ref_sp(gSRGBCurveGammas), kSRGBCurve_GammaNamed,
+                                        srgbToxyzD50, kSRGB_Named);
             });
             return sk_ref_sp(sRGB);
         }
         case kAdobeRGB_Named: {
-            gStandardGammasOnce([] {
-                gStandardGammas = new SkGammas(2.2f, 2.2f, 2.2f);
+            // Note that AdobeRGB has a very similar gamma curve to sRGB.
+            gSRGBCurveGammasOnce([] {
+                gSRGBCurveGammas = 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(sk_ref_sp(gSRGBCurveGammas), kSRGBCurve_GammaNamed,
+                                            adobergbToxyzD50, kAdobeRGB_Named);
             });
             return sk_ref_sp(adobeRGB);
         }
         default:
             break;
     }
     return nullptr;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ skipping 600 matching lines @@
                 }
             }
 
         }
         default:
             break;
     }
 
     return_null("ICC profile contains unsupported colorspace");
 }