Add SkColorSpaceTransferFn to 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 "SkColorSpacePriv.h"
 #include "SkOnce.h"
 #include "SkPoint3.h"
 
-static inline bool is_zero_to_one(float v) {
-    return (0.0f <= v) && (v <= 1.0f);
-}
-
 bool SkColorSpacePrimaries::toXYZD50(SkMatrix44* toXYZ_D50) const {
     if (!is_zero_to_one(fRX) || !is_zero_to_one(fRY) ||
         !is_zero_to_one(fGX) || !is_zero_to_one(fGY) ||
         !is_zero_to_one(fBX) || !is_zero_to_one(fBY) ||
         !is_zero_to_one(fWX) || !is_zero_to_one(fWY))
     {
         return false;
     }
 
     // First, we need to convert xy values (primaries) to XYZ.
@@ skipping 176 matching lines @@
     switch (gamma) {
         case kLinear_RenderTargetGamma:
             return SkColorSpace_Base::NewRGB(kLinear_SkGammaNamed, toXYZD50);
         case kSRGB_RenderTargetGamma:
             return SkColorSpace_Base::NewRGB(kSRGB_SkGammaNamed, toXYZD50);
         default:
             return nullptr;
     }
 }
 
+sk_sp<SkColorSpace> SkColorSpace::NewRGB(const SkColorSpaceTransferFn& coeffs,
+                                         const SkMatrix44& toXYZD50) {
+    if (!is_valid_transfer_fn(coeffs)) {
+        return nullptr;
+    }
+
+    if (is_almost_srgb(coeffs)) {
+        return SkColorSpace::NewRGB(kSRGB_RenderTargetGamma, toXYZD50);
+    }
+
+    if (is_almost_2dot2(coeffs)) {
+        return SkColorSpace_Base::NewRGB(k2Dot2Curve_SkGammaNamed, toXYZD50);
+    }
+
+    void* memory = sk_malloc_throw(sizeof(SkGammas) + sizeof(SkColorSpaceTransferFn));
+    sk_sp<SkGammas> gammas = sk_sp<SkGammas>(new (memory) SkGammas());
+    SkColorSpaceTransferFn* fn = SkTAddOffset<SkColorSpaceTransferFn>(memory, sizeof(SkGammas));
+    *fn = coeffs;
+    gammas->fRedType = SkGammas::Type::kParam_Type;
+    gammas->fGreenType = SkGammas::Type::kParam_Type;
+    gammas->fBlueType = SkGammas::Type::kParam_Type;
+
+    SkGammas::Data data;
+    data.fParamOffset = 0;
+    gammas->fRedData = data;
+    gammas->fGreenData = data;
+    gammas->fBlueData = data;
+    return sk_sp<SkColorSpace>(new SkColorSpace_Base(nullptr, kNonStandard_SkGammaNamed,
+                                                     std::move(gammas), toXYZD50, nullptr));
+}
+
 static SkColorSpace* gAdobeRGB;
 static SkColorSpace* gSRGB;
 static SkColorSpace* gSRGBLinear;
 
 sk_sp<SkColorSpace> SkColorSpace::NewNamed(Named named) {
     static SkOnce sRGBOnce;
     static SkOnce adobeRGBOnce;
     static SkOnce sRGBLinearOnce;
 
     switch (named) {
@@ skipping 69 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 enum Version {
     k0_Version, // Initial version, header + flags for matrix and profile
 };
 
 struct ColorSpaceHeader {
     /**
+     *  It is only valid to set zero or one flags.
+     *  Setting multiple flags is invalid.
+     */
+
+    /**
      *  If kMatrix_Flag is set, we will write 12 floats after the header.
-     *  Should not be set at the same time as the kICC_Flag or kFloatGamma_Flag.
      */
     static constexpr uint8_t kMatrix_Flag     = 1 << 0;
 
     /**
      *  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).
-     *  Should not be set at the same time as the kMatrix_Flag or kFloatGamma_Flag.
      */
     static constexpr uint8_t kICC_Flag        = 1 << 1;
 
     /**
      *  If kFloatGamma_Flag is set, we will write 15 floats after the header.
      *  The first three are the gamma values, and the next twelve are the
      *  matrix.
-     *  Should not be set at the same time as the kICC_Flag or kMatrix_Flag.
      */
     static constexpr uint8_t kFloatGamma_Flag = 1 << 2;
 
+    /**
+     *  If kTransferFn_Flag is set, we will write 19 floats after the header.
+     *  The first seven represent the transfer fn, and the next twelve are the
+     *  matrix.
+     */
+    static constexpr uint8_t kTransferFn_Flag = 1 << 3;
+
     static ColorSpaceHeader Pack(Version version, uint8_t named, uint8_t gammaNamed, uint8_t flags)
     {
         ColorSpaceHeader header;
 
         SkASSERT(k0_Version == version);
         header.fVersion = (uint8_t) version;
 
         SkASSERT(named <= SkColorSpace::kSRGBLinear_Named);
         header.fNamed = (uint8_t) named;
 
         SkASSERT(gammaNamed <= kNonStandard_SkGammaNamed);
         header.fGammaNamed = (uint8_t) gammaNamed;
 
-        SkASSERT(flags <= kFloatGamma_Flag);
+        SkASSERT(flags <= kTransferFn_Flag);
         header.fFlags = flags;
         return header;
     }
 
     uint8_t fVersion;    // Always zero
     uint8_t fNamed;      // Must be a SkColorSpace::Named
     uint8_t fGammaNamed; // Must be a SkGammaNamed
     uint8_t fFlags;      // Some combination of the flags listed above
 };
 
@@ skipping 33 matching lines @@
                 if (memory) {
                     *((ColorSpaceHeader*) memory) =
                             ColorSpaceHeader::Pack(k0_Version, 0, as_CSB(this)->fGammaNamed,
                                                    ColorSpaceHeader::kMatrix_Flag);
                     memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
                     as_CSB(this)->fToXYZD50.as3x4RowMajorf((float*) memory);
                 }
                 return sizeof(ColorSpaceHeader) + 12 * sizeof(float);
             }
             default:
-                // Otherwise, write the gamma values and the matrix.
-                if (memory) {
-                    *((ColorSpaceHeader*) memory) =
-                            ColorSpaceHeader::Pack(k0_Version, 0, as_CSB(this)->fGammaNamed,
-                                                   ColorSpaceHeader::kFloatGamma_Flag);
-                    memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
+                const SkGammas* gammas = as_CSB(this)->gammas();
+                SkASSERT(gammas);
+                if (gammas->isValue(0) && gammas->isValue(1) && gammas->isValue(2)) {
+                    if (memory) {
+                        *((ColorSpaceHeader*) memory) =
+                                ColorSpaceHeader::Pack(k0_Version, 0, as_CSB(this)->fGammaNamed,
+                                                       ColorSpaceHeader::kFloatGamma_Flag);
+                        memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
 
-                    const SkGammas* gammas = as_CSB(this)->gammas();
-                    SkASSERT(gammas);
-                    SkASSERT(SkGammas::Type::kValue_Type == gammas->fRedType &&
-                             SkGammas::Type::kValue_Type == gammas->fGreenType &&
-                             SkGammas::Type::kValue_Type == gammas->fBlueType);
-                    *(((float*) memory) + 0) = gammas->fRedData.fValue;
-                    *(((float*) memory) + 1) = gammas->fGreenData.fValue;
-                    *(((float*) memory) + 2) = gammas->fBlueData.fValue;
-                    memory = SkTAddOffset<void>(memory, 3 * sizeof(float));
+                        *(((float*) memory) + 0) = gammas->fRedData.fValue;
+                        *(((float*) memory) + 1) = gammas->fGreenData.fValue;
+                        *(((float*) memory) + 2) = gammas->fBlueData.fValue;
+                        memory = SkTAddOffset<void>(memory, 3 * sizeof(float));
 
-                    as_CSB(this)->fToXYZD50.as3x4RowMajorf((float*) memory);
+                        as_CSB(this)->fToXYZD50.as3x4RowMajorf((float*) memory);
+                    }
+
+                    return sizeof(ColorSpaceHeader) + 15 * sizeof(float);
+                } else {
+                    SkASSERT(gammas->isParametric(0));
+                    SkASSERT(gammas->isParametric(1));
+                    SkASSERT(gammas->isParametric(2));
+                    SkASSERT(gammas->data(0) == gammas->data(1));
+                    SkASSERT(gammas->data(0) == gammas->data(2));
+
+                    if (memory) {
+                        *((ColorSpaceHeader*) memory) =
+                                ColorSpaceHeader::Pack(k0_Version, 0, as_CSB(this)->fGammaNamed,
+                                                       ColorSpaceHeader::kTransferFn_Flag);
+                        memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
+
+                        *(((float*) memory) + 0) = gammas->params(0).fA;
+                        *(((float*) memory) + 1) = gammas->params(0).fB;
+                        *(((float*) memory) + 2) = gammas->params(0).fC;
+                        *(((float*) memory) + 3) = gammas->params(0).fD;
+                        *(((float*) memory) + 4) = gammas->params(0).fE;
+                        *(((float*) memory) + 5) = gammas->params(0).fF;
+                        *(((float*) memory) + 6) = gammas->params(0).fG;
+                        memory = SkTAddOffset<void>(memory, 7 * sizeof(float));
+
+                        as_CSB(this)->fToXYZD50.as3x4RowMajorf((float*) memory);
+                    }
+
+                    return sizeof(ColorSpaceHeader) + 19 * sizeof(float);
                 }
-                return sizeof(ColorSpaceHeader) + 15 * sizeof(float);
         }
     }
 
     // Otherwise, serialize the ICC data.
     size_t profileSize = as_CSB(this)->fProfileData->size();
     if (SkAlign4(profileSize) != (uint32_t) SkAlign4(profileSize)) {
         return 0;
     }
 
     if (memory) {
@@ skipping 73 matching lines @@
             float gammas[3];
             gammas[0] = *(((const float*) data) + 0);
             gammas[1] = *(((const float*) data) + 1);
             gammas[2] = *(((const float*) data) + 2);
             data = SkTAddOffset<const void>(data, 3 * sizeof(float));
 
             SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
             toXYZ.set3x4RowMajorf((const float*) data);
             return SkColorSpace_Base::NewRGB(gammas, toXYZ);
         }
+        case ColorSpaceHeader::kTransferFn_Flag: {
+            if (length < 19 * sizeof(float)) {
+                return nullptr;
+            }
+
+            SkColorSpaceTransferFn transferFn;
+            transferFn.fA = *(((const float*) data) + 0);
+            transferFn.fB = *(((const float*) data) + 1);
+            transferFn.fC = *(((const float*) data) + 2);
+            transferFn.fD = *(((const float*) data) + 3);
+            transferFn.fE = *(((const float*) data) + 4);
+            transferFn.fF = *(((const float*) data) + 5);
+            transferFn.fG = *(((const float*) data) + 6);
+            data = SkTAddOffset<const void>(data, 7 * sizeof(float));
+
+            SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
+            toXYZ.set3x4RowMajorf((const float*) data);
+            return SkColorSpace::NewRGB(transferFn, toXYZ);
+        }
         default:
             return nullptr;
     }
 }
 
 bool SkColorSpace::Equals(const SkColorSpace* src, const SkColorSpace* dst) {
     if (src == dst) {
         return true;
     }
 
@@ skipping 25 matching lines @@
                 return false;
             }
 
             // It is unlikely that we will reach this case.
             sk_sp<SkData> srcData = src->serialize();
             sk_sp<SkData> dstData = dst->serialize();
             return srcData->size() == dstData->size() &&
                    0 == memcmp(srcData->data(), dstData->data(), srcData->size());
     }
 }