Write ICC profiles from SkColorSpace object

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"
 
 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(kNonStandard_GammaNamed)
     , fToXYZD50(toXYZD50)
     , fNamed(named)
 {}
 
 SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkGammas> gammas, const SkMatrix44& toXYZD50,
-                                     Named named)
+                                     Named named, sk_sp<SkData> profileData)
     : INHERITED(kNonStandard_GammaNamed, toXYZD50, named)
     , fGammas(std::move(gammas))
+    , fProfileData(std::move(profileData))
 {}
 
 SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkGammas> gammas, GammaNamed gammaNamed,
-                                     const SkMatrix44& toXYZD50, Named named)
+                                     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)
+                                     const SkMatrix44& toXYZD50, sk_sp<SkData> profileData)
     : INHERITED(kNonStandard_GammaNamed, toXYZD50, kUnknown_Named)
     , fColorLUT(colorLUT)
     , fGammas(std::move(gammas))
+    , fProfileData(std::move(profileData))
 {}
 
-const float gSRGB_toXYZD50[] {
+static constexpr 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[] {
+static constexpr float gAdobeRGB_toXYZD50[] {
     0.6098f, 0.3111f, 0.0195f,    // * R
     0.2052f, 0.6257f, 0.0609f,    // * G
     0.1492f, 0.0632f, 0.7448f,    // * B
 };
 
 /**
  *  Checks if our toXYZ matrix is a close match to a known color gamut.
  *
  *  @param toXYZD50 transformation matrix deduced from profile data
  *  @param standard 3x3 canonical transformation matrix
@@ skipping 16 matching lines @@
            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);
+}
+
+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;
 
     // 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);
@@ skipping 13 matching lines @@
         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_Base(gammas, gammaNamed, toXYZD50, kUnknown_Named));
+    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammas, gammaNamed, toXYZD50, kUnknown_Named,
+                                                     std::move(profileData)));
 }
 
 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);
+                                             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,
-                                                 kAdobeRGB_Named);
+                                                 kAdobeRGB_Named, nullptr);
             });
             return sk_ref_sp(adobeRGB);
         }
         default:
             break;
     }
     return nullptr;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ skipping 25 matching lines @@
     return ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3];
 }
 
 static int32_t read_big_endian_int(const uint8_t* ptr) {
     return (int32_t) read_big_endian_uint(ptr);
 }
 
 // This is equal to the header size according to the ICC specification (128)
 // plus the size of the tag count (4).  We include the tag count since we
 // always require it to be present anyway.
-static const size_t kICCHeaderSize = 132;
+static constexpr size_t kICCHeaderSize = 132;
 
 // Contains a signature (4), offset (4), and size (4).
-static const size_t kICCTagTableEntrySize = 12;
+static constexpr size_t kICCTagTableEntrySize = 12;
 
-static const uint32_t kRGB_ColorSpace  = SkSetFourByteTag('R', 'G', 'B', ' ');
+static constexpr uint32_t kRGB_ColorSpace  = SkSetFourByteTag('R', 'G', 'B', ' ');
+static constexpr uint32_t kDisplay_Profile = SkSetFourByteTag('m', 'n', 't', 'r');
+static constexpr uint32_t kInput_Profile   = SkSetFourByteTag('s', 'c', 'n', 'r');
+static constexpr uint32_t kOutput_Profile  = SkSetFourByteTag('p', 'r', 't', 'r');
+static constexpr uint32_t kXYZ_PCSSpace    = SkSetFourByteTag('X', 'Y', 'Z', ' ');
+static constexpr uint32_t kACSP_Signature  = SkSetFourByteTag('a', 'c', 's', 'p');
 
 struct ICCProfileHeader {
     uint32_t fSize;
 
     // No reason to care about the preferred color management module (ex: Adobe, Apple, etc.).
     // We're always going to use this one.
     uint32_t fCMMType_ignored;
 
     uint32_t fVersion;
     uint32_t fProfileClass;
@@ skipping 45 matching lines @@
 
     bool valid() const {
         return_if_false(fSize >= kICCHeaderSize, "Size is too small");
 
         uint8_t majorVersion = fVersion >> 24;
         return_if_false(majorVersion <= 4, "Unsupported version");
 
         // These are the three basic classes of profiles that we might expect to see embedded
         // in images.  Four additional classes exist, but they generally are used as a convenient
         // way for CMMs to store calculated transforms.
-        const uint32_t kDisplay_Profile = SkSetFourByteTag('m', 'n', 't', 'r');
-        const uint32_t kInput_Profile   = SkSetFourByteTag('s', 'c', 'n', 'r');
-        const uint32_t kOutput_Profile  = SkSetFourByteTag('p', 'r', 't', 'r');
         return_if_false(fProfileClass == kDisplay_Profile ||
                         fProfileClass == kInput_Profile ||
                         fProfileClass == kOutput_Profile,
                         "Unsupported profile");
 
         // TODO (msarett):
         // All the profiles we've tested so far use RGB as the input color space.
         return_if_false(fInputColorSpace == kRGB_ColorSpace, "Unsupported color space");
 
         // TODO (msarett):
         // All the profiles we've tested so far use XYZ as the profile connection space.
-        const uint32_t kXYZ_PCSSpace = SkSetFourByteTag('X', 'Y', 'Z', ' ');
         return_if_false(fPCS == kXYZ_PCSSpace, "Unsupported PCS space");
 
-        return_if_false(fSignature == SkSetFourByteTag('a', 'c', 's', 'p'), "Bad signature");
+        return_if_false(fSignature == kACSP_Signature, "Bad signature");
 
         // TODO (msarett):
         // Should we treat different rendering intents differently?
         // Valid rendering intents include kPerceptual (0), kRelative (1),
         // kSaturation (2), and kAbsolute (3).
         return_if_false(fRenderingIntent <= 3, "Bad rendering intent");
 
         return_if_false(color_space_almost_equal(SkFixedToFloat(fIlluminantXYZ[0]), 0.96420f) &&
                         color_space_almost_equal(SkFixedToFloat(fIlluminantXYZ[1]), 1.00000f) &&
                         color_space_almost_equal(SkFixedToFloat(fIlluminantXYZ[2]), 0.82491f),
@@ skipping 29 matching lines @@
     static const ICCTag* Find(const ICCTag tags[], int count, uint32_t signature) {
         for (int i = 0; i < count; ++i) {
             if (tags[i].fSignature == signature) {
                 return &tags[i];
             }
         }
         return nullptr;
     }
 };
 
-static const uint32_t kTAG_rXYZ = SkSetFourByteTag('r', 'X', 'Y', 'Z');
-static const uint32_t kTAG_gXYZ = SkSetFourByteTag('g', 'X', 'Y', 'Z');
-static const uint32_t kTAG_bXYZ = SkSetFourByteTag('b', 'X', 'Y', 'Z');
-static const uint32_t kTAG_rTRC = SkSetFourByteTag('r', 'T', 'R', 'C');
-static const uint32_t kTAG_gTRC = SkSetFourByteTag('g', 'T', 'R', 'C');
-static const uint32_t kTAG_bTRC = SkSetFourByteTag('b', 'T', 'R', 'C');
-static const uint32_t kTAG_A2B0 = SkSetFourByteTag('A', '2', 'B', '0');
+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) {
     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 const uint32_t kTAG_CurveType     = SkSetFourByteTag('c', 'u', 'r', 'v');
-static const uint32_t kTAG_ParaCurveType = SkSetFourByteTag('p', 'a', 'r', 'a');
+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) {
     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;
         }
@@ skipping 187 matching lines @@
             }
 
             src += tagBytes;
             len -= tagBytes;
         }
     }
 
     return true;
 }
 
-static const uint32_t kTAG_AtoBType = SkSetFourByteTag('m', 'A', 'B', ' ');
+static constexpr uint32_t kTAG_AtoBType = SkSetFourByteTag('m', 'A', 'B', ' ');
 
 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;
@@ skipping 121 matching lines @@
     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");
         }
     }
 
     return true;
 }
 
-sk_sp<SkColorSpace> SkColorSpace::NewICC(const void* base, size_t len) {
-    const uint8_t* ptr = (const uint8_t*) base;
-
+sk_sp<SkColorSpace> SkColorSpace::NewICC(const void* input, size_t len) {
     if (len < kICCHeaderSize) {
         return_null("Data is not large enough to contain an ICC profile");
     }
 
+    // Create our own copy of the input.
+    void* memory = sk_malloc_throw(len);
+    memcpy(memory, input, len);
+    sk_sp<SkData> data = SkData::MakeFromMalloc(memory, len);
+    const void* base = data->data();
+    const uint8_t* ptr = (const uint8_t*) base;
+
     // Read the ICC profile header and check to make sure that it is valid.
     ICCProfileHeader header;
     header.init(ptr, len);
     if (!header.valid()) {
         return nullptr;
     }
 
     // Adjust ptr and len before reading the tags.
     if (len < header.fSize) {
         SkColorSpacePrintf("ICC profile might be truncated.\n");
@@ skipping 61 matching lines @@
                                                     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);
+                    return SkColorSpace_Base::NewRGB(gammaVals, mat, std::move(data));
                 } else {
                     return sk_sp<SkColorSpace>(new SkColorSpace_Base(std::move(gammas), mat,
-                                                                     kUnknown_Named));
+                                                                     kUnknown_Named,
+                                                                     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) {
                     return sk_sp<SkColorSpace>(new SkColorSpace_Base(colorLUT.release(),
-                                                                     std::move(gammas), toXYZ));
+                                                                     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::NewRGB(gammaVals, toXYZ);
+                    return SkColorSpace_Base::NewRGB(gammaVals, toXYZ, std::move(data));
                 } else {
                     return sk_sp<SkColorSpace>(new SkColorSpace_Base(std::move(gammas), toXYZ,
-                                                                     kUnknown_Named));
+                                                                     kUnknown_Named,
+                                                                     std::move(data)));
                 }
             }
         }
         default:
             break;
     }
 
     return_null("ICC profile contains unsupported colorspace");
 }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+// We will write a profile with the minimum nine required tags.
+static constexpr uint32_t kICCNumEntries = 9;
+
+static constexpr uint32_t kTAG_desc = SkSetFourByteTag('d', 'e', 's', 'c');
+static constexpr uint32_t kTAG_desc_Bytes = 12;
+static constexpr uint32_t kTAG_desc_Offset = kICCHeaderSize + kICCNumEntries*kICCTagTableEntrySize;
+
+static constexpr uint32_t kTAG_XYZ_Bytes = 20;
+static constexpr uint32_t kTAG_rXYZ_Offset = kTAG_desc_Offset + kTAG_desc_Bytes;
+static constexpr uint32_t kTAG_gXYZ_Offset = kTAG_rXYZ_Offset + kTAG_XYZ_Bytes;
+static constexpr uint32_t kTAG_bXYZ_Offset = kTAG_gXYZ_Offset + kTAG_XYZ_Bytes;
+
+static constexpr uint32_t kTAG_TRC_Bytes = 14;
+static constexpr uint32_t kTAG_rTRC_Offset = kTAG_bXYZ_Offset + kTAG_XYZ_Bytes;
+static constexpr uint32_t kTAG_gTRC_Offset = kTAG_rTRC_Offset + SkAlign4(kTAG_TRC_Bytes);
+static constexpr uint32_t kTAG_bTRC_Offset = kTAG_gTRC_Offset + SkAlign4(kTAG_TRC_Bytes);
+
+static constexpr uint32_t kTAG_wtpt = SkSetFourByteTag('w', 't', 'p', 't');
+static constexpr uint32_t kTAG_wtpt_Offset = kTAG_bTRC_Offset + SkAlign4(kTAG_TRC_Bytes);
+
+static constexpr uint32_t kTAG_cprt = SkSetFourByteTag('c', 'p', 'r', 't');
+static constexpr uint32_t kTAG_cprt_Bytes = 12;
+static constexpr uint32_t kTAG_cprt_Offset = kTAG_wtpt_Offset + kTAG_XYZ_Bytes;
+
+static constexpr uint32_t kICCProfileSize = kTAG_cprt_Offset + kTAG_cprt_Bytes;
+
+static constexpr uint32_t gICCHeader[kICCHeaderSize / 4] {
+    SkEndian_SwapBE32(kICCProfileSize),  // Size of the profile
+    0,                                   // Preferred CMM type (ignored)
+    SkEndian_SwapBE32(0x02100000),       // Version 2.1
+    SkEndian_SwapBE32(kDisplay_Profile), // Display device profile
+    SkEndian_SwapBE32(kRGB_ColorSpace),  // RGB input color space
+    SkEndian_SwapBE32(kXYZ_PCSSpace),    // XYZ profile connection space
+    0, 0, 0,                             // Date and time (ignored)
+    SkEndian_SwapBE32(kACSP_Signature),  // Profile signature
+    0,                                   // Platform target (ignored)
+    0x00000000,                          // Flags: not embedded, can be used independently
+    0,                                   // Device manufacturer (ignored)
+    0,                                   // Device model (ignored)
+    0, 0,                                // Device attributes (ignored)
+    SkEndian_SwapBE32(1),                // Relative colorimetric rendering intent
+    SkEndian_SwapBE32(0x0000f6d6),       // D50 standard illuminant (X)
+    SkEndian_SwapBE32(0x00010000),       // D50 standard illuminant (Y)
+    SkEndian_SwapBE32(0x0000d32d),       // D50 standard illuminant (Z)
+    0,                                   // Profile creator (ignored)
+    0, 0, 0, 0,                          // Profile id checksum (ignored)
+    0, 0, 0, 0, 0, 0, 0,                 // Reserved (ignored)
+    SkEndian_SwapBE32(kICCNumEntries),   // Number of tags
+};
+
+static constexpr uint32_t gICCTagTable[3 * kICCNumEntries] {
+    // Profile description
+    SkEndian_SwapBE32(kTAG_desc),
+    SkEndian_SwapBE32(kTAG_desc_Offset),
+    SkEndian_SwapBE32(kTAG_desc_Bytes),
+
+    // rXYZ
+    SkEndian_SwapBE32(kTAG_rXYZ),
+    SkEndian_SwapBE32(kTAG_rXYZ_Offset),
+    SkEndian_SwapBE32(kTAG_XYZ_Bytes),
+
+    // gXYZ
+    SkEndian_SwapBE32(kTAG_gXYZ),
+    SkEndian_SwapBE32(kTAG_gXYZ_Offset),
+    SkEndian_SwapBE32(kTAG_XYZ_Bytes),
+
+    // bXYZ
+    SkEndian_SwapBE32(kTAG_bXYZ),
+    SkEndian_SwapBE32(kTAG_bXYZ_Offset),
+    SkEndian_SwapBE32(kTAG_XYZ_Bytes),
+
+    // rTRC
+    SkEndian_SwapBE32(kTAG_rTRC),
+    SkEndian_SwapBE32(kTAG_rTRC_Offset),
+    SkEndian_SwapBE32(kTAG_TRC_Bytes),
+
+    // gTRC
+    SkEndian_SwapBE32(kTAG_gTRC),
+    SkEndian_SwapBE32(kTAG_gTRC_Offset),
+    SkEndian_SwapBE32(kTAG_TRC_Bytes),
+
+    // bTRC
+    SkEndian_SwapBE32(kTAG_bTRC),
+    SkEndian_SwapBE32(kTAG_bTRC_Offset),
+    SkEndian_SwapBE32(kTAG_TRC_Bytes),
+
+    // White point
+    SkEndian_SwapBE32(kTAG_wtpt),
+    SkEndian_SwapBE32(kTAG_wtpt_Offset),
+    SkEndian_SwapBE32(kTAG_XYZ_Bytes),
+
+    // Copyright
+    SkEndian_SwapBE32(kTAG_cprt),
+    SkEndian_SwapBE32(kTAG_cprt_Offset),
+    SkEndian_SwapBE32(kTAG_cprt_Bytes),
+};
+
+static constexpr uint32_t kTAG_TextType = SkSetFourByteTag('m', 'l', 'u', 'c');
+static constexpr uint32_t gEmptyTextTag[3] {
+    SkEndian_SwapBE32(kTAG_TextType), // Type signature
+    0,                                // Reserved
+    0,                                // Zero records
+};
+
+static void write_xyz_tag(uint32_t* ptr, const SkMatrix44& toXYZ, int row) {
+    ptr[0] = SkEndian_SwapBE32(kXYZ_PCSSpace);
+    ptr[1] = 0;
+    ptr[2] = SkEndian_SwapBE32(SkFloatToFixed(toXYZ.getFloat(row, 0)));
+    ptr[3] = SkEndian_SwapBE32(SkFloatToFixed(toXYZ.getFloat(row, 1)));
+    ptr[4] = SkEndian_SwapBE32(SkFloatToFixed(toXYZ.getFloat(row, 2)));
+}
+
+static void write_trc_tag(uint32_t* ptr, float value) {
+    ptr[0] = SkEndian_SwapBE32(kTAG_CurveType);
+    ptr[1] = 0;
+
+    // Gamma will be specified with a single value.
+    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;
+}
+
+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!
+    if (0.0f != fToXYZD50.getFloat(3, 0) || 0.0f != fToXYZD50.getFloat(3, 1) ||
+        0.0f != fToXYZD50.getFloat(3, 2) || 0.0f != fToXYZD50.getFloat(0, 3) ||
+        0.0f != fToXYZD50.getFloat(1, 3) || 0.0f != fToXYZD50.getFloat(2, 3))
+    {
+        return nullptr;
+    }
+
+    SkAutoMalloc profile(kICCProfileSize);
+    uint8_t* ptr = (uint8_t*) profile.get();
+
+    // Write profile header
+    memcpy(ptr, gICCHeader, sizeof(gICCHeader));
+    ptr += sizeof(gICCHeader);
+
+    // Write tag table
+    memcpy(ptr, gICCTagTable, sizeof(gICCTagTable));
+    ptr += sizeof(gICCTagTable);
+
+    // Write profile description tag
+    memcpy(ptr, gEmptyTextTag, sizeof(gEmptyTextTag));
+    ptr += sizeof(gEmptyTextTag);
+
+    // 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);
+
+    // 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);
+}