Refactored SkColorSpace and added in a Lab PCS GM

The refactoring breaks off A2B0 tag support into a separate
subclass of SkColorSpace_Base, while keeping the current
(besides CLUT) functionality in a XYZTRC subclass.

ICC profile loading is now aware of this and creates the A2B0
subclass when SkColorSpace::NewICC() is called on a profile
in need of the A2B0 functionality.

The LabPCSDemo GM loads a .icc profile containing a LAB PCS and
then runs a Lab->XYZ conversion on an image using it so we can
display it and test out the A2B0 SkColorSpace functionality,
sans a/b/m-curves, as well as the Lab->XYZ conversion code.

BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2389983002

Review-Url: https://codereview.chromium.org/2389983002

2 files changed, 282 insertions, 5 deletions

diff --git a/gm/gamut.cpp b/gm/gamut.cpp
index 707da29f64..3c64915561 100644
--- a/gm/gamut.cpp
+++ b/gm/gamut.cpp
@@ -127,20 +127,25 @@ static void draw_gamut_grid(SkCanvas* canvas, SkTArray<SkAutoTDelete<CellRendere
 
     // Use the original canvas' color type, but account for gamma requirements
     SkImageInfo origInfo = canvas->imageInfo();
-    auto srgbCS = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
-    auto wideCS = SkColorSpace::NewRGB(SkColorSpace::kSRGB_RenderTargetGamma,
-                                       wideGamutRGB_toXYZD50);
+    sk_sp<SkColorSpace> srgbCS;
+    sk_sp<SkColorSpace> wideCS;
     switch (origInfo.colorType()) {
         case kRGBA_8888_SkColorType:
         case kBGRA_8888_SkColorType:
+            srgbCS = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
+            wideCS = SkColorSpace::NewRGB(SkColorSpace::kSRGB_RenderTargetGamma,
+                                          wideGamutRGB_toXYZD50);
             break;
         case kRGBA_F16_SkColorType:
-            srgbCS = as_CSB(srgbCS.get())->makeLinearGamma();
-            wideCS = as_CSB(wideCS.get())->makeLinearGamma();
+            srgbCS = SkColorSpace::NewNamed(SkColorSpace::kSRGBLinear_Named);
+            wideCS = SkColorSpace::NewRGB(SkColorSpace::kLinear_RenderTargetGamma,
+                                          wideGamutRGB_toXYZD50);
             break;
         default:
             return;
     }
+    SkASSERT(srgbCS);
+    SkASSERT(wideCS);
 
     // Make our two working surfaces (one sRGB, one Adobe)
     SkImageInfo srgbGamutInfo = SkImageInfo::Make(gRectSize, gRectSize, origInfo.colorType(),
diff --git a/gm/labpcsdemo.cpp b/gm/labpcsdemo.cpp
new file mode 100644
index 0000000000..4bd9ed8140
--- /dev/null
+++ b/gm/labpcsdemo.cpp
@@ -0,0 +1,272 @@
+/*
+ * 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 <cmath>
+#include "gm.h"
+#include "Resources.h"
+#include "SkCodec.h"
+#include "SkColorSpace_Base.h"
+#include "SkColorSpace_A2B.h"
+#include "SkColorSpacePriv.h"
+#include "SkData.h"
+#include "SkFloatingPoint.h"
+#include "SkImageInfo.h"
+#include "SkScalar.h"
+#include "SkSRGB.h"
+#include "SkStream.h"
+#include "SkSurface.h"
+#include "SkTypes.h"
+
+static inline void interp_3d_clut(float dst[3], float src[3], const SkColorLookUpTable* colorLUT) {
+    // Call the src components x, y, and z.
+    uint8_t maxX = colorLUT->fGridPoints[0] - 1;
+    uint8_t maxY = colorLUT->fGridPoints[1] - 1;
+    uint8_t maxZ = colorLUT->fGridPoints[2] - 1;
+
+    // An approximate index into each of the three dimensions of the table.
+    float x = src[0] * maxX;
+    float y = src[1] * maxY;
+    float z = src[2] * maxZ;
+
+    // This gives us the low index for our interpolation.
+    int ix = sk_float_floor2int(x);
+    int iy = sk_float_floor2int(y);
+    int iz = sk_float_floor2int(z);
+
+    // Make sure the low index is not also the max index.
+    ix = (maxX == ix) ? ix - 1 : ix;
+    iy = (maxY == iy) ? iy - 1 : iy;
+    iz = (maxZ == iz) ? iz - 1 : iz;
+
+    // Weighting factors for the interpolation.
+    float diffX = x - ix;
+    float diffY = y - iy;
+    float diffZ = z - iz;
+
+    // Constants to help us navigate the 3D table.
+    // Ex: Assume x = a, y = b, z = c.
+    //     table[a * n001 + b * n010 + c * n100] logically equals table[a][b][c].
+    const int n000 = 0;
+    const int n001 = 3 * colorLUT->fGridPoints[1] * colorLUT->fGridPoints[2];
+    const int n010 = 3 * colorLUT->fGridPoints[2];
+    const int n011 = n001 + n010;
+    const int n100 = 3;
+    const int n101 = n100 + n001;
+    const int n110 = n100 + n010;
+    const int n111 = n110 + n001;
+
+    // Base ptr into the table.
+    const float* ptr = &(colorLUT->table()[ix*n001 + iy*n010 + iz*n100]);
+
+    // The code below performs a tetrahedral interpolation for each of the three
+    // dst components.  Once the tetrahedron containing the interpolation point is
+    // identified, the interpolation is a weighted sum of grid values at the
+    // vertices of the tetrahedron.  The claim is that tetrahedral interpolation
+    // provides a more accurate color conversion.
+    // blogs.mathworks.com/steve/2006/11/24/tetrahedral-interpolation-for-colorspace-conversion/
+    //
+    // I have one test image, and visually I can't tell the difference between
+    // tetrahedral and trilinear interpolation.  In terms of computation, the
+    // tetrahedral code requires more branches but less computation.  The
+    // SampleICC library provides an option for the client to choose either
+    // tetrahedral or trilinear.
+    for (int i = 0; i < 3; i++) {
+        if (diffZ < diffY) {
+            if (diffZ < diffX) {
+                dst[i] = (ptr[n000] + diffZ * (ptr[n110] - ptr[n010]) +
+                                      diffY * (ptr[n010] - ptr[n000]) +
+                                      diffX * (ptr[n111] - ptr[n110]));
+            } else if (diffY < diffX) {
+                dst[i] = (ptr[n000] + diffZ * (ptr[n111] - ptr[n011]) +
+                                      diffY * (ptr[n011] - ptr[n001]) +
+                                      diffX * (ptr[n001] - ptr[n000]));
+            } else {
+                dst[i] = (ptr[n000] + diffZ * (ptr[n111] - ptr[n011]) +
+                                      diffY * (ptr[n010] - ptr[n000]) +
+                                      diffX * (ptr[n011] - ptr[n010]));
+            }
+        } else {
+            if (diffZ < diffX) {
+                dst[i] = (ptr[n000] + diffZ * (ptr[n101] - ptr[n001]) +
+                                      diffY * (ptr[n111] - ptr[n101]) +
+                                      diffX * (ptr[n001] - ptr[n000]));
+            } else if (diffY < diffX) {
+                dst[i] = (ptr[n000] + diffZ * (ptr[n100] - ptr[n000]) +
+                                      diffY * (ptr[n111] - ptr[n101]) +
+                                      diffX * (ptr[n101] - ptr[n100]));
+            } else {
+                dst[i] = (ptr[n000] + diffZ * (ptr[n100] - ptr[n000]) +
+                                      diffY * (ptr[n110] - ptr[n100]) +
+                                      diffX * (ptr[n111] - ptr[n110]));
+            }
+        }
+
+        // Increment the table ptr in order to handle the next component.
+        // Note that this is the how table is designed: all of nXXX
+        // variables are multiples of 3 because there are 3 output
+        // components.
+        ptr++;
+    }
+}
+
+
+/**
+ *  This tests decoding from a Lab source image and displays on the left
+ *  the image as raw RGB values, and on the right a Lab PCS.
+ *  It currently does NOT apply a/b/m-curves, as in the .icc profile
+ *  We are testing it on these are all identity transforms.
+ */
+class LabPCSDemoGM : public skiagm::GM {
+public:
+    LabPCSDemoGM()
+        : fWidth(1080)
+        , fHeight(480)
+        {}
+
+protected:
+
+
+    SkString onShortName() override {
+        return SkString("labpcsdemo");
+    }
+
+    SkISize onISize() override {
+        return SkISize::Make(fWidth, fHeight);
+    }
+
+    void onDraw(SkCanvas* canvas) override {
+        canvas->drawColor(SK_ColorGREEN);
+        const char* filename = "brickwork-texture.jpg";
+        renderImage(canvas, filename, 0, false);
+        renderImage(canvas, filename, 1, true);
+    }
+
+    void renderImage(SkCanvas* canvas, const char* filename, int col, bool convertLabToXYZ) {
+        SkBitmap bitmap;
+        SkStream* stream(GetResourceAsStream(filename));
+        if (stream == nullptr) {
+            return;
+        }
+        std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream));
+        
+
+        // srgb_lab_pcs.icc is an elaborate way to specify sRGB but uses
+        // Lab as the PCS, so we can take any arbitrary image that should
+        // be sRGB and this should show a reasonable image
+        const SkString iccFilename(GetResourcePath("icc_profiles/srgb_lab_pcs.icc"));
+        sk_sp<SkData> iccData = SkData::MakeFromFileName(iccFilename.c_str());
+        if (iccData == nullptr) {
+            return;
+        }
+        sk_sp<SkColorSpace> colorSpace = SkColorSpace::NewICC(iccData->bytes(), iccData->size());
+
+        const int imageWidth = codec->getInfo().width();
+        const int imageHeight = codec->getInfo().height();
+        // Using nullptr as the color space instructs the codec to decode in legacy mode,
+        // meaning that we will get the raw encoded bytes without any color correction.
+        SkImageInfo imageInfo = SkImageInfo::Make(imageWidth, imageHeight, kN32_SkColorType,  
+                                                  kOpaque_SkAlphaType, nullptr);
+        bitmap.allocPixels(imageInfo);
+        codec->getPixels(imageInfo, bitmap.getPixels(), bitmap.rowBytes());
+        if (convertLabToXYZ) {
+            SkASSERT(SkColorSpace_Base::Type::kA2B == as_CSB(colorSpace)->type());
+            SkColorSpace_A2B& cs = *static_cast<SkColorSpace_A2B*>(colorSpace.get());
+            bool printConversions = false;
+            SkASSERT(cs.colorLUT());
+            // We're skipping evaluating the TRCs and the matrix here since they aren't
+            // in the ICC profile initially used here.
+            SkASSERT(kLinear_SkGammaNamed == cs.aCurveNamed());
+            SkASSERT(kLinear_SkGammaNamed == cs.mCurveNamed());
+            SkASSERT(kLinear_SkGammaNamed == cs.bCurveNamed());
+            SkASSERT(cs.matrix().isIdentity());
+            for (int y = 0; y < imageHeight; ++y) {
+                for (int x = 0; x < imageWidth; ++x) {
+                    uint32_t& p = *bitmap.getAddr32(x, y);
+                    const int r = SkColorGetR(p);
+                    const int g = SkColorGetG(p);
+                    const int b = SkColorGetB(p);
+                    if (printConversions) {
+                        SkColorSpacePrintf("\nraw = (%d, %d, %d)\t", r, g, b);
+                    }
+
+                    float lab[4] = { r * (1.f/255.f), g * (1.f/255.f), b * (1.f/255.f), 1.f };
+                    
+                    interp_3d_clut(lab, lab, cs.colorLUT());
+                    
+                    // Lab has ranges [0,100] for L and [-128,127] for a and b
+                    // but the ICC profile loader stores as [0,1]. The ICC
+                    // specifies an offset of -128 to convert.
+                    // note: formula could be adjusted to remove this conversion,
+                    //       but for now let's keep it like this for clarity until
+                    //       an optimized version is added.
+                    lab[0] *= 100.f;
+                    lab[1] = 255.f * lab[1] - 128.f;
+                    lab[2] = 255.f * lab[2] - 128.f;
+                    if (printConversions) {
+                        SkColorSpacePrintf("Lab = < %f, %f, %f >\n", lab[0], lab[1], lab[2]);
+                    }
+
+                    // convert from Lab to XYZ
+                    float Y = (lab[0] + 16.f) * (1.f/116.f);
+                    float X = lab[1] * (1.f/500.f) + Y;
+                    float Z = Y - (lab[2] * (1.f/200.f));
+                    float cubed;
+                    cubed = X*X*X;
+                    if (cubed > 0.008856f)
+                        X = cubed;
+                    else
+                        X = (X - (16.f/116.f)) * (1.f/7.787f);
+                    cubed = Y*Y*Y;
+                    if (cubed > 0.008856f)
+                        Y = cubed;
+                    else
+                        Y = (Y - (16.f/116.f)) * (1.f/7.787f);
+                    cubed = Z*Z*Z;
+                    if (cubed > 0.008856f)
+                        Z = cubed;
+                    else
+                        Z = (Z - (16.f/116.f)) * (1.f/7.787f);
+
+                    // adjust to D50 illuminant
+                    X *= 0.96422f;
+                    Y *= 1.00000f;
+                    Z *= 0.82521f;
+
+                    if (printConversions) {
+                        SkColorSpacePrintf("XYZ = (%4f, %4f, %4f)\t", X, Y, Z);
+                    }
+
+                    // convert XYZ -> linear sRGB
+                    Sk4f lRGB( 3.1338561f*X - 1.6168667f*Y - 0.4906146f*Z,
+                              -0.9787684f*X + 1.9161415f*Y + 0.0334540f*Z,
+                               0.0719453f*X - 0.2289914f*Y + 1.4052427f*Z,
+                              1.f);
+                    // and apply sRGB gamma
+                    Sk4i sRGB = sk_linear_to_srgb(lRGB);
+                    if (printConversions) {
+                        SkColorSpacePrintf("sRGB = (%d, %d, %d)\n", sRGB[0], sRGB[1], sRGB[2]);
+                    }
+                    p = SkColorSetRGB(sRGB[0], sRGB[1], sRGB[2]);
+                }
+            }
+        }
+        const int freeWidth = fWidth - 2*imageWidth;
+        const int freeHeight = fHeight - imageHeight;
+        canvas->drawBitmap(bitmap,
+                           static_cast<SkScalar>((col+1) * (freeWidth / 3) + col*imageWidth),
+                           static_cast<SkScalar>(freeHeight / 2));
+        ++col;
+    }
+
+private:
+    const int fWidth;
+    const int fHeight;
+
+    typedef skiagm::GM INHERITED;
+};
+
+DEF_GM( return new LabPCSDemoGM; )