Add support for 3D colorLUTs to SkColorXform

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 "SkEndian.h"
@@ skipping 14 matching lines @@
     , fToXYZD50(toXYZD50)
     , fNamed(named)
 {}
 
 SkColorSpace_Base::SkColorSpace_Base(GammaNamed gammaNamed, const SkMatrix44& toXYZD50, Named named)
     : INHERITED(gammaNamed, toXYZD50, named)
     , fGammas(nullptr)
     , fProfileData(nullptr)
 {}
 
-SkColorSpace_Base::SkColorSpace_Base(SkColorLookUpTable* colorLUT, sk_sp<SkGammas> gammas,
+SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkColorLookUpTable> colorLUT, sk_sp<SkGammas> gammas,
                                      const SkMatrix44& toXYZD50, sk_sp<SkData> profileData)
     : INHERITED(kNonStandard_GammaNamed, toXYZD50, kUnknown_Named)
-    , fColorLUT(colorLUT)
+    , fColorLUT(std::move(colorLUT))
     , fGammas(std::move(gammas))
     , fProfileData(std::move(profileData))
 {}
 
 static constexpr float gSRGB_toXYZD50[] {
     0.4358f, 0.2224f, 0.0139f,    // * R
     0.3853f, 0.7170f, 0.0971f,    // * G
     0.1430f, 0.0606f, 0.7139f,    // * B
 };
 
@@ skipping 621 matching lines @@
                     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(inputChannels <= SkColorLookUpTable::kMaxChannels && 3 == outputChannels);
+    SkASSERT(3 == inputChannels && 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];
         if (0 == src[i]) {
             SkColorSpacePrintf("Each input channel must have at least one grid point.");
             return false;
         }
 
@@ skipping 85 matching lines @@
     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");
+    if (3 != inputChannels || 3 != outputChannels) {
+        // We only handle (supposedly) RGB inputs and RGB outputs.  The numbers of input
+        // channels and output channels both must be 3.
+        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);
     if ((0 != offsetToACurves) || (0 != offsetToBCurves)) {
@@ skipping 128 matching lines @@
                     return sk_sp<SkColorSpace>(new SkColorSpace_Base(nullptr, std::move(gammas),
                                                                      mat, std::move(data)));
                 } 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) {
-                SkAutoTDelete<SkColorLookUpTable> colorLUT(new SkColorLookUpTable());
+                sk_sp<SkColorLookUpTable> colorLUT = sk_make_sp<SkColorLookUpTable>();
                 SkGammaCurve curves[3];
                 SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
-                if (!load_a2b0(colorLUT, curves, &toXYZ, a2b0->addr((const uint8_t*) base),
+                if (!load_a2b0(colorLUT.get(), curves, &toXYZ, a2b0->addr((const uint8_t*) base),
                                a2b0->fLength)) {
                     return_null("Failed to parse A2B0 tag");
                 }
 
                 GammaNamed gammaNamed = SkGammas::Named(curves);
-                if (colorLUT->fTable || kNonStandard_GammaNamed == gammaNamed) {
+                colorLUT = colorLUT->fTable ? colorLUT : nullptr;
+                if (colorLUT || kNonStandard_GammaNamed == gammaNamed) {
                     sk_sp<SkGammas> gammas = sk_make_sp<SkGammas>(std::move(curves[0]),
                                                                   std::move(curves[1]),
                                                                   std::move(curves[2]));
 
-                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(colorLUT.release(),
+                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(std::move(colorLUT),
                                                                      std::move(gammas), toXYZ,
                                                                      std::move(data)));
                 } else {
                     return SkColorSpace_Base::NewRGB(gammaNamed, toXYZ);
                 }
             }
         }
         default:
             break;
     }
@@ skipping 386 matching lines @@
 
     uint32_t profileSize = *((uint32_t*) data);
     data = SkTAddOffset<const void>(data, sizeof(uint32_t));
     length -= sizeof(uint32_t);
     if (length < profileSize) {
         return nullptr;
     }
 
     return NewICC(data, profileSize);
 }