Differentiate between sRGBGamma and 2Dot2Gamma

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 "SkColorSpace_Base.h"
 #include "SkEndian.h"
 #include "SkOnce.h"
 
+#define SkColorSpacePrintf(...)
+
 static bool color_space_almost_equal(float a, float b) {
     return SkTAbs(a - b) < 0.01f;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
 SkColorSpace::SkColorSpace(GammaNamed gammaNamed, const SkMatrix44& toXYZD50, Named named)
     : fGammaNamed(gammaNamed)
     , fToXYZD50(toXYZD50)
     , fNamed(named)
 {}
 
-SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkGammas> gammas, const SkMatrix44& toXYZD50,
-                                     Named named, sk_sp<SkData> profileData)
-    : INHERITED(kNonStandard_GammaNamed, toXYZD50, named)
-    , fGammas(std::move(gammas))
+SkColorSpace_Base::SkColorSpace_Base(GammaNamed gammaNamed, const SkMatrix44& toXYZD50, Named named,

[msarett, 2016/06/14 21:30:28]

Now SkColorSpace's have a GammaNamed *or* the increasingly wacky SkGammas
struct.

I did this because we can't say "sRGB" with a float anymore.  But I actually
think it's logical, since we were being redundant by having a name and another
representation.

In the future, I will probably blow away SkGammas and just use a look-up table
as a fallback representation.  I *think* that's how we'll end up using all of
that info anyway.

+                                     sk_sp<SkData> profileData)
+    : INHERITED(gammaNamed, toXYZD50, named)
+    , fGammas(nullptr)
     , fProfileData(std::move(profileData))
 {}
 
-SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkGammas> gammas, GammaNamed gammaNamed,
-                                     const SkMatrix44& toXYZD50, Named named,
-                                     sk_sp<SkData> profileData)
-    : INHERITED(gammaNamed, toXYZD50, named)
-    , fGammas(std::move(gammas))
-    , fProfileData(std::move(profileData))
-{}
-
 SkColorSpace_Base::SkColorSpace_Base(SkColorLookUpTable* colorLUT, sk_sp<SkGammas> gammas,
                                      const SkMatrix44& toXYZD50, sk_sp<SkData> profileData)
     : INHERITED(kNonStandard_GammaNamed, toXYZD50, kUnknown_Named)
     , fColorLUT(colorLUT)
     , fGammas(std::move(gammas))
     , fProfileData(std::move(profileData))
 {}
 
 static constexpr float gSRGB_toXYZD50[] {
     0.4358f, 0.2224f, 0.0139f,    // * R
@@ skipping 25 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 g2Dot2CurveGammasOnce;
-static SkGammas* g2Dot2CurveGammas;
-static SkOnce gLinearGammasOnce;
-static SkGammas* gLinearGammas;
-
-sk_sp<SkColorSpace> SkColorSpace::NewRGB(const float gammaVals[3], const SkMatrix44& toXYZD50) {
-    return SkColorSpace_Base::NewRGB(gammaVals, toXYZD50, nullptr);
+static void set_gamma_value(SkGammaCurve* gamma, float value) {
+    if (color_space_almost_equal(2.2f, value)) {
+        gamma->fNamed = SkColorSpace::k2Dot2Curve_GammaNamed;
+    } else if (color_space_almost_equal(1.0f, value)) {
+        gamma->fNamed = SkColorSpace::kLinear_GammaNamed;
+    } else if (color_space_almost_equal(0.0f, value)) {
+        SkColorSpacePrintf("Treating invalid zero gamma as linear.");
+        gamma->fNamed = SkColorSpace::kLinear_GammaNamed;
+    }
 }
 
-sk_sp<SkColorSpace> SkColorSpace_Base::NewRGB(const float gammaVals[3], const SkMatrix44& toXYZD50,
-                                              sk_sp<SkData> profileData) {
-    sk_sp<SkGammas> gammas = nullptr;
-    GammaNamed gammaNamed = kNonStandard_GammaNamed;
+sk_sp<SkColorSpace> SkColorSpace_Base::NewRGB(float values[3], const SkMatrix44& toXYZD50) {
+    SkGammaCurve curves[3];
+    set_gamma_value(&curves[0], values[0]);
+    set_gamma_value(&curves[1], values[1]);
+    set_gamma_value(&curves[2], values[2]);
 
-    // 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]))
-    {
-        g2Dot2CurveGammasOnce([] {
-                g2Dot2CurveGammas = new SkGammas(2.2f, 2.2f, 2.2f);
-        });
-        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;
+    GammaNamed gammaNamed = SkGammas::Named(curves);
+    if (kNonStandard_GammaNamed == gammaNamed) {
+        sk_sp<SkGammas> gammas(new SkGammas(std::move(curves[0]), std::move(curves[1]),
+                                            std::move(curves[2])));
+        return sk_sp<SkColorSpace>(new SkColorSpace_Base(nullptr, gammas, toXYZD50, nullptr));
     }
 
-    if (!gammas) {
-        gammas = sk_sp<SkGammas>(new SkGammas(gammaVals[0], gammaVals[1], gammaVals[2]));
+    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZD50, nullptr);
+}
+
+sk_sp<SkColorSpace> SkColorSpace_Base::NewRGB(GammaNamed gammaNamed, const SkMatrix44& toXYZD50,
+                                              sk_sp<SkData> profileData) {
+    switch (gammaNamed) {
+        case kSRGB_GammaNamed:
+            if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
+                return SkColorSpace::NewNamed(kSRGB_Named);
+            }
+            break;
+        case k2Dot2Curve_GammaNamed:
+            if (xyz_almost_equal(toXYZD50, gAdobeRGB_toXYZD50)) {
+                return SkColorSpace::NewNamed(kAdobeRGB_Named);
+            }
+            break;
+        case kNonStandard_GammaNamed:
+            // This is not allowed.
+            return nullptr;
+        default:
+            break;
     }
-    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammas, gammaNamed, toXYZD50, kUnknown_Named,
-                                                     std::move(profileData)));
+
+    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammaNamed, toXYZD50, kUnknown_Named,
+                                                     profileData));
+}
+
+sk_sp<SkColorSpace> SkColorSpace::NewRGB(GammaNamed gammaNamed, const SkMatrix44& toXYZD50) {
+    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZD50, nullptr);
 }
 
 sk_sp<SkColorSpace> SkColorSpace::NewNamed(Named named) {
     static SkOnce sRGBOnce;
     static SkColorSpace* sRGB;
     static SkOnce adobeRGBOnce;
     static SkColorSpace* adobeRGB;
 
     switch (named) {
         case kSRGB_Named: {
-            g2Dot2CurveGammasOnce([] {
-                g2Dot2CurveGammas = new SkGammas(2.2f, 2.2f, 2.2f);
-            });
-
             sRGBOnce([] {
                 SkMatrix44 srgbToxyzD50(SkMatrix44::kUninitialized_Constructor);
                 srgbToxyzD50.set3x3ColMajorf(gSRGB_toXYZD50);
-                sRGB = new SkColorSpace_Base(sk_ref_sp(g2Dot2CurveGammas), k2Dot2Curve_GammaNamed,
-                                             srgbToxyzD50, kSRGB_Named, nullptr);
+                sRGB = new SkColorSpace_Base(kSRGB_GammaNamed, srgbToxyzD50, kSRGB_Named, nullptr);
             });
             return sk_ref_sp(sRGB);
         }
         case kAdobeRGB_Named: {
-            g2Dot2CurveGammasOnce([] {
-                g2Dot2CurveGammas = new SkGammas(2.2f, 2.2f, 2.2f);
-            });
-
             adobeRGBOnce([] {
                 SkMatrix44 adobergbToxyzD50(SkMatrix44::kUninitialized_Constructor);
                 adobergbToxyzD50.set3x3ColMajorf(gAdobeRGB_toXYZD50);
-                adobeRGB = new SkColorSpace_Base(sk_ref_sp(g2Dot2CurveGammas),
-                                                 k2Dot2Curve_GammaNamed, adobergbToxyzD50,
+                adobeRGB = new SkColorSpace_Base(k2Dot2Curve_GammaNamed, adobergbToxyzD50,
                                                  kAdobeRGB_Named, nullptr);
             });
             return sk_ref_sp(adobeRGB);
         }
         default:
             break;
     }
     return nullptr;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "SkFixed.h"
 #include "SkTemplates.h"
 
-#define SkColorSpacePrintf(...)
-
 #define return_if_false(pred, msg)                                   \
     do {                                                             \
         if (!(pred)) {                                               \
             SkColorSpacePrintf("Invalid ICC Profile: %s.\n", (msg)); \
             return false;                                            \
         }                                                            \
     } while (0)
 
 #define return_null(msg)                                             \
     do {                                                             \
@@ skipping 173 matching lines @@
 };
 
 static constexpr uint32_t kTAG_rXYZ = SkSetFourByteTag('r', 'X', 'Y', 'Z');
 static constexpr uint32_t kTAG_gXYZ = SkSetFourByteTag('g', 'X', 'Y', 'Z');
 static constexpr uint32_t kTAG_bXYZ = SkSetFourByteTag('b', 'X', 'Y', 'Z');
 static constexpr uint32_t kTAG_rTRC = SkSetFourByteTag('r', 'T', 'R', 'C');
 static constexpr uint32_t kTAG_gTRC = SkSetFourByteTag('g', 'T', 'R', 'C');
 static constexpr uint32_t kTAG_bTRC = SkSetFourByteTag('b', 'T', 'R', 'C');
 static constexpr uint32_t kTAG_A2B0 = SkSetFourByteTag('A', '2', 'B', '0');
 
-bool load_xyz(float dst[3], const uint8_t* src, size_t len) {
+static bool load_xyz(float dst[3], const uint8_t* src, size_t len) {
     if (len < 20) {
         SkColorSpacePrintf("XYZ tag is too small (%d bytes)", len);
         return false;
     }
 
     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 constexpr uint32_t kTAG_CurveType     = SkSetFourByteTag('c', 'u', 'r', 'v');
 static constexpr uint32_t kTAG_ParaCurveType = SkSetFourByteTag('p', 'a', 'r', 'a');
 
-bool load_gammas(SkGammaCurve* gammas, uint32_t numGammas, const uint8_t* src, size_t len) {
+static 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 11 matching lines @@
                     !safe_add((size_t) 12, tagBytes, &tagBytes))
                 {
                     SkColorSpacePrintf("Invalid gamma count");
                     return false;
                 }
 
                 if (0 == count) {
                     // Some tags require a gamma curve, but the author doesn't actually want
                     // to transform the data.  In this case, it is common to see a curve with
                     // a count of 0.
-                    gammas[i].fValue = 1.0f;
+                    gammas[i].fNamed = SkColorSpace::kLinear_GammaNamed;
                     break;
                 } else if (len < tagBytes) {
                     SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
                     return false;
                 }
 
                 const uint16_t* table = (const uint16_t*) (src + 12);
                 if (1 == count) {
                     // The table entry is the gamma (with a bias of 256).
-                    uint16_t value = read_big_endian_short((const uint8_t*) table);
-                    gammas[i].fValue = value / 256.0f;
-                    if (0.0f == gammas[i].fValue) {
-                        SkColorSpacePrintf("Cannot have zero gamma value");
-                        return false;
-                    }
-                    SkColorSpacePrintf("gamma %d %g\n", value, gammas[i].fValue);
+                    float value = (read_big_endian_short((const uint8_t*) table)) / 256.0f;
+                    set_gamma_value(&gammas[i], value);
+                    SkColorSpacePrintf("gamma %g\n", value);
                     break;
                 }
 
-                // Check for frequently occurring curves and use a fast approximation.
+                // Check for frequently occurring sRGB curves.
                 // We do this by sampling a few values and see if they match our expectation.
                 // A more robust solution would be to compare each value in this curve against
-                // a 2.2f curve see if we remain below an error threshold.  At this time,
+                // an sRGB curve to see if we remain below an error threshold.  At this time,
                 // we haven't seen any images in the wild that make this kind of
                 // calculation necessary.  We encounter identical gamma curves over and
                 // over again, but relatively few variations.
                 if (1024 == count) {
                     // The magic values were chosen because they match a very common sRGB
                     // gamma table and the less common Canon sRGB gamma table (which use
                     // different rounding rules).
                     if (0 == read_big_endian_short((const uint8_t*) &table[0]) &&
                             3366 == read_big_endian_short((const uint8_t*) &table[257]) &&
                             14116 == read_big_endian_short((const uint8_t*) &table[513]) &&
                             34318 == read_big_endian_short((const uint8_t*) &table[768]) &&
                             65535 == read_big_endian_short((const uint8_t*) &table[1023])) {
-                        gammas[i].fValue = 2.2f;
+                        gammas[i].fNamed = SkColorSpace::kSRGB_GammaNamed;
                         break;
                     }
                 } else if (26 == count) {
                     // The magic values were chosen because they match a very common sRGB
                     // gamma table.
                     if (0 == read_big_endian_short((const uint8_t*) &table[0]) &&
                             3062 == read_big_endian_short((const uint8_t*) &table[6]) &&
                             12824 == read_big_endian_short((const uint8_t*) &table[12]) &&
                             31237 == read_big_endian_short((const uint8_t*) &table[18]) &&
                             65535 == read_big_endian_short((const uint8_t*) &table[25])) {
-                        gammas[i].fValue = 2.2f;
+                        gammas[i].fNamed = SkColorSpace::kSRGB_GammaNamed;
                         break;
                     }
                 } else if (4096 == count) {
                     // The magic values were chosen because they match Nikon, Epson, and
                     // LCMS sRGB gamma tables (all of which use different rounding rules).
                     if (0 == read_big_endian_short((const uint8_t*) &table[0]) &&
                             950 == read_big_endian_short((const uint8_t*) &table[515]) &&
                             3342 == read_big_endian_short((const uint8_t*) &table[1025]) &&
                             14079 == read_big_endian_short((const uint8_t*) &table[2051]) &&
                             65535 == read_big_endian_short((const uint8_t*) &table[4095])) {
-                        gammas[i].fValue = 2.2f;
+                        gammas[i].fNamed = SkColorSpace::kSRGB_GammaNamed;
                         break;
                     }
                 }
 
                 // Otherwise, fill in the interpolation table.
                 gammas[i].fTableSize = count;
                 gammas[i].fTable = std::unique_ptr<float[]>(new float[count]);
                 for (uint32_t j = 0; j < count; j++) {
                     gammas[i].fTable[j] =
                             (read_big_endian_short((const uint8_t*) &table[j])) / 65535.0f;
@@ skipping 13 matching lines @@
                 uint16_t format = read_big_endian_short(src + 8);
                 if (kExponential_ParaCurveType == format) {
                     tagBytes = 12 + 4;
                     if (len < tagBytes) {
                         SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
                         return false;
                     }
 
                     // Y = X^g
                     int32_t g = read_big_endian_int(src + 12);
-                    gammas[i].fValue = SkFixedToFloat(g);
+                    set_gamma_value(&gammas[i], SkFixedToFloat(g));
                 } else {
                     // Here's where the real parametric gammas start.  There are many
                     // permutations of the same equations.
                     //
                     // Y = (aX + b)^g + c  for X >= d
                     // Y = eX + f          otherwise
                     //
                     // We will fill in with zeros as necessary to always match the above form.
                     float g = 0.0f, a = 0.0f, b = 0.0f, c = 0.0f, d = 0.0f, e = 0.0f, f = 0.0f;
                     switch(format) {
@@ skipping 76 matching lines @@
                     }
 
                     // Recognize and simplify a very common parametric representation of sRGB gamma.
                     if (color_space_almost_equal(0.9479f, a) &&
                             color_space_almost_equal(0.0521f, b) &&
                             color_space_almost_equal(0.0000f, c) &&
                             color_space_almost_equal(0.0405f, d) &&
                             color_space_almost_equal(0.0774f, e) &&
                             color_space_almost_equal(0.0000f, f) &&
                             color_space_almost_equal(2.4000f, g)) {
-                        gammas[i].fValue = 2.2f;
+                        gammas[i].fNamed = SkColorSpace::kSRGB_GammaNamed;
                     } else {
                         // Fail on invalid gammas.
                         if (d <= 0.0f) {
                             // Y = (aX + b)^g + c  for always
                             if (0.0f == a || 0.0f == g) {
                                 SkColorSpacePrintf("A or G is zero, constant gamma function "
                                                    "is nonsense");
                                 return false;
                             }
                         } else if (d >= 1.0f) {
@@ skipping 20 matching lines @@
                 }
 
                 break;
             }
             default:
                 SkColorSpacePrintf("Unsupported gamma tag type %d\n", type);
                 return false;
         }
 
         // Ensure that we have successfully read a gamma representation.
-        SkASSERT(gammas[i].isValue() || gammas[i].isTable() || gammas[i].isParametric());
+        SkASSERT(gammas[i].isNamed() || gammas[i].isValue() || gammas[i].isTable() ||
+                 gammas[i].isParametric());
 
         // Adjust src and len if there is another gamma curve to load.
         if (i != numGammas - 1) {
             // Each curve is padded to 4-byte alignment.
             tagBytes = SkAlign4(tagBytes);
             if (len < tagBytes) {
                 return false;
             }
 
             src += tagBytes;
@@ skipping 127 matching lines @@
     if (0 != offsetToColorLUT && offsetToColorLUT < len) {
         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 (!load_gammas(gammas, outputChannels, src + offsetToMCurves, len - offsetToMCurves)) {
-            SkColorSpacePrintf("Failed to read M curves from A to B tag.\n");
+            SkColorSpacePrintf("Failed to read M curves from A to B tag.  Using linear gamma.\n");
+            gammas[0].fNamed = SkColorSpace::kLinear_GammaNamed;
+            gammas[1].fNamed = SkColorSpace::kLinear_GammaNamed;
+            gammas[2].fNamed = SkColorSpace::kLinear_GammaNamed;
         }
     }
 
     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");
+            toXYZ->setIdentity();
         }
     }
 
     return true;
 }
 
 sk_sp<SkColorSpace> SkColorSpace::NewICC(const void* input, size_t len) {
     if (!input || len < kICCHeaderSize) {
         return_null("Data is null or not large enough to contain an ICC profile");
     }
@@ skipping 48 matching lines @@
             const ICCTag* g = ICCTag::Find(tags.get(), tagCount, kTAG_gXYZ);
             const ICCTag* b = ICCTag::Find(tags.get(), tagCount, kTAG_bXYZ);
             if (r && g && b) {
                 float toXYZ[9];
                 if (!load_xyz(&toXYZ[0], r->addr((const uint8_t*) base), r->fLength) ||
                     !load_xyz(&toXYZ[3], g->addr((const uint8_t*) base), g->fLength) ||
                     !load_xyz(&toXYZ[6], b->addr((const uint8_t*) base), b->fLength))
                 {
                     return_null("Need valid rgb tags for XYZ space");
                 }
+                SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
+                mat.set3x3ColMajorf(toXYZ);
 
                 // 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 || !load_gammas(&curves[0], 1, r->addr((const uint8_t*) base), r->fLength))
                 {
                     SkColorSpacePrintf("Failed to read R gamma tag.\n");
+                    curves[0].fNamed = SkColorSpace::kLinear_GammaNamed;
                 }
                 if (!g || !load_gammas(&curves[1], 1, g->addr((const uint8_t*) base), g->fLength))
                 {
                     SkColorSpacePrintf("Failed to read G gamma tag.\n");
+                    curves[1].fNamed = SkColorSpace::kLinear_GammaNamed;
                 }
                 if (!b || !load_gammas(&curves[2], 1, b->addr((const uint8_t*) base), b->fLength))
                 {
                     SkColorSpacePrintf("Failed to read B gamma tag.\n");
+                    curves[2].fNamed = SkColorSpace::kLinear_GammaNamed;
                 }
 
-                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_Base::NewRGB(gammaVals, mat, std::move(data));
+                GammaNamed gammaNamed = SkGammas::Named(curves);
+                if (kNonStandard_GammaNamed == gammaNamed) {
+                    sk_sp<SkGammas> gammas(new SkGammas(std::move(curves[0]), std::move(curves[1]),
+                                                        std::move(curves[2])));
+                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(nullptr, std::move(gammas),
+                                                                     mat, std::move(data)));
                 } else {
-                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(std::move(gammas), mat,
-                                                                     kUnknown_Named,
-                                                                     std::move(data)));
+                    return SkColorSpace_Base::NewRGB(gammaNamed, mat, std::move(data));
                 }
             }
 
             // 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 (!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) {
+                GammaNamed gammaNamed = SkGammas::Named(curves);
+                if (colorLUT->fTable || kNonStandard_GammaNamed == gammaNamed) {
+                    sk_sp<SkGammas> gammas(new SkGammas(std::move(curves[0]), std::move(curves[1]),
+                                                        std::move(curves[2])));
+
                     return sk_sp<SkColorSpace>(new SkColorSpace_Base(colorLUT.release(),
                                                                      std::move(gammas), toXYZ,
                                                                      std::move(data)));
-                } 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_Base::NewRGB(gammaVals, toXYZ, std::move(data));
                 } else {
-                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(std::move(gammas), toXYZ,
-                                                                     kUnknown_Named,
-                                                                     std::move(data)));
+                    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZ, std::move(data));
                 }
             }
         }
         default:
             break;
     }
 
     return_null("ICC profile contains unsupported colorspace");
 }
 
@@ skipping 119 matching lines @@
     ptr[2] = SkEndian_SwapBE32(1);
 
     // Convert gamma to 16-bit fixed point.
     uint16_t* ptr16 = (uint16_t*) (ptr + 3);
     ptr16[0] = SkEndian_SwapBE16((uint16_t) (value * 256.0f));
 
     // Pad tag with zero.
     ptr16[1] = 0;
 }
 
+static float get_gamma_value(const SkGammaCurve* curve) {
+    switch (curve->fNamed) {
+        case SkColorSpace::kSRGB_GammaNamed:
+            // FIXME (msarett): kSRGB cannot be represented by a value.
+        case SkColorSpace::k2Dot2Curve_GammaNamed:
+            return 2.2f;
+        case SkColorSpace::kLinear_GammaNamed:
+            return 1.0f;
+        default:
+            SkASSERT(curve->isValue());
+            return curve->fValue;
+    }
+}
+
 sk_sp<SkData> SkColorSpace_Base::writeToICC() const {
     // Return if this object was created from a profile, or if we have already serialized
     // the profile.
     if (fProfileData) {
         return fProfileData;
     }
 
     // The client may create an SkColorSpace using an SkMatrix44, but currently we only
     // support writing profiles with 3x3 matrices.
     // TODO (msarett): Fix this!
@@ skipping 21 matching lines @@
 
     // Write XYZ tags
     write_xyz_tag((uint32_t*) ptr, fToXYZD50, 0);
     ptr += kTAG_XYZ_Bytes;
     write_xyz_tag((uint32_t*) ptr, fToXYZD50, 1);
     ptr += kTAG_XYZ_Bytes;
     write_xyz_tag((uint32_t*) ptr, fToXYZD50, 2);
     ptr += kTAG_XYZ_Bytes;
 
     // Write TRC tags
-    SkASSERT(as_CSB(this)->fGammas->fRed.isValue());
-    write_trc_tag((uint32_t*) ptr, as_CSB(this)->fGammas->fRed.fValue);
-    ptr += SkAlign4(kTAG_TRC_Bytes);
-    SkASSERT(as_CSB(this)->fGammas->fGreen.isValue());
-    write_trc_tag((uint32_t*) ptr, as_CSB(this)->fGammas->fGreen.fValue);
-    ptr += SkAlign4(kTAG_TRC_Bytes);
-    SkASSERT(as_CSB(this)->fGammas->fBlue.isValue());
-    write_trc_tag((uint32_t*) ptr, as_CSB(this)->fGammas->fBlue.fValue);
-    ptr += SkAlign4(kTAG_TRC_Bytes);
+    GammaNamed gammaNamed = this->gammaNamed();
+    if (kNonStandard_GammaNamed == gammaNamed) {
+        write_trc_tag((uint32_t*) ptr, get_gamma_value(&as_CSB(this)->fGammas->fRed));
+        ptr += SkAlign4(kTAG_TRC_Bytes);
+        write_trc_tag((uint32_t*) ptr, get_gamma_value(&as_CSB(this)->fGammas->fGreen));
+        ptr += SkAlign4(kTAG_TRC_Bytes);
+        write_trc_tag((uint32_t*) ptr, get_gamma_value(&as_CSB(this)->fGammas->fBlue));
+        ptr += SkAlign4(kTAG_TRC_Bytes);
+    } else {
+        switch (gammaNamed) {
+            case SkColorSpace::kSRGB_GammaNamed:
+                // FIXME (msarett): kSRGB cannot be represented by a value.
+            case SkColorSpace::k2Dot2Curve_GammaNamed:
+                write_trc_tag((uint32_t*) ptr, 2.2f);
+                ptr += SkAlign4(kTAG_TRC_Bytes);
+                write_trc_tag((uint32_t*) ptr, 2.2f);
+                ptr += SkAlign4(kTAG_TRC_Bytes);
+                write_trc_tag((uint32_t*) ptr, 2.2f);
+                ptr += SkAlign4(kTAG_TRC_Bytes);
+                break;
+            case SkColorSpace::kLinear_GammaNamed:
+                write_trc_tag((uint32_t*) ptr, 1.0f);
+                ptr += SkAlign4(kTAG_TRC_Bytes);
+                write_trc_tag((uint32_t*) ptr, 1.0f);
+                ptr += SkAlign4(kTAG_TRC_Bytes);
+                write_trc_tag((uint32_t*) ptr, 1.0f);
+                ptr += SkAlign4(kTAG_TRC_Bytes);
+                break;
+            default:
+                SkASSERT(false);
+                break;
+        }
+    }
 
     // Write white point tag
     uint32_t* ptr32 = (uint32_t*) ptr;
     ptr32[0] = SkEndian_SwapBE32(kXYZ_PCSSpace);
     ptr32[1] = 0;
     // TODO (msarett): These values correspond to the D65 white point.  This may not always be
     //                 correct.
     ptr32[2] = SkEndian_SwapBE32(0x0000f351);
     ptr32[3] = SkEndian_SwapBE32(0x00010000);
     ptr32[4] = SkEndian_SwapBE32(0x000116cc);
     ptr += kTAG_XYZ_Bytes;
 
     // Write copyright tag
     memcpy(ptr, gEmptyTextTag, sizeof(gEmptyTextTag));
 
     // TODO (msarett): Should we try to hold onto the data so we can return immediately if
     //                 the client calls again?
     return SkData::MakeFromMalloc(profile.release(), kICCProfileSize);
 }