Drafts and half ideas

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 "SkAtomics.h"
 #include "SkColorSpace.h"
 
@@ skipping 70 matching lines @@
     SkDebugf("[%7.4f %7.4f %7.4f] [%7.4f %7.4f %7.4f] [%7.4f %7.4f %7.4f]\n",
              fMat[0], fMat[1], fMat[2],
              fMat[3], fMat[4], fMat[5],
              fMat[6], fMat[7], fMat[8]);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
 static int32_t gUniqueColorSpaceID;
 
-SkColorSpace::SkColorSpace(const SkFloat3& gamma, const SkFloat3x3& toXYZD50, Named named)
-    : fGamma(gamma)
+SkColorSpace::SkColorSpace(SkGammas gammas, const SkFloat3x3& toXYZD50, Named named)
+    : fGammas(std::move(gammas))
     , fToXYZD50(toXYZD50)
     , fToXYZOffset({ 0.0f, 0.0f, 0.0f })
     , fUniqueID(sk_atomic_inc(&gUniqueColorSpaceID))
     , fNamed(named)
 {
     for (int i = 0; i < 3; ++i) {
-        SkASSERT(SkFloatIsFinite(gamma.fVec[i]));
         for (int j = 0; j < 3; ++j) {
             SkASSERT(SkFloatIsFinite(toXYZD50.fMat[3*i + j]));
         }
     }
 }
 
-SkColorSpace::SkColorSpace(SkColorLookUpTable colorLUT, const SkFloat3& gamma, const SkFloat3x3& toXYZD50,
+SkColorSpace::SkColorSpace(SkColorLookUpTable colorLUT, SkGammas gammas, const SkFloat3x3& toXYZD50,
                            const SkFloat3& toXYZOffset)
     : fColorLUT(std::move(colorLUT))
-    , fGamma(gamma)
+    , fGammas(gammas)
     , fToXYZD50(toXYZD50)
     , fToXYZOffset(toXYZOffset)
     , fUniqueID(sk_atomic_inc(&gUniqueColorSpaceID))
     , fNamed(kUnknown_Named)
 {}
 
-sk_sp<SkColorSpace> SkColorSpace::NewRGB(const SkFloat3x3& toXYZD50, const SkFloat3& gamma) {
+sk_sp<SkColorSpace> SkColorSpace::NewRGB(const SkFloat3x3& toXYZD50, SkGammas gammas) {
     for (int i = 0; i < 3; ++i) {
-        if (!SkFloatIsFinite(gamma.fVec[i]) || gamma.fVec[i] < 0) {
-            return nullptr;
-        }
         for (int j = 0; j < 3; ++j) {
             if (!SkFloatIsFinite(toXYZD50.fMat[3*i + j])) {
                 return nullptr;
             }
         }
     }
 
     // check the matrix for invertibility
     float d = det(toXYZD50);
     if (!SkFloatIsFinite(d) || !SkFloatIsFinite(1 / d)) {
         return nullptr;
     }
 
-    return sk_sp<SkColorSpace>(new SkColorSpace(gamma, toXYZD50, kUnknown_Named));
+    return sk_sp<SkColorSpace>(new SkColorSpace(std::move(gammas), toXYZD50, kUnknown_Named));
 }
 
 void SkColorSpace::dump() const {
     fToXYZD50.dump();
-    fGamma.dump();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
-const SkFloat3   gDevice_gamma {{ 0, 0, 0 }};
 const SkFloat3x3 gDevice_toXYZD50 {{
     1, 0, 0,
     0, 1, 0,
     0, 0, 1
 }};
 
-const SkFloat3 gSRGB_gamma {{ 2.2f, 2.2f, 2.2f }};
 const SkFloat3x3 gSRGB_toXYZD50 {{
     0.4358f, 0.2224f, 0.0139f,    // * R
     0.3853f, 0.7170f, 0.0971f,    // * G
     0.1430f, 0.0606f, 0.7139f,    // * B
 }};
 
 sk_sp<SkColorSpace> SkColorSpace::NewNamed(Named named) {
     switch (named) {
         case kDevice_Named:
-            return sk_sp<SkColorSpace>(new SkColorSpace(gDevice_gamma, gDevice_toXYZD50,
+            return sk_sp<SkColorSpace>(new SkColorSpace(std::move(SkGammas()), gDevice_toXYZD50,
                                                         kDevice_Named));
         case kSRGB_Named:
-            return sk_sp<SkColorSpace>(new SkColorSpace(gSRGB_gamma, gSRGB_toXYZD50, kSRGB_Named));
+            return sk_sp<SkColorSpace>(new SkColorSpace(std::move(SkGammas::sRGB()), gSRGB_toXYZD50,
+                                                        kSRGB_Named));
         default:
             break;
     }
     return nullptr;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "SkFixed.h"
 #include "SkTemplates.h"
@@ skipping 190 matching lines @@
     dst[2] = SkFixedToFloat(read_big_endian_int(src + 16));
     SkColorSpacePrintf("XYZ %g %g %g\n", dst[0], dst[1], dst[2]);
     return true;
 }
 
 static const uint32_t kTAG_CurveType     = SkSetFourByteTag('c', 'u', 'r', 'v');
 static const uint32_t kTAG_ParaCurveType = SkSetFourByteTag('p', 'a', 'r', 'a');
 
 // FIXME (msarett):
 // We need to handle the possibility that the gamma curve does not correspond to 2.2f.
-static bool load_gammas(float* gammas, uint32_t numGammas, const uint8_t* src, size_t len) {
+static bool load_gammas(SkGamma* gammas, uint32_t numGammas, const uint8_t* src, size_t len) {
     for (uint32_t i = 0; i < numGammas; i++) {
         if (len < 12) {
             // FIXME (msarett):
             // We could potentially return false here after correctly parsing *some* of the
             // gammas correctly.  Should we somehow try to indicate a partial success?
             SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
             return false;
         }
 
         // We need to count the number of bytes in the tag, so we are able to move to the
         // next tag on the next loop iteration.
         size_t tagBytes;
 
         uint32_t type = read_big_endian_uint(src);
         switch (type) {
             case kTAG_CurveType: {
                 uint32_t count = read_big_endian_uint(src + 8);
                 tagBytes = 12 + count * 2;
                 if (0 == count) {
                     // Some tags require a gamma curve, but the author doesn't actually want
                     // to transform the data.  In this case, it is common to see a curve with
                     // a count of 0.
-                    gammas[i] = 1.0f;
+                    gammas[i].fFlag = SkGamma::kGammaUseValueFlag;
+                    gammas[i].fValue = 1.0f;
                     break;
                 } else if (len < 12 + 2 * count) {
                     SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
                     return false;
                 }
 
                 const uint16_t* table = (const uint16_t*) (src + 12);
                 if (1 == count) {
                     // Table entry is the exponent (bias 256).
                     uint16_t value = read_big_endian_short((const uint8_t*) table);
-                    gammas[i] = value / 256.0f;
+                    gammas[i].fFlag = SkGamma::kGammaUseValueFlag;
+                    gammas[i].fValue = value / 256.0f;
                     SkColorSpacePrintf("gamma %d %g\n", value, *gamma);
                     break;
                 }
 
-                // Print the interpolation table.  For now, we ignore this and guess 2.2f.
-                for (uint32_t i = 0; i < count; i++) {
-                    SkColorSpacePrintf("curve[%d] %d\n", i,
-                            read_big_endian_short((const uint8_t*) &table[i]));
+                // Fill in the interpolation table.
+                // FIXME (msarett):
+                // We should recognize commonly occurring tables and just set gamma to 2.2f.
+                gammas[i].fFlag = SkGamma::kGammaUseTableFlag;
+                gammas[i].fTableSize = count;
+                gammas[i].fTable = std::unique_ptr(new float[count]);
+                for (uint32_t j = 0; j < count; j++) {
+                    gammas[i].fTable[j] =
+                            (read_big_endian_short((const uint8_t*) &table[j])) / 65535.0f;
                 }
-
-                gammas[i] = 2.2f;
                 break;
             }
             case kTAG_ParaCurveType:
                 // Guess 2.2f.
                 SkColorSpacePrintf("parametric curve\n");
-                gammas[i] = 2.2f;
+                gammas[i].fFlag = SkGamma::kGammaUseValueFlag;
+                gammas[i].fValue = 2.2f;
 
                 switch(read_big_endian_short(src + 8)) {
                     case 0:
                         tagBytes = 12 + 4;
                         break;
                     case 1:
                         tagBytes = 12 + 12;
                         break;
                     case 2:
                         tagBytes = 12 + 16;
@@ skipping 362 matching lines @@
 }
 
 // D65 white point of Rec.  709 [8] are:
 //
 // D65 white-point in unit luminance XYZ = 0.9505, 1.0000, 1.0890
 //
 //          R           G           B           white
 //   x      0.640       0.300       0.150       0.3127
 //   y      0.330       0.600       0.060       0.3290
 //   z      0.030       0.100       0.790       0.3582