Parse A2B0 tag on ICC profiles

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 SkFloat3x3& toXYZD50, const SkFloat3& gamma, Named named)
-    : fToXYZD50(toXYZD50)
-    , fGamma(gamma)
+SkColorSpace::SkColorSpace(const SkFloat3& gamma, const SkFloat3x3& toXYZD50, Named named)
+    : fGamma(gamma)
+    , 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, const SkFloat3& toXYZOffset)
+    : fColorLUT(std::move(colorLUT))
+    , fGamma(gamma)
+    , fToXYZD50(toXYZD50)
+    , fToXYZOffset(toXYZOffset)
+    , fUniqueID(sk_atomic_inc(&gUniqueColorSpaceID))
+    , fNamed(kUnknown_Named)
+{}
+
 sk_sp<SkColorSpace> SkColorSpace::NewRGB(const SkFloat3x3& toXYZD50, const SkFloat3& gamma) {
     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(toXYZD50, gamma, kUnknown_Named));
+    return sk_sp<SkColorSpace>(new SkColorSpace(gamma, 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_toXYZD50, gDevice_gamma,
+            return sk_sp<SkColorSpace>(new SkColorSpace(gDevice_gamma, gDevice_toXYZD50,
                                                         kDevice_Named));
         case kSRGB_Named:
-            return sk_sp<SkColorSpace>(new SkColorSpace(gSRGB_toXYZD50, gSRGB_gamma, kSRGB_Named));
+            return sk_sp<SkColorSpace>(new SkColorSpace(gSRGB_gamma, gSRGB_toXYZD50, kSRGB_Named));
         default:
             break;
     }
     return nullptr;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "SkFixed.h"
 #include "SkTemplates.h"
@@ skipping 164 matching lines @@
     static const ICCTag* Find(const ICCTag tags[], int count, uint32_t signature) {
         for (int i = 0; i < count; ++i) {
             if (tags[i].fSignature == signature) {
                 return &tags[i];
             }
         }
         return nullptr;
     }
 };
 
-// TODO (msarett):
-// Should we recognize more tags?
 static const uint32_t kTAG_rXYZ = SkSetFourByteTag('r', 'X', 'Y', 'Z');
 static const uint32_t kTAG_gXYZ = SkSetFourByteTag('g', 'X', 'Y', 'Z');
 static const uint32_t kTAG_bXYZ = SkSetFourByteTag('b', 'X', 'Y', 'Z');
 static const uint32_t kTAG_rTRC = SkSetFourByteTag('r', 'T', 'R', 'C');
 static const uint32_t kTAG_gTRC = SkSetFourByteTag('g', 'T', 'R', 'C');
 static const uint32_t kTAG_bTRC = SkSetFourByteTag('b', 'T', 'R', 'C');
+static const uint32_t kTAG_A2B0 = SkSetFourByteTag('A', '2', 'B', '0');
 
 bool load_xyz(float dst[3], const uint8_t* src, size_t len) {
     if (len < 20) {
         SkColorSpacePrintf("XYZ tag is too small (%d bytes)", len);
         return false;
     }
 
     dst[0] = SkFixedToFloat(read_big_endian_int(src + 8));
     dst[1] = SkFixedToFloat(read_big_endian_int(src + 12));
     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');
 
-static bool load_gamma(float* gamma, const uint8_t* src, size_t len) {
-    if (len < 14) {
-        SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
-        return false;
-    }
-
-    uint32_t type = read_big_endian_uint(src);
-    switch (type) {
-        case kTAG_CurveType: {
-            uint32_t count = read_big_endian_int(src + 8);
-            if (0 == count) {
+// 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) {
+    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;
+                    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;
+                    SkColorSpacePrintf("gamma %d %g\n", value, *gamma);
+                    break;
+                }
+
+                // Print the interpolation table.  For now, we ignore this and guess 2.2f.
+                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] = 2.2f;
+                break;
+            }
+            case kTAG_ParaCurveType:
+                // Guess 2.2f.
+                SkColorSpacePrintf("parametric curve\n");
+                gammas[i] = 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;
+                        break;
+                    case 3:
+                        tagBytes = 12 + 20;
+                        break;
+                    case 4:
+                        tagBytes = 12 + 28;
+                        break;
+                    default:
+                        SkColorSpacePrintf("Invalid parametric curve type\n");
+                        return false;
+                }
+                break;
+            default:
+                SkColorSpacePrintf("Unsupported gamma tag type %d\n", type);
+                return false;
+        }
+
+        // Adjust src and len if there is another gamma curve to load.
+        if (0 != numGammas) {
+            // Each curve is padded to 4-byte alignment.
+            tagBytes = SkAlign4(tagBytes);
+            if (len < tagBytes) {
                 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);
-                *gamma = value / 256.0f;
-                SkColorSpacePrintf("gamma %d %g\n", value, *gamma);
-                return true;
-            }
-
-            // Check length again if we have a table.
-            if (len < 12 + 2 * count) {
-                SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
-                return false;
-            }
-
-            // 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]));
-            }
-
-            *gamma = 2.2f;
+            src += tagBytes;
+            len -= tagBytes;
+        }
+    }
+
+    // If all of the gammas we encounter are 1.0f, indicate that we failed to load gammas.
+    // 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;
         }
-        case kTAG_ParaCurveType:
-            // Guess 2.2f.
-            SkColorSpacePrintf("parametric curve\n");
-            *gamma = 2.2f;
-            return true;
+    }
+
+    return false;
+}
+
+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);
+    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
+    // of the table values.
+    uint8_t precision = src[16];
+    switch (precision) {
+        case 1: // 8-bit data
+        case 2: // 16-bit data
+            break;
         default:
-            SkColorSpacePrintf("Unsupported gamma tag type %d\n", type);
+            SkColorSpacePrintf("Color LUT precision must be 8-bit or 16-bit.\n", len);
             return false;
     }
+
+    if (len < 20 + numEntries * precision) {
+        SkColorSpacePrintf("Color LUT tag is too small (%d bytes).", len);
+        return false;
+    }
+
+    // Movable struct colorLUT has ownership of fTable.
+    colorLUT->fTable = std::unique_ptr<float[]>(new float[numEntries]);
+    const uint8_t* ptr = src + 20;
+    for (uint32_t i = 0; i < numEntries; i++, ptr += precision) {
+        if (1 == precision) {
+            colorLUT->fTable[i] = ((float) ptr[i]) / 255.0f;
+        } else {
+            colorLUT->fTable[i] = ((float) read_big_endian_short(ptr)) / 65535.0f;
+        }
+    }
+
+    return true;
+}
+
+bool load_matrix(SkFloat3x3* toXYZ, SkFloat3* toXYZOffset, const uint8_t* src, size_t len) {
+    if (len < 48) {
+        SkColorSpacePrintf("Matrix tag is too small (%d bytes).", len);
+        return false;
+    }
+
+    toXYZ->fMat[0] = SkFixedToFloat(read_big_endian_int(src));
+    toXYZ->fMat[3] = SkFixedToFloat(read_big_endian_int(src + 4));
+    toXYZ->fMat[6] = SkFixedToFloat(read_big_endian_int(src + 8));
+    toXYZ->fMat[1] = SkFixedToFloat(read_big_endian_int(src + 12));
+    toXYZ->fMat[4] = SkFixedToFloat(read_big_endian_int(src + 16));
+    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) {
+    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) {
+        // 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.
+    uint32_t offsetToACurves = read_big_endian_int(src + 28);
+    uint32_t offsetToBCurves = read_big_endian_int(src + 12);
+    if ((0 != offsetToACurves) || (0 != offsetToBCurves)) {
+        // FIXME (msarett): Handle A and B curves.
+        // Note that the A curve is technically required in order to have a color LUT.
+        // However, all the A curves I have seen so far have are just placeholders that
+        // don't actually transform the data.
+        SkColorSpacePrintf("Ignoring A and/or B curve.  Output may be wrong.\n");
+    }
+
+    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))
+        {
+            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");
+        }
+    }
+
+    return true;
 }
 
 sk_sp<SkColorSpace> SkColorSpace::NewICC(const void* base, size_t len) {
     const uint8_t* ptr = (const uint8_t*) base;
 
     if (len < kICCHeaderSize) {
         return_null("Data is not large enough to contain an ICC profile");
     }
 
     // Read the ICC profile header and check to make sure that it is valid.
@@ skipping 25 matching lines @@
         ptr = tags[i].init(ptr);
         SkColorSpacePrintf("[%d] %c%c%c%c %d %d\n", i, (tags[i].fSignature >> 24) & 0xFF,
                 (tags[i].fSignature >> 16) & 0xFF, (tags[i].fSignature >>  8) & 0xFF,
                 (tags[i].fSignature >>  0) & 0xFF, tags[i].fOffset, tags[i].fLength);
 
         if (!tags[i].valid(kICCHeaderSize + len)) {
             return_null("Tag is too large to fit in ICC profile");
         }
     }
 
-    // Load our XYZ and gamma matrices.
-    SkFloat3x3 toXYZ;
-    SkFloat3 gamma {{ 1.0f, 1.0f, 1.0f }};
     switch (header.fInputColorSpace) {
         case kRGB_ColorSpace: {
+            // Recognize the rXYZ, gXYZ, and bXYZ tags.
             const ICCTag* r = ICCTag::Find(tags.get(), tagCount, kTAG_rXYZ);
             const ICCTag* g = ICCTag::Find(tags.get(), tagCount, kTAG_gXYZ);
             const ICCTag* b = ICCTag::Find(tags.get(), tagCount, kTAG_bXYZ);
-            if (!r || !g || !b) {
-                return_null("Need rgb tags for XYZ space");
+            if (r && g && b) {
+                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 }};
+                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))
+                {
+                    SkColorSpacePrintf("Failed to read R gamma tag.\n");
+                }
+                if (!g ||
+                    !load_gammas(&gamma.fVec[1], 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))
+                {
+                    SkColorSpacePrintf("Failed to read B gamma tag.\n");
+                }
+                return SkColorSpace::NewRGB(toXYZ, gamma);
             }
 
-            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");
+            // Recognize color profile specified by A2B0 tag.
+            const ICCTag* a2b0 = ICCTag::Find(tags.get(), tagCount, kTAG_A2B0);
+            if (a2b0) {
+                SkColorLookUpTable colorLUT;
+                SkFloat3 gamma;
+                SkFloat3x3 toXYZ;
+                SkFloat3 toXYZOffset;
+                if (!load_a2b0(&colorLUT, &gamma, &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));
             }
 
-            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_gamma(&gamma.fVec[0], r->addr((const uint8_t*) base), r->fLength)) {
-                SkColorSpacePrintf("Failed to read R gamma tag.\n");
-            }
-            if (!g || !load_gamma(&gamma.fVec[1], g->addr((const uint8_t*) base), g->fLength)) {
-                SkColorSpacePrintf("Failed to read G gamma tag.\n");
-            }
-            if (!b || !load_gamma(&gamma.fVec[2], b->addr((const uint8_t*) base), b->fLength)) {
-                SkColorSpacePrintf("Failed to read B gamma tag.\n");
-            }
-            return SkColorSpace::NewRGB(toXYZ, gamma);
         }
         default:
             break;
     }
 
     return_null("ICC profile contains unsupported colorspace");
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 75 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