path: root/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 "SkOnce.h"

static bool color_space_almost_equal(float a, float b) {
    return SkTAbs(a - b) < 0.01f;
}

//////////////////////////////////////////////////////////////////////////////////////////////////

SkColorSpace::SkColorSpace(GammaNamed gammaNamed, const SkMatrix44& toXYZD50, Named named)
    : fGammaNamed(kNonStandard_GammaNamed)
    , fToXYZD50(toXYZD50)
    , fNamed(named)
{}

SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkGammas> gammas, const SkMatrix44& toXYZD50,
                                     Named named)
    : INHERITED(kNonStandard_GammaNamed, toXYZD50, named)
    , fGammas(gammas)
{}

SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkGammas> gammas, GammaNamed gammaNamed,
                                     const SkMatrix44& toXYZD50, Named named)
    : INHERITED(gammaNamed, toXYZD50, named)
    , fGammas(gammas)
{}

SkColorSpace_Base::SkColorSpace_Base(SkColorLookUpTable* colorLUT, sk_sp<SkGammas> gammas,
                                     const SkMatrix44& toXYZD50)
    : INHERITED(kNonStandard_GammaNamed, toXYZD50, kUnknown_Named)
    , fColorLUT(colorLUT)
    , fGammas(gammas)
{}

const float gSRGB_toXYZD50[] {
    0.4358f, 0.2224f, 0.0139f,    // * R
    0.3853f, 0.7170f, 0.0971f,    // * G
    0.1430f, 0.0606f, 0.7139f,    // * B
};

const float gAdobeRGB_toXYZD50[] {
    0.6098f, 0.3111f, 0.0195f,    // * R
    0.2052f, 0.6257f, 0.0609f,    // * G
    0.1492f, 0.0632f, 0.7448f,    // * B
};

/**
 *  Checks if our toXYZ matrix is a close match to a known color gamut.
 *
 *  @param toXYZD50 transformation matrix deduced from profile data
 *  @param standard 3x3 canonical transformation matrix
 */
static bool xyz_almost_equal(const SkMatrix44& toXYZD50, const float* standard) {
    return color_space_almost_equal(toXYZD50.getFloat(0, 0), standard[0]) &&
           color_space_almost_equal(toXYZD50.getFloat(0, 1), standard[1]) &&
           color_space_almost_equal(toXYZD50.getFloat(0, 2), standard[2]) &&
           color_space_almost_equal(toXYZD50.getFloat(1, 0), standard[3]) &&
           color_space_almost_equal(toXYZD50.getFloat(1, 1), standard[4]) &&
           color_space_almost_equal(toXYZD50.getFloat(1, 2), standard[5]) &&
           color_space_almost_equal(toXYZD50.getFloat(2, 0), standard[6]) &&
           color_space_almost_equal(toXYZD50.getFloat(2, 1), standard[7]) &&
           color_space_almost_equal(toXYZD50.getFloat(2, 2), standard[8]) &&
           color_space_almost_equal(toXYZD50.getFloat(0, 3), 0.0f) &&
           color_space_almost_equal(toXYZD50.getFloat(1, 3), 0.0f) &&
           color_space_almost_equal(toXYZD50.getFloat(2, 3), 0.0f) &&
           color_space_almost_equal(toXYZD50.getFloat(3, 0), 0.0f) &&
           color_space_almost_equal(toXYZD50.getFloat(3, 1), 0.0f) &&
           color_space_almost_equal(toXYZD50.getFloat(3, 2), 0.0f) &&
           color_space_almost_equal(toXYZD50.getFloat(3, 3), 1.0f);
}

static SkOnce g2Dot2CurveGammasOnce;
static SkGammas* g2Dot2CurveGammas;
static SkOnce gLinearGammasOnce;
static SkGammas* gLinearGammas;

sk_sp<SkColorSpace> SkColorSpace::NewRGB(float gammaVals[3], const SkMatrix44& toXYZD50) {
    sk_sp<SkGammas> gammas = nullptr;
    GammaNamed gammaNamed = kNonStandard_GammaNamed;

    // Check if we really have sRGB or Adobe RGB
    if (color_space_almost_equal(2.2f, gammaVals[0]) &&
        color_space_almost_equal(2.2f, gammaVals[1]) &&
        color_space_almost_equal(2.2f, gammaVals[2]))
    {
        g2Dot2CurveGammasOnce([] {
                g2Dot2CurveGammas = new SkGammas(2.2f, 2.2f, 2.2f);
        });
        gammas = sk_ref_sp(g2Dot2CurveGammas);
        gammaNamed = k2Dot2Curve_GammaNamed;

        if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
            return SkColorSpace::NewNamed(kSRGB_Named);
        } else if (xyz_almost_equal(toXYZD50, gAdobeRGB_toXYZD50)) {
            return SkColorSpace::NewNamed(kAdobeRGB_Named);
        }
    } else if (color_space_almost_equal(1.0f, gammaVals[0]) &&
               color_space_almost_equal(1.0f, gammaVals[1]) &&
               color_space_almost_equal(1.0f, gammaVals[2]))
    {
        gLinearGammasOnce([] {
            gLinearGammas = new SkGammas(1.0f, 1.0f, 1.0f);
        });
        gammas = sk_ref_sp(gLinearGammas);
        gammaNamed = kLinear_GammaNamed;
    }

    if (!gammas) {
        gammas = sk_sp<SkGammas>(new SkGammas(gammaVals[0], gammaVals[1], gammaVals[2]));
    }
    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammas, gammaNamed, toXYZD50, kUnknown_Named));
}

sk_sp<SkColorSpace> SkColorSpace::NewNamed(Named named) {
    static SkOnce sRGBOnce;
    static SkColorSpace* sRGB;
    static SkOnce adobeRGBOnce;
    static SkColorSpace* adobeRGB;

    switch (named) {
        case kSRGB_Named: {
            g2Dot2CurveGammasOnce([] {
                g2Dot2CurveGammas = new SkGammas(2.2f, 2.2f, 2.2f);
            });

            sRGBOnce([] {
                SkMatrix44 srgbToxyzD50(SkMatrix44::kUninitialized_Constructor);
                srgbToxyzD50.set3x3ColMajorf(gSRGB_toXYZD50);
                sRGB = new SkColorSpace_Base(sk_ref_sp(g2Dot2CurveGammas), k2Dot2Curve_GammaNamed,
                                             srgbToxyzD50, kSRGB_Named);
            });
            return sk_ref_sp(sRGB);
        }
        case kAdobeRGB_Named: {
            g2Dot2CurveGammasOnce([] {
                g2Dot2CurveGammas = new SkGammas(2.2f, 2.2f, 2.2f);
            });

            adobeRGBOnce([] {
                SkMatrix44 adobergbToxyzD50(SkMatrix44::kUninitialized_Constructor);
                adobergbToxyzD50.set3x3ColMajorf(gAdobeRGB_toXYZD50);
                adobeRGB = new SkColorSpace_Base(sk_ref_sp(g2Dot2CurveGammas),
                                                 k2Dot2Curve_GammaNamed, adobergbToxyzD50,
                                                 kAdobeRGB_Named);
            });
            return sk_ref_sp(adobeRGB);
        }
        default:
            break;
    }
    return nullptr;
}

///////////////////////////////////////////////////////////////////////////////////////////////////

#include "SkFixed.h"
#include "SkTemplates.h"

#define SkColorSpacePrintf(...)

#define return_if_false(pred, msg)                                   \
    do {                                                             \
        if (!(pred)) {                                               \
            SkColorSpacePrintf("Invalid ICC Profile: %s.\n", (msg)); \
            return false;                                            \
        }                                                            \
    } while (0)

#define return_null(msg)                                             \
    do {                                                             \
        SkColorSpacePrintf("Invalid ICC Profile: %s.\n", (msg));     \
        return nullptr;                                              \
    } while (0)

static uint16_t read_big_endian_short(const uint8_t* ptr) {
    return ptr[0] << 8 | ptr[1];
}

static uint32_t read_big_endian_uint(const uint8_t* ptr) {
    return ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3];
}

static int32_t read_big_endian_int(const uint8_t* ptr) {
    return (int32_t) read_big_endian_uint(ptr);
}

// This is equal to the header size according to the ICC specification (128)
// plus the size of the tag count (4).  We include the tag count since we
// always require it to be present anyway.
static const size_t kICCHeaderSize = 132;

// Contains a signature (4), offset (4), and size (4).
static const size_t kICCTagTableEntrySize = 12;

static const uint32_t kRGB_ColorSpace  = SkSetFourByteTag('R', 'G', 'B', ' ');

struct ICCProfileHeader {
    uint32_t fSize;

    // No reason to care about the preferred color management module (ex: Adobe, Apple, etc.).
    // We're always going to use this one.
    uint32_t fCMMType_ignored;

    uint32_t fVersion;
    uint32_t fProfileClass;
    uint32_t fInputColorSpace;
    uint32_t fPCS;
    uint32_t fDateTime_ignored[3];
    uint32_t fSignature;

    // Indicates the platform that this profile was created for (ex: Apple, Microsoft).  This
    // doesn't really matter to us.
    uint32_t fPlatformTarget_ignored;

    // Flags can indicate:
    // (1) Whether this profile was embedded in a file.  This flag is consistently wrong.
    //     Ex: The profile came from a file but indicates that it did not.
    // (2) Whether we are allowed to use the profile independently of the color data.  If set,
    //     this may allow us to use the embedded profile for testing separate from the original
    //     image.
    uint32_t fFlags_ignored;

    // We support many output devices.  It doesn't make sense to think about the attributes of
    // the device in the context of the image profile.
    uint32_t fDeviceManufacturer_ignored;
    uint32_t fDeviceModel_ignored;
    uint32_t fDeviceAttributes_ignored[2];

    uint32_t fRenderingIntent;
    int32_t  fIlluminantXYZ[3];

    // We don't care who created the profile.
    uint32_t fCreator_ignored;

    // This is an MD5 checksum.  Could be useful for checking if profiles are equal.
    uint32_t fProfileId_ignored[4];

    // Reserved for future use.
    uint32_t fReserved_ignored[7];

    uint32_t fTagCount;

    void init(const uint8_t* src, size_t len) {
        SkASSERT(kICCHeaderSize == sizeof(*this));

        uint32_t* dst = (uint32_t*) this;
        for (uint32_t i = 0; i < kICCHeaderSize / 4; i++, src+=4) {
            dst[i] = read_big_endian_uint(src);
        }
    }

    bool valid() const {
        return_if_false(fSize >= kICCHeaderSize, "Size is too small");

        uint8_t majorVersion = fVersion >> 24;
        return_if_false(majorVersion <= 4, "Unsupported version");

        // These are the three basic classes of profiles that we might expect to see embedded
        // in images.  Four additional classes exist, but they generally are used as a convenient
        // way for CMMs to store calculated transforms.
        const uint32_t kDisplay_Profile = SkSetFourByteTag('m', 'n', 't', 'r');
        const uint32_t kInput_Profile   = SkSetFourByteTag('s', 'c', 'n', 'r');
        const uint32_t kOutput_Profile  = SkSetFourByteTag('p', 'r', 't', 'r');
        return_if_false(fProfileClass == kDisplay_Profile ||
                        fProfileClass == kInput_Profile ||
                        fProfileClass == kOutput_Profile,
                        "Unsupported profile");

        // TODO (msarett):
        // All the profiles we've tested so far use RGB as the input color space.
        return_if_false(fInputColorSpace == kRGB_ColorSpace, "Unsupported color space");

        // TODO (msarett):
        // All the profiles we've tested so far use XYZ as the profile connection space.
        const uint32_t kXYZ_PCSSpace = SkSetFourByteTag('X', 'Y', 'Z', ' ');
        return_if_false(fPCS == kXYZ_PCSSpace, "Unsupported PCS space");

        return_if_false(fSignature == SkSetFourByteTag('a', 'c', 's', 'p'), "Bad signature");

        // TODO (msarett):
        // Should we treat different rendering intents differently?
        // Valid rendering intents include kPerceptual (0), kRelative (1),
        // kSaturation (2), and kAbsolute (3).
        return_if_false(fRenderingIntent <= 3, "Bad rendering intent");

        return_if_false(color_space_almost_equal(SkFixedToFloat(fIlluminantXYZ[0]), 0.96420f) &&
                        color_space_almost_equal(SkFixedToFloat(fIlluminantXYZ[1]), 1.00000f) &&
                        color_space_almost_equal(SkFixedToFloat(fIlluminantXYZ[2]), 0.82491f),
                        "Illuminant must be D50");

        return_if_false(fTagCount <= 100, "Too many tags");

        return true;
    }
};

struct ICCTag {
    uint32_t fSignature;
    uint32_t fOffset;
    uint32_t fLength;

    const uint8_t* init(const uint8_t* src) {
        fSignature = read_big_endian_uint(src);
        fOffset = read_big_endian_uint(src + 4);
        fLength = read_big_endian_uint(src + 8);
        return src + 12;
    }

    bool valid(size_t len) {
        return_if_false(fOffset + fLength <= len, "Tag too large for ICC profile");
        return true;
    }

    const uint8_t* addr(const uint8_t* src) const {
        return src + fOffset;
    }

    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;
    }
};

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');

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].fValue = 1.0f;
                    break;
                } else if (len < tagBytes) {
                    SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
                    return false;
                }

                const uint16_t* table = (const uint16_t*) (src + 12);
                if (1 == count) {
                    // The table entry is the gamma (with a bias of 256).
                    uint16_t value = read_big_endian_short((const uint8_t*) table);
                    gammas[i].fValue = value / 256.0f;
                    SkColorSpacePrintf("gamma %d %g\n", value, gammas[i].fValue);
                    break;
                }

                // Check for frequently occurring curves and use a fast approximation.
                // We do this by sampling a few values and see if they match our expectation.
                // A more robust solution would be to compare each value in this curve against
                // a 2.2f curve see if we remain below an error threshold.  At this time,
                // we haven't seen any images in the wild that make this kind of
                // calculation necessary.  We encounter identical gamma curves over and
                // over again, but relatively few variations.
                if (1024 == count) {
                    // The magic values were chosen because they match a very common sRGB
                    // gamma table and the less common Canon sRGB gamma table (which use
                    // different rounding rules).
                    if (0 == read_big_endian_short((const uint8_t*) &table[0]) &&
                            3366 == read_big_endian_short((const uint8_t*) &table[257]) &&
                            14116 == read_big_endian_short((const uint8_t*) &table[513]) &&
                            34318 == read_big_endian_short((const uint8_t*) &table[768]) &&
                            65535 == read_big_endian_short((const uint8_t*) &table[1023])) {
                        gammas[i].fValue = 2.2f;
                        break;
                    }
                } else if (26 == count) {
                    // The magic values were chosen because they match a very common sRGB
                    // gamma table.
                    if (0 == read_big_endian_short((const uint8_t*) &table[0]) &&
                            3062 == read_big_endian_short((const uint8_t*) &table[6]) &&
                            12824 == read_big_endian_short((const uint8_t*) &table[12]) &&
                            31237 == read_big_endian_short((const uint8_t*) &table[18]) &&
                            65535 == read_big_endian_short((const uint8_t*) &table[25])) {
                        gammas[i].fValue = 2.2f;
                        break;
                    }
                } else if (4096 == count) {
                    // The magic values were chosen because they match Nikon, Epson, and
                    // LCMS sRGB gamma tables (all of which use different rounding rules).
                    if (0 == read_big_endian_short((const uint8_t*) &table[0]) &&
                            950 == read_big_endian_short((const uint8_t*) &table[515]) &&
                            3342 == read_big_endian_short((const uint8_t*) &table[1025]) &&
                            14079 == read_big_endian_short((const uint8_t*) &table[2051]) &&
                            65535 == read_big_endian_short((const uint8_t*) &table[4095])) {
                        gammas[i].fValue = 2.2f;
                        break;
                    }
                }

                // Otherwise, fill in the interpolation table.
                gammas[i].fTableSize = count;
                gammas[i].fTable = std::unique_ptr<float[]>(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;
                }
                break;
            }
            case kTAG_ParaCurveType:
                // Determine the format of the parametric curve tag.
                switch(read_big_endian_short(src + 8)) {
                    case 0: {
                        tagBytes = 12 + 4;
                        if (len < tagBytes) {
                            SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
                            return false;
                        }

                        // Y = X^g
                        int32_t g = read_big_endian_int(src + 12);
                        gammas[i].fValue = SkFixedToFloat(g);
                        break;
                    }

                    // Here's where the real parametric gammas start.  There are many
                    // permutations of the same equations.
                    //
                    // Y = (aX + b)^g + c  for X >= d
                    // Y = eX + f          otherwise
                    //
                    // We will fill in with zeros as necessary to always match the above form.
                    // Note that there is no need to actually write zero, since the struct is
                    // zero initialized.
                    case 1: {
                        tagBytes = 12 + 12;
                        if (len < tagBytes) {
                            SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
                            return false;
                        }

                        // Y = (aX + b)^g  for X >= -b/a
                        // Y = 0           otherwise
                        gammas[i].fG = SkFixedToFloat(read_big_endian_int(src + 12));
                        gammas[i].fA = SkFixedToFloat(read_big_endian_int(src + 16));
                        gammas[i].fB = SkFixedToFloat(read_big_endian_int(src + 20));
                        gammas[i].fD = -gammas[i].fB / gammas[i].fA;
                        break;
                    }
                    case 2:
                        tagBytes = 12 + 16;
                        if (len < tagBytes) {
                            SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
                            return false;
                        }

                        // Y = (aX + b)^g + c  for X >= -b/a
                        // Y = c               otherwise
                        gammas[i].fG = SkFixedToFloat(read_big_endian_int(src + 12));
                        gammas[i].fA = SkFixedToFloat(read_big_endian_int(src + 16));
                        gammas[i].fB = SkFixedToFloat(read_big_endian_int(src + 20));
                        gammas[i].fC = SkFixedToFloat(read_big_endian_int(src + 24));
                        gammas[i].fD = -gammas[i].fB / gammas[i].fA;
                        gammas[i].fF = gammas[i].fC;
                        break;
                    case 3:
                        tagBytes = 12 + 20;
                        if (len < tagBytes) {
                            SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
                            return false;
                        }

                        // Y = (aX + b)^g  for X >= d
                        // Y = cX          otherwise
                        gammas[i].fG = SkFixedToFloat(read_big_endian_int(src + 12));
                        gammas[i].fA = SkFixedToFloat(read_big_endian_int(src + 16));
                        gammas[i].fB = SkFixedToFloat(read_big_endian_int(src + 20));
                        gammas[i].fD = SkFixedToFloat(read_big_endian_int(src + 28));
                        gammas[i].fE = SkFixedToFloat(read_big_endian_int(src + 24));
                        break;
                    case 4:
                        tagBytes = 12 + 28;
                        if (len < tagBytes) {
                            SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
                            return false;
                        }

                        // Y = (aX + b)^g + c  for X >= d
                        // Y = eX + f          otherwise
                        // NOTE: The ICC spec writes "cX" instead of "eX" but I think it's a typo.
                        gammas[i].fG = SkFixedToFloat(read_big_endian_int(src + 12));
                        gammas[i].fA = SkFixedToFloat(read_big_endian_int(src + 16));
                        gammas[i].fB = SkFixedToFloat(read_big_endian_int(src + 20));
                        gammas[i].fC = SkFixedToFloat(read_big_endian_int(src + 24));
                        gammas[i].fD = SkFixedToFloat(read_big_endian_int(src + 28));
                        gammas[i].fE = SkFixedToFloat(read_big_endian_int(src + 32));
                        gammas[i].fF = SkFixedToFloat(read_big_endian_int(src + 36));
                        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 (i != numGammas - 1) {
            // Each curve is padded to 4-byte alignment.
            tagBytes = SkAlign4(tagBytes);
            if (len < tagBytes) {
                return false;
            }

            src += tagBytes;
            len -= tagBytes;
        }
    }

    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 && 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
    // of the table values.
    uint8_t precision = src[16];
    switch (precision) {
        case 1: // 8-bit data
        case 2: // 16-bit data
            break;
        default:
            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(SkMatrix44* toXYZ, const uint8_t* src, size_t len) {
    if (len < 48) {
        SkColorSpacePrintf("Matrix tag is too small (%d bytes).", len);
        return false;
    }

    float array[16];
    array[ 0] = SkFixedToFloat(read_big_endian_int(src));
    array[ 1] = SkFixedToFloat(read_big_endian_int(src + 4));
    array[ 2] = SkFixedToFloat(read_big_endian_int(src + 8));
    array[ 3] = SkFixedToFloat(read_big_endian_int(src + 36)); // translate R
    array[ 4] = SkFixedToFloat(read_big_endian_int(src + 12));
    array[ 5] = SkFixedToFloat(read_big_endian_int(src + 16));
    array[ 6] = SkFixedToFloat(read_big_endian_int(src + 20));
    array[ 7] = SkFixedToFloat(read_big_endian_int(src + 40)); // translate G
    array[ 8] = SkFixedToFloat(read_big_endian_int(src + 24));
    array[ 9] = SkFixedToFloat(read_big_endian_int(src + 28));
    array[10] = SkFixedToFloat(read_big_endian_int(src + 32));
    array[11] = SkFixedToFloat(read_big_endian_int(src + 44)); // translate B
    array[12] = 0.0f;
    array[13] = 0.0f;
    array[14] = 0.0f;
    array[15] = 1.0f;
    toXYZ->setColMajorf(array);
    return true;
}

bool load_a2b0(SkColorLookUpTable* colorLUT, SkGammaCurve* gammas, SkMatrix44* toXYZ,
               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 ||
            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.
    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(gammas, 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, 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.
    ICCProfileHeader header;
    header.init(ptr, len);
    if (!header.valid()) {
        return nullptr;
    }

    // Adjust ptr and len before reading the tags.
    if (len < header.fSize) {
        SkColorSpacePrintf("ICC profile might be truncated.\n");
    } else if (len > header.fSize) {
        SkColorSpacePrintf("Caller provided extra data beyond the end of the ICC profile.\n");
        len = header.fSize;
    }
    ptr += kICCHeaderSize;
    len -= kICCHeaderSize;

    // Parse tag headers.
    uint32_t tagCount = header.fTagCount;
    SkColorSpacePrintf("ICC profile contains %d tags.\n", tagCount);
    if (len < kICCTagTableEntrySize * tagCount) {
        return_null("Not enough input data to read tag table entries");
    }

    SkAutoTArray<ICCTag> tags(tagCount);
    for (uint32_t i = 0; i < tagCount; i++) {
        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");
        }
    }

    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) {
                float toXYZ[9];
                if (!load_xyz(&toXYZ[0], r->addr((const uint8_t*) base), r->fLength) ||
                    !load_xyz(&toXYZ[3], g->addr((const uint8_t*) base), g->fLength) ||
                    !load_xyz(&toXYZ[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.
                SkGammaCurve curves[3];
                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(&curves[0], 1, r->addr((const uint8_t*) base), r->fLength))
                {
                    SkColorSpacePrintf("Failed to read R gamma tag.\n");
                }
                if (!g || !load_gammas(&curves[1], 1, g->addr((const uint8_t*) base), g->fLength))
                {
                    SkColorSpacePrintf("Failed to read G gamma tag.\n");
                }
                if (!b || !load_gammas(&curves[2], 1, b->addr((const uint8_t*) base), b->fLength))
                {
                    SkColorSpacePrintf("Failed to read B gamma tag.\n");
                }

                sk_sp<SkGammas> gammas(new SkGammas(std::move(curves[0]), std::move(curves[1]),
                                                    std::move(curves[2])));
                SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
                mat.set3x3ColMajorf(toXYZ);
                if (gammas->isValues()) {
                    // When we have values, take advantage of the NewFromRGB initializer.
                    // This allows us to check for canonical sRGB and Adobe RGB.
                    float gammaVals[3];
                    gammaVals[0] = gammas->fRed.fValue;
                    gammaVals[1] = gammas->fGreen.fValue;
                    gammaVals[2] = gammas->fBlue.fValue;
                    return SkColorSpace::NewRGB(gammaVals, mat);
                } else {
                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammas, mat, kUnknown_Named));
                }
            }

            // Recognize color profile specified by A2B0 tag.
            const ICCTag* a2b0 = ICCTag::Find(tags.get(), tagCount, kTAG_A2B0);
            if (a2b0) {
                SkAutoTDelete<SkColorLookUpTable> colorLUT(new SkColorLookUpTable());
                SkGammaCurve curves[3];
                SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
                if (!load_a2b0(colorLUT, curves, &toXYZ, a2b0->addr((const uint8_t*) base),
                               a2b0->fLength)) {
                    return_null("Failed to parse A2B0 tag");
                }

                sk_sp<SkGammas> gammas(new SkGammas(std::move(curves[0]), std::move(curves[1]),
                                                    std::move(curves[2])));
                if (colorLUT->fTable) {
                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(colorLUT.release(), gammas,
                                                                     toXYZ));
                } else if (gammas->isValues()) {
                    // When we have values, take advantage of the NewFromRGB initializer.
                    // This allows us to check for canonical sRGB and Adobe RGB.
                    float gammaVals[3];
                    gammaVals[0] = gammas->fRed.fValue;
                    gammaVals[1] = gammas->fGreen.fValue;
                    gammaVals[2] = gammas->fBlue.fValue;
                    return SkColorSpace::NewRGB(gammaVals, toXYZ);
                } else {
                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammas, toXYZ,
                                                                     kUnknown_Named));
                }
            }

        }
        default:
            break;
    }

    return_null("ICC profile contains unsupported colorspace");
}