Revert "Remove old ICC parser, A2B SkColorSpace, SkGammas, etc..."

This reverts commit 8ae7c90.

Reason for revert: Chrome roll

Original change's description:
> Remove old ICC parser, A2B SkColorSpace, SkGammas, etc...
> 
> Docs-Preview: https://skia.org/?cl=148807
> Change-Id: I2d77f6543e390c4948d57242a518af77443f0165
> Reviewed-on: https://skia-review.googlesource.com/148807
> Commit-Queue: Mike Klein <mtklein@google.com>
> Reviewed-by: Mike Klein <mtklein@google.com>

TBR=mtklein@google.com,brianosman@google.com,reed@google.com

Change-Id: I5821591b22e395327ec0cd29ec18569bf7f61859
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/150142
Reviewed-by: Brian Osman <brianosman@google.com>
Commit-Queue: Brian Osman <brianosman@google.com>

Author: brianosman

gn/core.gni

@@ -75,8 +75,11 @@ skia_core_sources = [
   "$_src/core/SkColorMatrixFilterRowMajor255.cpp",
   "$_src/core/SkColorMatrixFilterRowMajor255.h",
   "$_src/core/SkColorSpace.cpp",
+  "$_src/core/SkColorSpace_A2B.cpp",
+  "$_src/core/SkColorSpace_A2B.h",
   "$_src/core/SkColorSpace_XYZ.cpp",
   "$_src/core/SkColorSpace_XYZ.h",
+  "$_src/core/SkColorSpace_ICC.cpp",
   "$_src/core/SkColorSpaceXform.cpp",
   "$_src/core/SkColorSpaceXformCanvas.cpp",
   "$_src/core/SkColorSpaceXformSteps.cpp",

include/core/SkColorSpace.h

@@ -126,6 +126,11 @@ class SK_API SkColorSpace : public SkRefCnt {
 
     static sk_sp<SkColorSpace> MakeRGB(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50);
 
+    /**
+     *  Create an SkColorSpace from an ICC profile.
+     */
+    static sk_sp<SkColorSpace> MakeICC(const void*, size_t);
+
     /**
      *  Create an SkColorSpace from a parsed (skcms) ICC profile.
      */
@@ -136,6 +141,16 @@ class SK_API SkColorSpace : public SkRefCnt {
      */
     void toProfile(skcms_ICCProfile*) const;
 
+    /**
+     *  Types of colorspaces.
+     */
+    enum Type {
+        kRGB_Type,
+        kCMYK_Type,
+        kGray_Type,
+    };
+    Type type() const;
+
     SkGammaNamed gammaNamed() const;
 
     /**
@@ -250,6 +265,9 @@ class SK_API SkColorSpace : public SkRefCnt {
     virtual bool onGammaCloseToSRGB() const = 0;
     virtual bool onGammaIsLinear() const = 0;
     virtual bool onIsNumericalTransferFn(SkColorSpaceTransferFn* coeffs) const = 0;
+    virtual bool onIsCMYK() const { return false; }
+
+    virtual const SkData* onProfileData() const { return nullptr; }
 
     using INHERITED = SkRefCnt;
 };

site/user/sample/color.md

@@ -80,6 +80,9 @@ to make color spaces.
 
 	// Choose a common gamut and a common transfer function
 	sk_sp<SkColorSpace> MakeRGB(RenderTargetGamma, Gamut);
+	
+	// Create a color space from an ICC profile
+	sk_sp<SkColorSpace> MakeICC();
 
 Starting with **sources** (the things that you draw), there are a number of ways to make sure
 that they are tagged with a color space.

src/core/SkColorSpace.cpp

@@ -9,7 +9,6 @@
 #include "SkColorSpace_XYZ.h"
 #include "SkColorSpacePriv.h"
 #include "SkPoint3.h"
-#include "SkTemplates.h"
 #include <new>
 
 bool SkColorSpacePrimaries::toXYZD50(SkMatrix44* toXYZ_D50) const {
@@ -128,7 +127,7 @@ sk_sp<SkColorSpace> SkColorSpace::MakeRGB(SkGammaNamed gammaNamed, const SkMatri
             break;
     }
 
-    return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(gammaNamed, nullptr, toXYZD50));
+    return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(gammaNamed, toXYZD50));
 }
 
 sk_sp<SkColorSpace> SkColorSpace::MakeRGB(RenderTargetGamma gamma, const SkMatrix44& toXYZD50) {
@@ -160,7 +159,18 @@ sk_sp<SkColorSpace> SkColorSpace::MakeRGB(const SkColorSpaceTransferFn& coeffs,
         return SkColorSpace::MakeRGB(kLinear_SkGammaNamed, toXYZD50);
     }
 
-    return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(kNonStandard_SkGammaNamed, &coeffs, toXYZD50));
+    void* memory = sk_malloc_throw(sizeof(SkGammas) + sizeof(SkColorSpaceTransferFn));
+    sk_sp<SkGammas> gammas = sk_sp<SkGammas>(new (memory) SkGammas(3));
+    SkColorSpaceTransferFn* fn = SkTAddOffset<SkColorSpaceTransferFn>(memory, sizeof(SkGammas));
+    *fn = coeffs;
+    SkGammas::Data data;
+    data.fParamOffset = 0;
+    for (int channel = 0; channel < 3; ++channel) {
+        gammas->fType[channel] = SkGammas::Type::kParam_Type;
+        gammas->fData[channel] = data;
+    }
+    return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(kNonStandard_SkGammaNamed,
+                                                    std::move(gammas), toXYZD50, nullptr));
 }
 
 sk_sp<SkColorSpace> SkColorSpace::MakeRGB(RenderTargetGamma gamma, Gamut gamut) {
@@ -179,7 +189,7 @@ static SkColorSpace* singleton_colorspace(SkGammaNamed gamma, const float to_xyz
     SkMatrix44 m44(SkMatrix44::kUninitialized_Constructor);
     m44.set3x3RowMajorf(to_xyz);
     (void)m44.getType();  // Force typemask to be computed to avoid races.
-    return new SkColorSpace_XYZ(gamma, nullptr, m44);
+    return new SkColorSpace_XYZ(gamma, m44);
 }
 
 SkColorSpace* sk_srgb_singleton() {
@@ -201,6 +211,14 @@ sk_sp<SkColorSpace> SkColorSpace::MakeSRGBLinear() {
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+SkColorSpace::Type SkColorSpace::type() const {
+    const SkMatrix44* m = this->toXYZD50();
+    if (m) {
+        return m->isScale() ? kGray_Type : kRGB_Type;
+    }
+    return this->onIsCMYK() ? kCMYK_Type : kRGB_Type;
+}
+
 SkGammaNamed SkColorSpace::gammaNamed() const {
     return this->onGammaNamed();
 }
@@ -271,7 +289,6 @@ struct ColorSpaceHeader {
      *  If kICC_Flag is set, we will write an ICC profile after the header.
      *  The ICC profile will be written as a uint32 size, followed immediately
      *  by the data (padded to 4 bytes).
-     *  DEPRECATED / UNUSED
      */
     static constexpr uint8_t kICC_Flag        = 1 << 1;
 
@@ -307,61 +324,87 @@ struct ColorSpaceHeader {
 };
 
 size_t SkColorSpace::writeToMemory(void* memory) const {
-    // If we have a named profile, only write the enum.
-    const SkGammaNamed gammaNamed = this->gammaNamed();
-    if (this == sk_srgb_singleton()) {
-        if (memory) {
-            *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
-                    k0_Version, kSRGB_NamedColorSpace, gammaNamed, 0);
-        }
-        return sizeof(ColorSpaceHeader);
-    } else if (this == sk_srgb_linear_singleton()) {
-        if (memory) {
-            *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
-                    k0_Version, kSRGBLinear_NamedColorSpace, gammaNamed, 0);
-        }
-        return sizeof(ColorSpaceHeader);
-    }
-
-    // If we have a named gamma, write the enum and the matrix.
-    switch (gammaNamed) {
-        case kSRGB_SkGammaNamed:
-        case k2Dot2Curve_SkGammaNamed:
-        case kLinear_SkGammaNamed: {
+    // Start by trying the serialization fast path.  If we haven't saved ICC profile data,
+    // we must have a profile that we can serialize easily.
+    if (!this->onProfileData()) {
+        // Profile data is mandatory for A2B0 color spaces, so we must be XYZ.
+        SkASSERT(this->toXYZD50());
+        // If we have a named profile, only write the enum.
+        const SkGammaNamed gammaNamed = this->gammaNamed();
+        if (this == sk_srgb_singleton()) {
             if (memory) {
-                *((ColorSpaceHeader*) memory) =
-                        ColorSpaceHeader::Pack(k0_Version, 0, gammaNamed,
-                                                ColorSpaceHeader::kMatrix_Flag);
-                memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
-                this->toXYZD50()->as3x4RowMajorf((float*) memory);
+                *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
+                        k0_Version, kSRGB_NamedColorSpace, gammaNamed, 0);
             }
-            return sizeof(ColorSpaceHeader) + 12 * sizeof(float);
-        }
-        default: {
-            SkColorSpaceTransferFn transferFn;
-            SkAssertResult(this->isNumericalTransferFn(&transferFn));
-
+            return sizeof(ColorSpaceHeader);
+        } else if (this == sk_srgb_linear_singleton()) {
             if (memory) {
-                *((ColorSpaceHeader*) memory) =
-                        ColorSpaceHeader::Pack(k0_Version, 0, gammaNamed,
-                                                ColorSpaceHeader::kTransferFn_Flag);
-                memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
-
-                *(((float*) memory) + 0) = transferFn.fA;
-                *(((float*) memory) + 1) = transferFn.fB;
-                *(((float*) memory) + 2) = transferFn.fC;
-                *(((float*) memory) + 3) = transferFn.fD;
-                *(((float*) memory) + 4) = transferFn.fE;
-                *(((float*) memory) + 5) = transferFn.fF;
-                *(((float*) memory) + 6) = transferFn.fG;
-                memory = SkTAddOffset<void>(memory, 7 * sizeof(float));
-
-                this->toXYZD50()->as3x4RowMajorf((float*) memory);
+                *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
+                        k0_Version, kSRGBLinear_NamedColorSpace, gammaNamed, 0);
             }
+            return sizeof(ColorSpaceHeader);
+        }
 
-            return sizeof(ColorSpaceHeader) + 19 * sizeof(float);
+        // If we have a named gamma, write the enum and the matrix.
+        switch (gammaNamed) {
+            case kSRGB_SkGammaNamed:
+            case k2Dot2Curve_SkGammaNamed:
+            case kLinear_SkGammaNamed: {
+                if (memory) {
+                    *((ColorSpaceHeader*) memory) =
+                            ColorSpaceHeader::Pack(k0_Version, 0, gammaNamed,
+                                                   ColorSpaceHeader::kMatrix_Flag);
+                    memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
+                    this->toXYZD50()->as3x4RowMajorf((float*) memory);
+                }
+                return sizeof(ColorSpaceHeader) + 12 * sizeof(float);
+            }
+            default: {
+                SkColorSpaceTransferFn transferFn;
+                SkAssertResult(this->isNumericalTransferFn(&transferFn));
+
+                if (memory) {
+                    *((ColorSpaceHeader*) memory) =
+                            ColorSpaceHeader::Pack(k0_Version, 0, gammaNamed,
+                                                   ColorSpaceHeader::kTransferFn_Flag);
+                    memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
+
+                    *(((float*) memory) + 0) = transferFn.fA;
+                    *(((float*) memory) + 1) = transferFn.fB;
+                    *(((float*) memory) + 2) = transferFn.fC;
+                    *(((float*) memory) + 3) = transferFn.fD;
+                    *(((float*) memory) + 4) = transferFn.fE;
+                    *(((float*) memory) + 5) = transferFn.fF;
+                    *(((float*) memory) + 6) = transferFn.fG;
+                    memory = SkTAddOffset<void>(memory, 7 * sizeof(float));
+
+                    this->toXYZD50()->as3x4RowMajorf((float*) memory);
+                }
+
+                return sizeof(ColorSpaceHeader) + 19 * sizeof(float);
+            }
         }
     }
+
+    // Otherwise, serialize the ICC data.
+    size_t profileSize = this->onProfileData()->size();
+    if (SkAlign4(profileSize) != (uint32_t) SkAlign4(profileSize)) {
+        return 0;
+    }
+
+    if (memory) {
+        *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(k0_Version, 0,
+                                                               kNonStandard_SkGammaNamed,
+                                                               ColorSpaceHeader::kICC_Flag);
+        memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
+
+        *((uint32_t*) memory) = (uint32_t) SkAlign4(profileSize);
+        memory = SkTAddOffset<void>(memory, sizeof(uint32_t));
+
+        memcpy(memory, this->onProfileData()->data(), profileSize);
+        memset(SkTAddOffset<void>(memory, profileSize), 0, SkAlign4(profileSize) - profileSize);
+    }
+    return sizeof(ColorSpaceHeader) + sizeof(uint32_t) + SkAlign4(profileSize);
 }
 
 sk_sp<SkData> SkColorSpace::serialize() const {
@@ -412,8 +455,18 @@ sk_sp<SkColorSpace> SkColorSpace::Deserialize(const void* data, size_t length) {
 
     switch (header.fFlags) {
         case ColorSpaceHeader::kICC_Flag: {
-            // Deprecated and unsupported code path
-            return nullptr;
+            if (length < sizeof(uint32_t)) {
+                return nullptr;
+            }
+
+            uint32_t profileSize = *((uint32_t*) data);
+            data = SkTAddOffset<const void>(data, sizeof(uint32_t));
+            length -= sizeof(uint32_t);
+            if (length < profileSize) {
+                return nullptr;
+            }
+
+            return MakeICC(data, profileSize);
         }
         case ColorSpaceHeader::kTransferFn_Flag: {
             if (length < 19 * sizeof(float)) {
@@ -448,6 +501,18 @@ bool SkColorSpace::Equals(const SkColorSpace* src, const SkColorSpace* dst) {
         return false;
     }
 
+    const SkData* srcData = src->onProfileData();
+    const SkData* dstData = dst->onProfileData();
+    if (srcData || dstData) {
+        if (srcData && dstData) {
+            return srcData->size() == dstData->size() &&
+                   0 == memcmp(srcData->data(), dstData->data(), srcData->size());
+        }
+
+        return false;
+    }
+
+    // Profiles are mandatory for A2B0 color spaces, so these must be XYZ
     if (src->gammaNamed() != dst->gammaNamed()) {
         return false;
     }
@@ -463,7 +528,6 @@ bool SkColorSpace::Equals(const SkColorSpace* src, const SkColorSpace* dst) {
             return false;
         default:
             // It is unlikely that we will reach this case.
-            // TODO: Simplify this case now that color spaces have one representation.
             sk_sp<SkData> serializedSrcData = src->serialize();
             sk_sp<SkData> serializedDstData = dst->serialize();
             return serializedSrcData->size() == serializedDstData->size() &&

src/core/SkColorSpacePriv.h

@@ -188,6 +188,43 @@ static inline bool is_almost_linear(const SkColorSpaceTransferFn& coeffs) {
     return linearExp || linearFn;
 }
 
+static inline bool is_just_gamma(const SkColorSpaceTransferFn& coeffs) {
+    return transfer_fn_almost_equal(coeffs.fA, 1.0f)
+        && transfer_fn_almost_equal(coeffs.fB, 0.0f)
+        && transfer_fn_almost_equal(coeffs.fC, 0.0f)
+        && transfer_fn_almost_equal(coeffs.fD, 0.0f)
+        && transfer_fn_almost_equal(coeffs.fE, 0.0f)
+        && transfer_fn_almost_equal(coeffs.fF, 0.0f);
+}
+
+
+static inline void value_to_parametric(SkColorSpaceTransferFn* coeffs, float exponent) {
+    coeffs->fA = 1.0f;
+    coeffs->fB = 0.0f;
+    coeffs->fC = 0.0f;
+    coeffs->fD = 0.0f;
+    coeffs->fE = 0.0f;
+    coeffs->fF = 0.0f;
+    coeffs->fG = exponent;
+}
+
+static inline bool named_to_parametric(SkColorSpaceTransferFn* coeffs,
+                                       SkGammaNamed gammaNamed) {
+    switch (gammaNamed) {
+        case kSRGB_SkGammaNamed:
+            *coeffs = gSRGB_TransferFn;
+            return true;
+        case k2Dot2Curve_SkGammaNamed:
+            *coeffs = g2Dot2_TransferFn;
+            return true;
+        case kLinear_SkGammaNamed:
+            *coeffs = gLinear_TransferFn;
+            return true;
+        default:
+            return false;
+    }
+}
+
 // Return raw pointers to commonly used SkColorSpaces.
 // No need to ref/unref these, but if you do, do it in pairs.
 SkColorSpace* sk_srgb_singleton();

src/core/SkColorSpaceXform.cpp

@@ -77,19 +77,23 @@ bool SkColorSpaceXform_skcms::apply(ColorFormat dstFormat, void* dst,
 }
 
 void SkColorSpace::toProfile(skcms_ICCProfile* profile) const {
-    SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
-    SkColorSpaceTransferFn tf;
-    SkAssertResult(this->toXYZD50(&toXYZ) && this->isNumericalTransferFn(&tf));
-
-    skcms_Matrix3x3 m = { {
-        { toXYZ.get(0, 0), toXYZ.get(0, 1), toXYZ.get(0, 2) },
-        { toXYZ.get(1, 0), toXYZ.get(1, 1), toXYZ.get(1, 2) },
-        { toXYZ.get(2, 0), toXYZ.get(2, 1), toXYZ.get(2, 2) },
-    } };
-
-    skcms_Init(profile);
-    skcms_SetTransferFunction(profile, (const skcms_TransferFunction*)&tf);
-    skcms_SetXYZD50(profile, &m);
+    if (auto blob = this->onProfileData()) {
+        SkAssertResult(skcms_Parse(blob->data(), blob->size(), profile));
+    } else {
+        SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
+        SkColorSpaceTransferFn tf;
+        SkAssertResult(this->toXYZD50(&toXYZ) && this->isNumericalTransferFn(&tf));
+
+        skcms_Matrix3x3 m = { {
+            { toXYZ.get(0, 0), toXYZ.get(0, 1), toXYZ.get(0, 2) },
+            { toXYZ.get(1, 0), toXYZ.get(1, 1), toXYZ.get(1, 2) },
+            { toXYZ.get(2, 0), toXYZ.get(2, 1), toXYZ.get(2, 2) },
+        } };
+
+        skcms_Init(profile);
+        skcms_SetTransferFunction(profile, (const skcms_TransferFunction*)&tf);
+        skcms_SetXYZD50(profile, &m);
+    }
 }
 
 std::unique_ptr<SkColorSpaceXform> SkMakeColorSpaceXform(SkColorSpace* src, SkColorSpace* dst) {