Miscellaneous color space refactors

src/core/SkColorSpace_ICC.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 "SkColorSpacePriv.h"
 #include "SkEndian.h"
 #include "SkFixed.h"
 #include "SkTemplates.h"
 
 #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) {
+static uint16_t read_big_endian_u16(const uint8_t* ptr) {
     return ptr[0] << 8 | ptr[1];
 }
 
-static uint32_t read_big_endian_uint(const uint8_t* ptr) {
+static uint32_t read_big_endian_u32(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);
+static int32_t read_big_endian_i32(const uint8_t* ptr) {
+    return (int32_t) read_big_endian_u32(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 constexpr size_t kICCHeaderSize = 132;
 
 // Contains a signature (4), offset (4), and size (4).
 static constexpr size_t kICCTagTableEntrySize = 12;
 
@@ skipping 49 matching lines @@
     // 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);
+            dst[i] = read_big_endian_u32(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 four basic classes of profiles that we might expect to see embedded
@@ skipping 60 matching lines @@
     *result = product32;
     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);
+        fSignature = read_big_endian_u32(src);
+        fOffset = read_big_endian_u32(src + 4);
+        fLength = read_big_endian_u32(src + 8);
         return src + 12;
     }
 
     bool valid(size_t len) {
         size_t tagEnd;
         return_if_false(safe_add(fOffset, fLength, &tagEnd),
                         "Tag too large, overflows integer addition");
         return_if_false(tagEnd <= len, "Tag too large for ICC profile");
         return true;
     }
@@ skipping 19 matching lines @@
 static constexpr uint32_t kTAG_gTRC = SkSetFourByteTag('g', 'T', 'R', 'C');
 static constexpr uint32_t kTAG_bTRC = SkSetFourByteTag('b', 'T', 'R', 'C');
 static constexpr uint32_t kTAG_A2B0 = SkSetFourByteTag('A', '2', 'B', '0');
 
 static 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));
+    dst[0] = SkFixedToFloat(read_big_endian_i32(src + 8));
+    dst[1] = SkFixedToFloat(read_big_endian_i32(src + 12));
+    dst[2] = SkFixedToFloat(read_big_endian_i32(src + 16));
     SkColorSpacePrintf("XYZ %g %g %g\n", dst[0], dst[1], dst[2]);
     return true;
 }
 
 static constexpr uint32_t kTAG_CurveType     = SkSetFourByteTag('c', 'u', 'r', 'v');
 static constexpr uint32_t kTAG_ParaCurveType = SkSetFourByteTag('p', 'a', 'r', 'a');
 
 static SkGammas::Type set_gamma_value(SkGammas::Data* data, float value) {
     if (color_space_almost_equal(2.2f, value)) {
         data->fNamed = SkColorSpace::k2Dot2Curve_GammaNamed;
         return SkGammas::Type::kNamed_Type;
     }
 
     if (color_space_almost_equal(1.0f, value)) {
         data->fNamed = SkColorSpace::kLinear_GammaNamed;
         return SkGammas::Type::kNamed_Type;
     }
 
     if (color_space_almost_equal(0.0f, value)) {
         return SkGammas::Type::kNone_Type;
     }
 
     data->fValue = value;
     return SkGammas::Type::kValue_Type;
 }
 
 static float read_big_endian_16_dot_16(const uint8_t buf[4]) {
     // It just so happens that SkFixed is also 16.16!
-    return SkFixedToFloat(read_big_endian_int(buf));
+    return SkFixedToFloat(read_big_endian_i32(buf));
 }
 
 /**
  *  @param outData     Set to the appropriate value on success.  If we have table or
  *                     parametric gamma, it is the responsibility of the caller to set
  *                     fOffset.
  *  @param outParams   If this is a parametric gamma, this is set to the appropriate
  *                     parameters on success.
  *  @param outTagBytes Will be set to the length of the tag on success.
  *  @src               Pointer to tag data.
  *  @len               Length of tag data in bytes.
  *
  *  @return            kNone_Type on failure, otherwise the type of the gamma tag.
  */
 static SkGammas::Type parse_gamma(SkGammas::Data* outData, SkGammas::Params* outParams,
                                       size_t* outTagBytes, const uint8_t* src, size_t len) {
     if (len < 12) {
         SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
         return SkGammas::Type::kNone_Type;
     }
 
     // In the case of consecutive gamma tags, we need to count the number of bytes in the
     // tag, so that we can move on to the next tag.
     size_t tagBytes;
 
-    uint32_t type = read_big_endian_uint(src);
+    uint32_t type = read_big_endian_u32(src);
     // Bytes 4-7 are reserved and should be set to zero.
     switch (type) {
         case kTAG_CurveType: {
-            uint32_t count = read_big_endian_uint(src + 8);
+            uint32_t count = read_big_endian_u32(src + 8);
 
             // tagBytes = 12 + 2 * count
             // We need to do safe addition here to avoid integer overflow.
             if (!safe_add(count, count, &tagBytes) ||
                 !safe_add((size_t) 12, tagBytes, &tagBytes))
             {
                 SkColorSpacePrintf("Invalid gamma count");
                 return SkGammas::Type::kNone_Type;
             }
 
             if (len < tagBytes) {
                 SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
                 return SkGammas::Type::kNone_Type;
             }
             *outTagBytes = tagBytes;
 
             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.
                 outData->fNamed = SkColorSpace::kLinear_GammaNamed;
                 return SkGammas::Type::kNamed_Type;
             }
 
             const uint16_t* table = (const uint16_t*) (src + 12);
             if (1 == count) {
                 // The table entry is the gamma (with a bias of 256).
-                float value = (read_big_endian_short((const uint8_t*) table)) / 256.0f;
+                float value = (read_big_endian_u16((const uint8_t*) table)) / 256.0f;
                 SkColorSpacePrintf("gamma %g\n", value);
 
                 return set_gamma_value(outData, value);
             }
 
             // Check for frequently occurring sRGB curves.
             // 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
             // an sRGB curve to 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 both the very common
                 // HP 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])) {
+                if (0 == read_big_endian_u16((const uint8_t*) &table[0]) &&
+                        3366 == read_big_endian_u16((const uint8_t*) &table[257]) &&
+                        14116 == read_big_endian_u16((const uint8_t*) &table[513]) &&
+                        34318 == read_big_endian_u16((const uint8_t*) &table[768]) &&
+                        65535 == read_big_endian_u16((const uint8_t*) &table[1023])) {
                     outData->fNamed = SkColorSpace::kSRGB_GammaNamed;
                     return SkGammas::Type::kNamed_Type;
                 }
             }
 
             if (26 == count) {
                 // The magic values were chosen because they match a very common LCMS 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])) {
+                if (0 == read_big_endian_u16((const uint8_t*) &table[0]) &&
+                        3062 == read_big_endian_u16((const uint8_t*) &table[6]) &&
+                        12824 == read_big_endian_u16((const uint8_t*) &table[12]) &&
+                        31237 == read_big_endian_u16((const uint8_t*) &table[18]) &&
+                        65535 == read_big_endian_u16((const uint8_t*) &table[25])) {
                     outData->fNamed = SkColorSpace::kSRGB_GammaNamed;
                     return SkGammas::Type::kNamed_Type;
                 }
             }
 
             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])) {
+                if (0 == read_big_endian_u16((const uint8_t*) &table[0]) &&
+                        950 == read_big_endian_u16((const uint8_t*) &table[515]) &&
+                        3342 == read_big_endian_u16((const uint8_t*) &table[1025]) &&
+                        14079 == read_big_endian_u16((const uint8_t*) &table[2051]) &&
+                        65535 == read_big_endian_u16((const uint8_t*) &table[4095])) {
                     outData->fNamed = SkColorSpace::kSRGB_GammaNamed;
                     return SkGammas::Type::kNamed_Type;
                 }
             }
 
             // Otherwise, we will represent gamma with a table.
             outData->fTable.fSize = count;
             return SkGammas::Type::kTable_Type;
         }
         case kTAG_ParaCurveType: {
             enum ParaCurveType {
                 kExponential_ParaCurveType = 0,
                 kGAB_ParaCurveType         = 1,
                 kGABC_ParaCurveType        = 2,
                 kGABDE_ParaCurveType       = 3,
                 kGABCDEF_ParaCurveType     = 4,
             };
 
             // Determine the format of the parametric curve tag.
-            uint16_t format = read_big_endian_short(src + 8);
+            uint16_t format = read_big_endian_u16(src + 8);
             if (format > kGABCDEF_ParaCurveType) {
                 SkColorSpacePrintf("Unsupported gamma tag type %d\n", type);
                 return SkGammas::Type::kNone_Type;
             }
 
             if (kExponential_ParaCurveType == format) {
                 tagBytes = 12 + 4;
                 if (len < tagBytes) {
                     SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
                     return SkGammas::Type::kNone_Type;
@@ skipping 192 matching lines @@
         case SkGammas::Type::kNamed_Type:
         case SkGammas::Type::kValue_Type:
             // Nothing to do here.
             return 0;
         case SkGammas::Type::kTable_Type: {
             data->fTable.fOffset = offset;
 
             float* outTable = (float*) storage;
             const uint16_t* inTable = (const uint16_t*) (src + 12);
             for (int i = 0; i < data->fTable.fSize; i++) {
-                outTable[i] = (read_big_endian_short((const uint8_t*) &inTable[i])) / 65535.0f;
+                outTable[i] = (read_big_endian_u16((const uint8_t*) &inTable[i])) / 65535.0f;
             }
 
             return sizeof(float) * data->fTable.fSize;
         }
         case SkGammas::Type::kParam_Type:
             data->fTable.fOffset = offset;
             memcpy(storage, &params, sizeof(SkGammas::Params));
             return sizeof(SkGammas::Params);
         default:
             SkASSERT(false);
             return 0;
     }
 }
 
 static constexpr uint32_t kTAG_AtoBType = SkSetFourByteTag('m', 'A', 'B', ' ');
 
-static bool load_color_lut(SkColorLookUpTable* colorLUT, uint32_t inputChannels,
-                           uint32_t outputChannels, const uint8_t* src, size_t len) {
+static bool load_color_lut(sk_sp<SkColorLookUpTable>* colorLUT, uint32_t inputChannels,
+                           const uint8_t* src, size_t len) {
     // 16 bytes reserved for grid points, 2 for precision, 2 for padding.
     // The color LUT data follows after this header.
     static constexpr uint32_t kColorLUTHeaderSize = 20;
     if (len < kColorLUTHeaderSize) {
         SkColorSpacePrintf("Color LUT tag is too small (%d bytes).", len);
         return false;
     }
     size_t dataLen = len - kColorLUTHeaderSize;
 
-    SkASSERT(3 == inputChannels && 3 == outputChannels);
-    colorLUT->fInputChannels = inputChannels;
-    colorLUT->fOutputChannels = outputChannels;
+    SkASSERT(3 == inputChannels);
+    uint8_t gridPoints[3];
     uint32_t numEntries = 1;
     for (uint32_t i = 0; i < inputChannels; i++) {
-        colorLUT->fGridPoints[i] = src[i];
+        gridPoints[i] = src[i];
         if (0 == src[i]) {
             SkColorSpacePrintf("Each input channel must have at least one grid point.");
             return false;
         }
 
         if (!safe_mul(numEntries, src[i], &numEntries)) {
             SkColorSpacePrintf("Too many entries in Color LUT.");
             return false;
         }
     }
 
-    if (!safe_mul(numEntries, outputChannels, &numEntries)) {
+    if (!safe_mul(numEntries, SkColorLookUpTable::kOutputChannels, &numEntries)) {
         SkColorSpacePrintf("Too many entries in Color LUT.");
         return false;
     }
 
     // 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");
             return false;
     }
 
     uint32_t clutBytes;
     if (!safe_mul(numEntries, precision, &clutBytes)) {
         SkColorSpacePrintf("Too many entries in Color LUT.");
         return false;
     }
 
     if (dataLen < clutBytes) {
         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]);
+    void* memory = sk_malloc_throw(sizeof(SkColorLookUpTable) + sizeof(float) * numEntries);
+    *colorLUT = sk_sp<SkColorLookUpTable>(new (memory) SkColorLookUpTable(inputChannels,
+                                                                          gridPoints));
+
+    float* table = SkTAddOffset<float>(memory, sizeof(SkColorLookUpTable));
     const uint8_t* ptr = src + kColorLUTHeaderSize;
     for (uint32_t i = 0; i < numEntries; i++, ptr += precision) {
         if (1 == precision) {
-            colorLUT->fTable[i] = ((float) ptr[i]) / 255.0f;
+            table[i] = ((float) ptr[i]) / 255.0f;
         } else {
-            colorLUT->fTable[i] = ((float) read_big_endian_short(ptr)) / 65535.0f;
+            table[i] = ((float) read_big_endian_u16(ptr)) / 65535.0f;
         }
     }
 
     return true;
 }
 
 static 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;
     }
 
     // For this matrix to behave like our "to XYZ D50" matrices, it needs to be scaled.
     constexpr float scale = 65535.0 / 32768.0;
     float array[16];
-    array[ 0] = scale * SkFixedToFloat(read_big_endian_int(src));
-    array[ 1] = scale * SkFixedToFloat(read_big_endian_int(src + 4));
-    array[ 2] = scale * SkFixedToFloat(read_big_endian_int(src + 8));
-    array[ 3] = scale * SkFixedToFloat(read_big_endian_int(src + 36)); // translate R
-    array[ 4] = scale * SkFixedToFloat(read_big_endian_int(src + 12));
-    array[ 5] = scale * SkFixedToFloat(read_big_endian_int(src + 16));
-    array[ 6] = scale * SkFixedToFloat(read_big_endian_int(src + 20));
-    array[ 7] = scale * SkFixedToFloat(read_big_endian_int(src + 40)); // translate G
-    array[ 8] = scale * SkFixedToFloat(read_big_endian_int(src + 24));
-    array[ 9] = scale * SkFixedToFloat(read_big_endian_int(src + 28));
-    array[10] = scale * SkFixedToFloat(read_big_endian_int(src + 32));
-    array[11] = scale * SkFixedToFloat(read_big_endian_int(src + 44)); // translate B
+    array[ 0] = scale * SkFixedToFloat(read_big_endian_i32(src));
+    array[ 1] = scale * SkFixedToFloat(read_big_endian_i32(src + 4));
+    array[ 2] = scale * SkFixedToFloat(read_big_endian_i32(src + 8));
+    array[ 3] = scale * SkFixedToFloat(read_big_endian_i32(src + 36)); // translate R
+    array[ 4] = scale * SkFixedToFloat(read_big_endian_i32(src + 12));
+    array[ 5] = scale * SkFixedToFloat(read_big_endian_i32(src + 16));
+    array[ 6] = scale * SkFixedToFloat(read_big_endian_i32(src + 20));
+    array[ 7] = scale * SkFixedToFloat(read_big_endian_i32(src + 40)); // translate G
+    array[ 8] = scale * SkFixedToFloat(read_big_endian_i32(src + 24));
+    array[ 9] = scale * SkFixedToFloat(read_big_endian_i32(src + 28));
+    array[10] = scale * SkFixedToFloat(read_big_endian_i32(src + 32));
+    array[11] = scale * SkFixedToFloat(read_big_endian_i32(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;
 }
 
-static bool load_a2b0(SkColorLookUpTable* colorLUT, SkColorSpace::GammaNamed* gammaNamed,
+static bool load_a2b0(sk_sp<SkColorLookUpTable>* colorLUT, SkColorSpace::GammaNamed* gammaNamed,
                       sk_sp<SkGammas>* 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);
+    uint32_t type = read_big_endian_u32(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 (3 != inputChannels || 3 != outputChannels) {
+    if (3 != inputChannels || SkColorLookUpTable::kOutputChannels != outputChannels) {
         // We only handle (supposedly) RGB inputs and RGB outputs.  The numbers of input
         // channels and output channels both must be 3.
+        // TODO (msarett):
+        // Support different numbers of input channels.  Ex: CMYK (4).
         SkColorSpacePrintf("Input and output channels must equal 3 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);
+    uint32_t offsetToACurves = read_big_endian_i32(src + 28);
+    uint32_t offsetToBCurves = read_big_endian_i32(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);
+    uint32_t offsetToColorLUT = read_big_endian_i32(src + 24);
     if (0 != offsetToColorLUT && offsetToColorLUT < len) {
-        if (!load_color_lut(colorLUT, inputChannels, outputChannels, src + offsetToColorLUT,
+        if (!load_color_lut(colorLUT, inputChannels, 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);
+    uint32_t offsetToMCurves = read_big_endian_i32(src + 20);
     if (0 != offsetToMCurves && offsetToMCurves < len) {
         const uint8_t* rTagPtr = src + offsetToMCurves;
         size_t tagLen = len - offsetToMCurves;
 
         SkGammas::Data rData;
         SkGammas::Params rParams;
 
         // On an invalid first gamma, tagBytes remains set as zero.  This causes the two
         // subsequent to be treated as identical (which is what we want).
         size_t tagBytes = 0;
@@ skipping 55 matching lines @@
 
             (*gammas)->fBlueType = bType;
             load_gammas(memory, offset, bType, &bData, bParams, bTagPtr);
 
             (*gammas)->fRedData = rData;
             (*gammas)->fGreenData = gData;
             (*gammas)->fBlueData = bData;
         }
     }
 
-    uint32_t offsetToMatrix = read_big_endian_int(src + 16);
+    uint32_t offsetToMatrix = read_big_endian_i32(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");
             toXYZ->setIdentity();
         }
     }
 
     return true;
 }
 
@@ skipping 178 matching lines @@
                 } else {
                     return SkColorSpace_Base::NewRGB(gammaNamed, mat);
                 }
             }
 
             // Recognize color profile specified by A2B0 tag.
             const ICCTag* a2b0 = ICCTag::Find(tags.get(), tagCount, kTAG_A2B0);
             if (a2b0) {
                 GammaNamed gammaNamed = kNonStandard_GammaNamed;
                 sk_sp<SkGammas> gammas = nullptr;
-                sk_sp<SkColorLookUpTable> colorLUT = sk_make_sp<SkColorLookUpTable>();
+                sk_sp<SkColorLookUpTable> colorLUT = nullptr;
                 SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
-                if (!load_a2b0(colorLUT.get(), &gammaNamed, &gammas, &toXYZ, a2b0->addr(base),
+                if (!load_a2b0(&colorLUT, &gammaNamed, &gammas, &toXYZ, a2b0->addr(base),
                                a2b0->fLength)) {
                     return_null("Failed to parse A2B0 tag");
                 }
 
-                colorLUT = colorLUT->fTable ? colorLUT : nullptr;
                 if (colorLUT || kNonStandard_GammaNamed == gammaNamed) {
                     return sk_sp<SkColorSpace>(new SkColorSpace_Base(std::move(colorLUT),
                                                                      gammaNamed, std::move(gammas),
                                                                      toXYZ, std::move(data)));
                 } else {
                     return SkColorSpace_Base::NewRGB(gammaNamed, toXYZ);
                 }
             }
         }
         default:
@@ skipping 223 matching lines @@
     ptr32[4] = SkEndian_SwapBE32(0x000116cc);
     ptr += kTAG_XYZ_Bytes;
 
     // Write copyright tag
     memcpy(ptr, gEmptyTextTag, sizeof(gEmptyTextTag));
 
     // TODO (msarett): Should we try to hold onto the data so we can return immediately if
     //                 the client calls again?
     return SkData::MakeFromMalloc(profile.release(), kICCProfileSize);
 }