Introduce SkGammas type to represent ICC gamma curves

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"
 
 void SkFloat3::dump() const {
     SkDebugf("[%7.4f %7.4f %7.4f]\n", fVec[0], fVec[1], fVec[2]);
 }
 
 void SkFloat3x3::dump() const {
     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)
 {}
 
-SkColorSpace::SkColorSpace(SkColorLookUpTable colorLUT, const SkFloat3& gamma,
+SkColorSpace::SkColorSpace(SkColorLookUpTable colorLUT, SkGammas gammas,
                            const SkFloat3x3& toXYZD50, const SkFloat3& toXYZOffset)
     : fColorLUT(std::move(colorLUT))
-    , fGamma(gamma)
+    , fGammas(std::move(gammas))
     , fToXYZD50(toXYZD50)
     , fToXYZOffset(toXYZOffset)
     , fUniqueID(sk_atomic_inc(&gUniqueColorSpaceID))
     , fNamed(kUnknown_Named)
 {}
 
-sk_sp<SkColorSpace> SkColorSpace::NewRGB(const SkFloat3x3& toXYZD50, const SkFloat3& gamma) {
-    return sk_sp<SkColorSpace>(new SkColorSpace(gamma, toXYZD50, kUnknown_Named));
+sk_sp<SkColorSpace> SkColorSpace::NewRGB(const SkFloat3x3& toXYZD50, SkGammas gammas) {
+    return sk_sp<SkColorSpace>(new SkColorSpace(std::move(gammas), toXYZD50, kUnknown_Named));
 }
 
-const SkFloat3 gSRGB_gamma {{ 2.2f, 2.2f, 2.2f }};
+SkGammas gSRGB_gamma = { SkGammaCurve(2.2f), SkGammaCurve(2.2f), SkGammaCurve(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 kSRGB_Named:
-            return sk_sp<SkColorSpace>(new SkColorSpace(gSRGB_gamma, gSRGB_toXYZD50, kSRGB_Named));
+            return sk_sp<SkColorSpace>(new SkColorSpace(std::move(gSRGB_gamma), 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(SkGammaCurve* 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].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).
+                    // The table entry is the gamma (with a bias of 256).
                     uint16_t value = read_big_endian_short((const uint8_t*) table);
-                    gammas[i] = value / 256.0f;
+                    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.
+                // Fill in the interpolation table.
+                // FIXME (msarett):
+                // We should recognize commonly occurring tables and just set gamma to 2.2f.

[Brian Osman, 2016/04/29 13:15:50]

Best approach for this might just be to compute the error vs. pow(x, 2.2) as
you're copying the table, and record the largest absolute difference, then we
can just have a threshold for deciding if the curve is close enough.

[msarett, 2016/04/29 14:07:08]

I think that's a really good idea!

I've also considered sampling a few arbitrary points and checking if they are a
close match to some canonical curves.  This may be a bit less computation, but
also way less robust.

I'm planning to handle this in a follow up.

+                gammas[i].fTableSize = count;
+                gammas[i].fTable = std::unique_ptr<float[]>(new float[count]);
                 for (uint32_t j = 0; j < count; j++) {
-                    SkColorSpacePrintf("curve[%d] %d\n", j,
-                            read_big_endian_short((const uint8_t*) &table[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.
+                // FIXME (msarett): Handle parametric curves.
                 SkColorSpacePrintf("parametric curve\n");
-                gammas[i] = 2.2f;
+                gammas[i].fValue = 2.2f;
 
+                // Determine the size of the parametric curve tag.
                 switch(read_big_endian_short(src + 8)) {
                     case 0:
                         tagBytes = 12 + 4;
                         break;
                     case 1:
                         tagBytes = 12 + 12;
                         break;
                     case 2:
                         tagBytes = 12 + 16;
                         break;
@@ skipping 19 matching lines @@
             tagBytes = SkAlign4(tagBytes);
             if (len < tagBytes) {
                 return false;
             }
 
             src += tagBytes;
             len -= tagBytes;
         }
     }
 
-    // If all of the gammas we encounter are 1.0f, indicate that we failed to load gammas.

[msarett, 2016/04/28 21:26:48]

I don't think this is the right place for this optimization.

-    // There is no need to apply a gamma of 1.0f.
-    for (uint32_t i = 0; i < numGammas; i++) {
-        if (1.0f != gammas[i]) {
-            return true;
-        }
-    }
-
-    return false;
+    return true;
 }
 
 static const uint32_t kTAG_AtoBType = SkSetFourByteTag('m', 'A', 'B', ' ');
 
 bool load_color_lut(SkColorLookUpTable* colorLUT, uint32_t inputChannels, uint32_t outputChannels,
         const uint8_t* src, size_t len) {
     if (len < 20) {
         SkColorSpacePrintf("Color LUT tag is too small (%d bytes).", len);
         return false;
     }
 
-    SkASSERT(inputChannels <= SkColorLookUpTable::kMaxChannels &&
-             outputChannels <= SkColorLookUpTable::kMaxChannels);
+    SkASSERT(inputChannels <= SkColorLookUpTable::kMaxChannels && 3 == outputChannels);
     colorLUT->fInputChannels = inputChannels;
     colorLUT->fOutputChannels = outputChannels;
     uint32_t numEntries = 1;
     for (uint32_t i = 0; i < inputChannels; i++) {
         colorLUT->fGridPoints[i] = src[i];
         numEntries *= src[i];
     }
     numEntries *= outputChannels;
 
     // Space is provided for a maximum of the 16 input channels.  Now we determine the precision
@@ skipping 41 matching lines @@
     toXYZ->fMat[7] = SkFixedToFloat(read_big_endian_int(src + 20));
     toXYZ->fMat[2] = SkFixedToFloat(read_big_endian_int(src + 24));
     toXYZ->fMat[5] = SkFixedToFloat(read_big_endian_int(src + 28));
     toXYZ->fMat[8] = SkFixedToFloat(read_big_endian_int(src + 32));
     toXYZOffset->fVec[0] = SkFixedToFloat(read_big_endian_int(src + 36));
     toXYZOffset->fVec[1] = SkFixedToFloat(read_big_endian_int(src + 40));
     toXYZOffset->fVec[2] = SkFixedToFloat(read_big_endian_int(src + 44));
     return true;
 }
 
-bool load_a2b0(SkColorLookUpTable* colorLUT, SkFloat3* gamma, SkFloat3x3* toXYZ,
-        SkFloat3* toXYZOffset, const uint8_t* src, size_t len) {
+bool load_a2b0(SkColorLookUpTable* colorLUT, SkGammas* gammas, SkFloat3x3* toXYZ,
+               SkFloat3* toXYZOffset, const uint8_t* src, size_t len) {
     if (len < 32) {
         SkColorSpacePrintf("A to B tag is too small (%d bytes).", len);
         return false;
     }
 
     uint32_t type = read_big_endian_uint(src);
     if (kTAG_AtoBType != type) {
         // FIXME (msarett): Need to support lut8Type and lut16Type.
         SkColorSpacePrintf("Unsupported A to B tag type.\n");
         return false;
     }
 
     // Read the number of channels.  The four bytes that we skipped are reserved and
     // must be zero.
     uint8_t inputChannels = src[8];
     uint8_t outputChannels = src[9];
     if (0 == inputChannels || inputChannels > SkColorLookUpTable::kMaxChannels ||
-            0 < outputChannels || outputChannels > SkColorLookUpTable::kMaxChannels) {
+            3 != outputChannels) {
         // The color LUT assumes that there are at most 16 input channels.  For RGB
         // profiles, output channels should be 3.
         SkColorSpacePrintf("Too many input or output channels in A to B tag.\n");
         return false;
     }
 
     // Read the offsets of each element in the A to B tag.  With the exception of A curves and
     // B curves (which we do not yet support), we will handle these elements in the order in
     // which they should be applied (rather than the order in which they occur in the tag).
     // If the offset is non-zero it indicates that the element is present.
@@ skipping 10 matching lines @@
     uint32_t offsetToColorLUT = read_big_endian_int(src + 24);
     if (0 != offsetToColorLUT && offsetToColorLUT < len) {
         if (!load_color_lut(colorLUT, inputChannels, outputChannels, src + offsetToColorLUT,
                 len - offsetToColorLUT)) {
             SkColorSpacePrintf("Failed to read color LUT from A to B tag.\n");
         }
     }
 
     uint32_t offsetToMCurves = read_big_endian_int(src + 20);
     if (0 != offsetToMCurves && offsetToMCurves < len) {
-        if (!load_gammas(gamma->fVec, outputChannels, src + offsetToMCurves, len - offsetToMCurves))
+        if (!load_gammas(&gammas->fRed, outputChannels, src + offsetToMCurves, len - offsetToMCurves))
         {
             SkColorSpacePrintf("Failed to read M curves from A to B tag.\n");
         }
     }
 
     uint32_t offsetToMatrix = read_big_endian_int(src + 16);
     if (0 != offsetToMatrix && offsetToMatrix < len) {
         if (!load_matrix(toXYZ, toXYZOffset, src + offsetToMatrix, len - offsetToMatrix)) {
             SkColorSpacePrintf("Failed to read matrix from A to B tag.\n");
         }
@@ skipping 55 matching lines @@
                 SkFloat3x3 toXYZ;
                 if (!load_xyz(&toXYZ.fMat[0], r->addr((const uint8_t*) base), r->fLength) ||
                     !load_xyz(&toXYZ.fMat[3], g->addr((const uint8_t*) base), g->fLength) ||
                     !load_xyz(&toXYZ.fMat[6], b->addr((const uint8_t*) base), b->fLength))
                 {
                     return_null("Need valid rgb tags for XYZ space");
                 }
 
                 // It is not uncommon to see missing or empty gamma tags.  This indicates
                 // that we should use unit gamma.
-                SkFloat3 gamma {{ 1.0f, 1.0f, 1.0f }};
+                SkGammas gammas;
                 r = ICCTag::Find(tags.get(), tagCount, kTAG_rTRC);
                 g = ICCTag::Find(tags.get(), tagCount, kTAG_gTRC);
                 b = ICCTag::Find(tags.get(), tagCount, kTAG_bTRC);
                 if (!r ||
-                    !load_gammas(&gamma.fVec[0], 1, r->addr((const uint8_t*) base), r->fLength))
+                    !load_gammas(&gammas.fRed, 1, r->addr((const uint8_t*) base), r->fLength))
                 {
                     SkColorSpacePrintf("Failed to read R gamma tag.\n");
                 }
                 if (!g ||
-                    !load_gammas(&gamma.fVec[1], 1, g->addr((const uint8_t*) base), g->fLength))
+                    !load_gammas(&gammas.fGreen, 1, g->addr((const uint8_t*) base), g->fLength))
                 {
                     SkColorSpacePrintf("Failed to read G gamma tag.\n");
                 }
                 if (!b ||
-                    !load_gammas(&gamma.fVec[2], 1, b->addr((const uint8_t*) base), b->fLength))
+                    !load_gammas(&gammas.fBlue, 1, b->addr((const uint8_t*) base), b->fLength))
                 {
                     SkColorSpacePrintf("Failed to read B gamma tag.\n");
                 }
-                return SkColorSpace::NewRGB(toXYZ, gamma);
+                return SkColorSpace::NewRGB(toXYZ, std::move(gammas));
             }
 
             // Recognize color profile specified by A2B0 tag.
             const ICCTag* a2b0 = ICCTag::Find(tags.get(), tagCount, kTAG_A2B0);
             if (a2b0) {
                 SkColorLookUpTable colorLUT;
-                SkFloat3 gamma;
+                SkGammas gammas;
                 SkFloat3x3 toXYZ;
                 SkFloat3 toXYZOffset;
-                if (!load_a2b0(&colorLUT, &gamma, &toXYZ, &toXYZOffset,
-                        a2b0->addr((const uint8_t*) base), a2b0->fLength)) {
+                if (!load_a2b0(&colorLUT, &gammas, &toXYZ, &toXYZOffset,
+                               a2b0->addr((const uint8_t*) base), a2b0->fLength)) {
                     return_null("Failed to parse A2B0 tag");
                 }
 
-                return sk_sp<SkColorSpace>(new SkColorSpace(std::move(colorLUT), gamma, toXYZ,
-                                                            toXYZOffset));
+                return sk_sp<SkColorSpace>(new SkColorSpace(std::move(colorLUT), std::move(gammas),
+                                                            toXYZ, toXYZOffset));
             }
 
         }
         default:
             break;
     }
 
     return_null("ICC profile contains unsupported colorspace");
 }