Enable flattening and unflattening of SkColorSpace

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"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.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(GammaNamed gammaNamed, const SkMatrix44& toXYZD50, Named named,
-                                     sk_sp<SkData> profileData)
+SkColorSpace_Base::SkColorSpace_Base(GammaNamed gammaNamed, const SkMatrix44& toXYZD50, Named named)
     : INHERITED(gammaNamed, toXYZD50, named)
     , fGammas(nullptr)
-    , fProfileData(std::move(profileData))
+    , fProfileData(nullptr)
 {}
 
 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))
 {}
 
@@ skipping 53 matching lines @@
     set_gamma_value(&curves[1], values[1]);
     set_gamma_value(&curves[2], values[2]);
 
     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));
     }
 
-    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZD50, nullptr);
+    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZD50);
 }
 
-sk_sp<SkColorSpace> SkColorSpace_Base::NewRGB(GammaNamed gammaNamed, const SkMatrix44& toXYZD50,
-                                              sk_sp<SkData> profileData) {
+sk_sp<SkColorSpace> SkColorSpace_Base::NewRGB(GammaNamed gammaNamed, const SkMatrix44& toXYZD50) {
     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(gammaNamed, toXYZD50, kUnknown_Named,
-                                                     profileData));
+    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammaNamed, toXYZD50, kUnknown_Named));
 }
 
 sk_sp<SkColorSpace> SkColorSpace::NewRGB(GammaNamed gammaNamed, const SkMatrix44& toXYZD50) {
-    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZD50, nullptr);
+    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZD50);
 }
 
 sk_sp<SkColorSpace> SkColorSpace::NewNamed(Named named) {
     static SkOnce sRGBOnce;
     static SkColorSpace* sRGB;
     static SkOnce adobeRGBOnce;
     static SkColorSpace* adobeRGB;
 
     switch (named) {
         case kSRGB_Named: {
             sRGBOnce([] {
                 SkMatrix44 srgbToxyzD50(SkMatrix44::kUninitialized_Constructor);
                 srgbToxyzD50.set3x3ColMajorf(gSRGB_toXYZD50);
-                sRGB = new SkColorSpace_Base(kSRGB_GammaNamed, srgbToxyzD50, kSRGB_Named, nullptr);
+                sRGB = new SkColorSpace_Base(kSRGB_GammaNamed, srgbToxyzD50, kSRGB_Named);
             });
             return sk_ref_sp(sRGB);
         }
         case kAdobeRGB_Named: {
             adobeRGBOnce([] {
                 SkMatrix44 adobergbToxyzD50(SkMatrix44::kUninitialized_Constructor);
                 adobergbToxyzD50.set3x3ColMajorf(gAdobeRGB_toXYZD50);
                 adobeRGB = new SkColorSpace_Base(k2Dot2Curve_GammaNamed, adobergbToxyzD50,
-                                                 kAdobeRGB_Named, nullptr);
+                                                 kAdobeRGB_Named);
             });
             return sk_ref_sp(adobeRGB);
         }
         default:
             break;
     }
     return nullptr;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ skipping 756 matching lines @@
                 }
 
                 GammaNamed gammaNamed = SkGammas::Named(curves);
                 if (kNonStandard_GammaNamed == gammaNamed) {
                     sk_sp<SkGammas> gammas = sk_make_sp<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 SkColorSpace_Base::NewRGB(gammaNamed, mat, std::move(data));
+                    return SkColorSpace_Base::NewRGB(gammaNamed, mat);
                 }
             }
 
             // 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");
                 }
 
                 GammaNamed gammaNamed = SkGammas::Named(curves);
                 if (colorLUT->fTable || kNonStandard_GammaNamed == gammaNamed) {
                     sk_sp<SkGammas> gammas = sk_make_sp<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 {
-                    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZ, std::move(data));
+                    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZ);
                 }
             }
         }
         default:
             break;
     }
 
     return_null("ICC profile contains unsupported colorspace");
 }
 
@@ skipping 232 matching lines @@
     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);
 }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////

[reed1, 2016/06/21 14:58:34]

Some thoughts.

I think we should be more explicit about sizes and the memory layout of the
serialized buffer. sizeof(enum) can possibly change (depending on compiler
settings and the value ranges for our enums), and I also think we should
explicitly encode the size of the profile-data (when present) rather than rely
on implicitly knowing it from the total size... think of the case where we may
have our contents embedded in a larger stream of data...

I guess that last thought implies that our Deserialize might want to return the
number of bytes actually processed (think if Deserialize took a stream ...)

e.g.
First 4 bytes encode the type of encoding...

struct Header {
    uint8_t  fVersion;
    uint8_t fNamed;   // or 0xFF if this guy is not named
    uint8_t fGammaNamed;   // or 0xFF if this guy is not a named gamma
    uint8_t fFlags;  // 0 for now, maybe 1 bit means an ICC Profile follows:
4-byte length + data (padded to 4 bytes?)
};

[msarett, 2016/06/21 16:41:57]

The implementation with Header sgtm, along with storing the length of the icc
data.

And I agree that returning the length from the API could be useful - but I'd
rather not make that change until we have a caller that needs it.

The current implementation on SkImageInfo uses read/writeData() APIs, so we
already know that the blob we pass to Deserialize is just the serialized
SkColorSpace.

+
+sk_sp<SkData> SkColorSpace::serialize() const {
+    // If we have a named profile, only write the enum.
+    switch (fNamed) {
+        case kSRGB_Named:
+        case kAdobeRGB_Named: {
+            sk_sp<SkData> data = SkData::MakeUninitialized(sizeof(Named));
+            *((Named*) data->writable_data()) = fNamed;
+            return data;
+        }
+        default:
+            break;
+    }
+
+    // If we have a named gamma, write the enum and the matrix.
+    switch (fGammaNamed) {
+        case kSRGB_GammaNamed:
+        case k2Dot2Curve_GammaNamed:
+        case kLinear_GammaNamed: {
+            sk_sp<SkData> data = SkData::MakeUninitialized(sizeof(Named) + sizeof(GammaNamed) +
+                                                           16 * sizeof(float));
+            void* dataPtr = data->writable_data();
+
+            *((Named*) dataPtr) = fNamed;
+            dataPtr = SkTAddOffset<void>(dataPtr, sizeof(fNamed));
+
+            *((GammaNamed*) dataPtr) = fGammaNamed;
+            dataPtr = SkTAddOffset<void>(dataPtr, sizeof(fGammaNamed));
+
+            fToXYZD50.asColMajorf((float*) dataPtr);
+            return data;
+        }
+        default:
+            break;
+    }
+
+    // If we do not have a named gamma, this must have been created from an ICC profile.
+    // Since we were unable to recognize the gamma, we will have saved the ICC data.
+    SkASSERT(as_CSB(this)->fProfileData);
+
+    sk_sp<SkData> data = SkData::MakeUninitialized(sizeof(Named) + sizeof(GammaNamed) +
+                                                   as_CSB(this)->fProfileData->size());
+    void* dataPtr = data->writable_data();
+
+    *((Named*) dataPtr) = fNamed;
+    dataPtr = SkTAddOffset<void>(dataPtr, sizeof(fNamed));
+
+    *((GammaNamed*) dataPtr) = fGammaNamed;
+    dataPtr = SkTAddOffset<void>(dataPtr, sizeof(fGammaNamed));
+
+    memcpy(dataPtr, as_CSB(this)->fProfileData->data(), as_CSB(this)->fProfileData->size());
+    return data;
+}
+
+sk_sp<SkColorSpace> SkColorSpace::Deserialize(const void* data, size_t length) {
+    if (length < sizeof(Named)) {
+        return nullptr;
+    }
+
+    Named named = *((const Named*) data);
+    data = SkTAddOffset<const void>(data, sizeof(Named));
+    length -= sizeof(Named);
+    switch (named) {
+        case kSRGB_Named:
+        case kAdobeRGB_Named:
+            return NewNamed(named);
+        default:
+            break;
+    }
+
+    if (length < sizeof(GammaNamed)) {
+        return nullptr;
+    }
+
+    GammaNamed gammaNamed = *((const GammaNamed*) data);
+    data = SkTAddOffset<const void>(data, sizeof(GammaNamed));
+    length -= sizeof(GammaNamed);
+    switch (gammaNamed) {
+        case kSRGB_GammaNamed:
+        case k2Dot2Curve_GammaNamed:
+        case kLinear_GammaNamed: {
+            if (length < 16 * sizeof(float)) {
+                return nullptr;
+            }
+
+            SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
+            toXYZ.setColMajorf((const float*) data);
+            return NewRGB(gammaNamed, toXYZ);
+        }
+        default:
+            break;
+    }
+
+    return NewICC(data, length);
+}