Add SkColorSpacePrimaries to help with making D50 matrices

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"
@@ skipping 107 matching lines @@
             break;
     }
 
     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);
 }
 
+sk_sp<SkColorSpace> SkColorSpace::NewRGB(const GammaCoefficients& coeffs,
+                                         const SkMatrix44& toXYZD50) {
+    // TODO: Check if coeffs match sRGB, 2.2, or linear.
+    // TODO: Make sure coefficients are non-crazy.  Return nullptr if they are.
+    void* memory = sk_malloc_throw(sizeof(SkGammas) + sizeof(SkColorSpace::GammaParams));
+    sk_sp<SkGammas> gammas = sk_sp<SkGammas>(new (memory) SkGammas());
+    void* storage = SkTAddOffset<void>(memory, sizeof(SkGammas));
+     memcpy(storage, &coeffs, sizeof(SkColorSpace::GammaParams));
+     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_GammaNamed,
+                                                      std::move(gammas), toXYZD50, nullptr);
+}
+
+sk_sp<SkColorSpace> SkColorSpace::NewRGB(GammaNamed gammaNamed, const Primaries& primaries) {
+    SkMatrix44 toXYZD50;
+    // TODO: Implement primaries_to_toXYZD50.
+    if (!primaries_to_toXYZD50(&toXYZD50, primaries)) {
+        return nullptr;
+    }
+
+    return NewRGB(gammaNamed, toXYZD50)
+}
+
+sk_sp<SkColorSpace> SkColorSpace::NewRGB(const GammaCoefficients& coeffs,
+                                         const Primaries& primaries) {
+    SkMatrix44 toXYZD50;
+    if (!primaries_to_toXYZD50(&toXYZD50, primaries)) {
+        return nullptr;
+    }
+
+    return NewRGB(coeffs, toXYZD50)
+}
+
 sk_sp<SkColorSpace> SkColorSpace::NewNamed(Named named) {
     static SkOnce sRGBOnce;
     static sk_sp<SkColorSpace> sRGB;
     static SkOnce adobeRGBOnce;
     static sk_sp<SkColorSpace> adobeRGB;
 
     switch (named) {
         case kSRGB_Named: {
             sRGBOnce([] {
                 SkMatrix44 srgbToxyzD50(SkMatrix44::kUninitialized_Constructor);
@@ skipping 106 matching lines @@
                 if (memory) {
                     *((ColorSpaceHeader*) memory) =
                             ColorSpaceHeader::Pack(k0_Version, fNamed, fGammaNamed,
                                                    ColorSpaceHeader::kMatrix_Flag);
                     memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
                     fToXYZD50.as4x3ColMajorf((float*) memory);
                 }
                 return sizeof(ColorSpaceHeader) + 12 * sizeof(float);
             }
             default:
+                // TODO: This case gets trickier.  The code below exists because I allow
+                //       SkPngCodec to call a constructor with float gammas.
+                //       I think the best thing to do would be:
+                //       (1) Fix SkPngCodec to call one of the new constructors.
+                //       (2) Handle serializing the parametric gammas here.
+                // TODO: In a separate CL, remove the idea of "exponential" gammas.
+                //       These can be consumed by the parametric case.  Maybe this CL
+                //       should land first.
+
                 // Otherwise, write the gamma values and the matrix.
                 if (memory) {
                     *((ColorSpaceHeader*) memory) =
                             ColorSpaceHeader::Pack(k0_Version, fNamed, 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 &&
@@ skipping 83 matching lines @@
             uint32_t profileSize = *((uint32_t*) data);
             data = SkTAddOffset<const void>(data, sizeof(uint32_t));
             length -= sizeof(uint32_t);
             if (length < profileSize) {
                 return nullptr;
             }
 
             return NewICC(data, profileSize);
         }
         case ColorSpaceHeader::kFloatGamma_Flag: {
+            // TODO: This needs to be fixed to match the new version of serialize().
+
             if (length < 15 * sizeof(float)) {
                 return nullptr;
             }
 
             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));
 
@@ skipping 41 matching lines @@
     // gammas, but also include other wacky features that cause us to save the data.
     switch (src->fGammaNamed) {
         case kSRGB_GammaNamed:
         case k2Dot2Curve_GammaNamed:
         case kLinear_GammaNamed:
             return (src->fGammaNamed == dst->fGammaNamed) && (src->fToXYZD50 == dst->fToXYZD50);
         default:
             if (src->fGammaNamed != dst->fGammaNamed) {
                 return false;
             }
+            // This should still work :).
 
             // 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());
     }
 }
 
 bool SkColorSpace::gammasAreMatching() const {
@@ skipping 27 matching lines @@
            gammas->fBlueType == SkGammas::Type::kTable_Type;
 }
 
 bool SkColorSpace::gammasAreParams() const {
     const SkGammas* gammas = as_CSB(this)->gammas();
     SkASSERT(gammas);
     return gammas->fRedType == SkGammas::Type::kParam_Type &&
            gammas->fGreenType == SkGammas::Type::kParam_Type &&
            gammas->fBlueType == SkGammas::Type::kParam_Type;
 }