Parse parametric gamma curves

src/core/SkColorSpacePriv.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkColorSpacePriv_DEFINED
 #define SkColorSpacePriv_DEFINED
 
 struct SkGammaCurve {
     bool isValue() const {
         bool result = (0.0f != fValue);
         SkASSERT(!result || (0 == fTableSize));
+        SkASSERT(!result || (0.0f == fG));
         return result;
     }
 
     bool isTable() const {
         bool result = (0 != fTableSize);
         SkASSERT(!result || (0.0f == fValue));
+        SkASSERT(!result || (0.0f == fG));
         SkASSERT(!result || fTable);
         return result;
     }
 
-    bool isParametric() const { return false; }
+    bool isParametric() const {
+        bool result = (0.0f != fG);
+        SkASSERT(!result || (0.0f == fValue));
+        SkASSERT(!result || (0 == fTableSize));
+        return result;
+    }
 
     // We have three different ways to represent gamma.
     // (1) A single value:
     float                    fValue;
 
     // (2) A lookup table:
     uint32_t                 fTableSize;
     std::unique_ptr<float[]> fTable;
 
     // (3) Parameters for a curve:
-    // FIXME (msarett): Handle parametric curves.
+    //     Y = (aX + b)^g + c  for X >= d
+    //     Y = eX + f          otherwise
+    float                    fG;

[scroggo, 2016/05/18 12:49:15]

Why does G come first?

[msarett, 2016/05/18 13:14:01]

In my mind it makes sense because g is the "most important".

Every parametric curve always has an exponent g.  And g is always the first
parameter that we read from the profile.

We check whether or not we have g to decide if we actually have a parametric
curve.

The other parameters are optional (except I guess we always have A as well...)

+    float                    fA;
+    float                    fB;
+    float                    fC;
+    float                    fD;
+    float                    fE;
+    float                    fF;
 
     SkGammaCurve() {
         memset(this, 0, sizeof(struct SkGammaCurve));
     }
 
     SkGammaCurve(float value)
         : fValue(value)
         , fTableSize(0)
         , fTable(nullptr)
+        , fG(0.0f)
+        , fA(0.0f)
+        , fB(0.0f)
+        , fC(0.0f)
+        , fD(0.0f)
+        , fE(0.0f)
+        , fF(0.0f)
     {}
 };
 
 struct SkGammas : public SkRefCnt {
 public:
     bool isValues() const {
         return fRed.isValue() && fGreen.isValue() && fBlue.isValue();
     }
 
     const SkGammaCurve fRed;
@@ skipping 24 matching lines @@
     uint8_t                  fOutputChannels;
     uint8_t                  fGridPoints[kMaxChannels];
     std::unique_ptr<float[]> fTable;
 
     SkColorLookUpTable() {
         memset(this, 0, sizeof(struct SkColorLookUpTable));
     }
 };
 
 #endif