(Some) gradients are gamma and gamut correct on GPU

src/effects/gradients/SkGradientShader.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Sk4fLinearGradient.h"
 #include "SkGradientShaderPriv.h"
 #include "SkLinearGradient.h"
 #include "SkRadialGradient.h"
 #include "SkTwoPointConicalGradient.h"
 #include "SkSweepGradient.h"
 
 void SkGradientShaderBase::Descriptor::flatten(SkWriteBuffer& buffer) const {
     buffer.writeColorArray(fColors, fCount);
+    // TODO: Flatten fColors4f and fColorSpace
     if (fPos) {
         buffer.writeBool(true);
         buffer.writeScalarArray(fPos, fCount);
     } else {
         buffer.writeBool(false);
     }
     buffer.write32(fTileMode);
     buffer.write32(fGradFlags);
     if (fLocalMatrix) {
         buffer.writeBool(true);
         buffer.writeMatrix(*fLocalMatrix);
     } else {
         buffer.writeBool(false);
     }
 }
 
 bool SkGradientShaderBase::DescriptorScope::unflatten(SkReadBuffer& buffer) {
+    // TODO: Unflatten fColors4f and fColorSpace
     fCount = buffer.getArrayCount();
     if (fCount > kStorageCount) {
         size_t allocSize = (sizeof(SkColor) + sizeof(SkScalar)) * fCount;
         fDynamicStorage.reset(allocSize);
         fColors = (SkColor*)fDynamicStorage.get();
         fPos = (SkScalar*)(fColors + fCount);
     } else {
         fColors = fColorStorage;
         fPos = fPosStorage;
     }
@@ skipping 52 matching lines @@
     // check if we need to add in dummy start and/or end position/colors
     bool dummyFirst = false;
     bool dummyLast = false;
     if (desc.fPos) {
         dummyFirst = desc.fPos[0] != 0;
         dummyLast = desc.fPos[desc.fCount - 1] != SK_Scalar1;
         fColorCount += dummyFirst + dummyLast;
     }
 
     if (fColorCount > kColorStorageCount) {
-        size_t size = sizeof(SkColor) + sizeof(Rec);
+        size_t size = sizeof(SkColor) + sizeof(SkColor4f) + sizeof(Rec);
         if (desc.fPos) {
             size += sizeof(SkScalar);
         }
         fOrigColors = reinterpret_cast<SkColor*>(
                                         sk_malloc_throw(size * fColorCount));
     }
     else {
         fOrigColors = fStorage;
     }
 
-    // Now copy over the colors, adding the dummies as needed
-    {
+    fOrigColors4f = (SkColor4f*)(fOrigColors + fColorCount);
+
+    // We should have been supplied with either fColors *or* (fColors4f and fColorSpace)
+    if (desc.fColors) {
+        // TODO: Should we support alternate gamma-encoded colorspaces with SkColor inputs?
+        SkASSERT(!desc.fColors4f && !desc.fColorSpace);
+
+        // Now copy over the colors, adding the dummies as needed
         SkColor* origColors = fOrigColors;
         if (dummyFirst) {
             *origColors++ = desc.fColors[0];
         }
         memcpy(origColors, desc.fColors, desc.fCount * sizeof(SkColor));
         if (dummyLast) {
             origColors += desc.fCount;
             *origColors = desc.fColors[desc.fCount - 1];
         }
+
+        // Convert our SkColor colors to SkColor4f as well
+        for (int i = 0; i < fColorCount; ++i) {
+            fOrigColors4f[i] = SkColor4f::FromColor(fOrigColors[i]);
+        }
+
+        // Color space refers to fColors4f, so it's always linear gamma
+        fColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named)->makeLinearGamma();
+    } else {
+        SkASSERT(desc.fColors4f && desc.fColorSpace && desc.fColorSpace->gammaIsLinear());
+
+        // Now copy over the colors, adding the dummies as needed
+        SkColor4f* origColors = fOrigColors4f;
+        if (dummyFirst) {
+            *origColors++ = desc.fColors4f[0];
+        }
+        memcpy(origColors, desc.fColors4f, desc.fCount * sizeof(SkColor4f));
+        if (dummyLast) {
+            origColors += desc.fCount;
+            *origColors = desc.fColors4f[desc.fCount - 1];
+        }
+
+        // Convert our SkColor4f colors to SkColor as well. Note that this is incorrect if the
+        // source colors are not in sRGB gamut. We would need to do a gamut transformation, but
+        // SkColorSpaceXform can't do that (yet). GrColorSpaceXform can, but we may not have GPU
+        // support compiled in here.
+        for (int i = 0; i < fColorCount; ++i) {
+            fOrigColors[i] = fOrigColors4f[i].toSkColor();
+        }
+        fColorSpace = desc.fColorSpace;
     }
 
     if (desc.fPos && fColorCount) {
-        fOrigPos = (SkScalar*)(fOrigColors + fColorCount);
+        fOrigPos = (SkScalar*)(fOrigColors4f + fColorCount);
         fRecs = (Rec*)(fOrigPos + fColorCount);
     } else {
         fOrigPos = nullptr;
-        fRecs = (Rec*)(fOrigColors + fColorCount);
+        fRecs = (Rec*)(fOrigColors4f + fColorCount);
     }
 
     if (fColorCount > 2) {
         Rec* recs = fRecs;
         recs->fPos = 0;
         //  recs->fScale = 0; // unused;
         recs += 1;
         if (desc.fPos) {
             SkScalar* origPosPtr = fOrigPos;
             *origPosPtr++ = 0;
@@ skipping 65 matching lines @@
     unsigned colorAlpha = 0xFF;
     for (int i = 0; i < fColorCount; i++) {
         colorAlpha &= SkColorGetA(fOrigColors[i]);
     }
     fColorsAreOpaque = colorAlpha == 0xFF;
 }
 
 void SkGradientShaderBase::flatten(SkWriteBuffer& buffer) const {
     Descriptor desc;
     desc.fColors = fOrigColors;
+    desc.fColors4f = fOrigColors4f;
+    desc.fColorSpace = fColorSpace;
     desc.fPos = fOrigPos;
     desc.fCount = fColorCount;
     desc.fTileMode = fTileMode;
     desc.fGradFlags = fGradFlags;
 
     const SkMatrix& m = this->getLocalMatrix();
     desc.fLocalMatrix = m.isIdentity() ? nullptr : &m;
     desc.flatten(buffer);
 }
 
@@ skipping 510 matching lines @@
 static bool valid_grad(const SkColor colors[], const SkScalar pos[], int count, unsigned tileMode) {
     return nullptr != colors && count >= 1 && tileMode < (unsigned)SkShader::kTileModeCount;
 }
 
 static void desc_init(SkGradientShaderBase::Descriptor* desc,
                       const SkColor colors[], const SkScalar pos[], int colorCount,
                       SkShader::TileMode mode, uint32_t flags, const SkMatrix* localMatrix) {
     SkASSERT(colorCount > 1);
 
     desc->fColors       = colors;
+    desc->fColors4f     = nullptr;
+    desc->fColorSpace   = nullptr; // SkColor is always sRGB
     desc->fPos          = pos;
     desc->fCount        = colorCount;
     desc->fTileMode     = mode;
     desc->fGradFlags    = flags;
     desc->fLocalMatrix  = localMatrix;
 }
 
 // assumes colors is SkColor* and pos is SkScalar*
 #define EXPAND_1_COLOR(count)                \
      SkColor tmp[2];                         \
@@ skipping 264 matching lines @@
                                                      kDefault_GrSLPrecision,
                                                      "Colors",
                                                      colorCount);
     } else {
         fFSYUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                              kFloat_GrSLType, kDefault_GrSLPrecision,
                                              "GradientYCoordFS");
     }
 }
 
+static inline void set_after_interp_color_uni_array(
+                                                  const GrGLSLProgramDataManager& pdman,
+                                                  const GrGLSLProgramDataManager::UniformHandle uni,
+                                                  const SkTDArray<SkColor4f>& colors,
+                                                  const GrColorSpaceXform* colorSpaceXform) {
+    int count = colors.count();
+    if (colorSpaceXform) {
+        constexpr int kSmallCount = 10;
+        SkAutoSTArray<4 * kSmallCount, float> vals(4 * count);
+
+        for (int i = 0; i < count; i++) {
+            colorSpaceXform->srcToDst().mapScalars(colors[i].vec(), &vals[4 * i]);
+        }
+
+        pdman.set4fv(uni, count, vals.get());
+    } else {
+        pdman.set4fv(uni, count, (float*)&colors[0]);
+    }
+}
+
+static inline void set_before_interp_color_uni_array(
+                                                  const GrGLSLProgramDataManager& pdman,
+                                                  const GrGLSLProgramDataManager::UniformHandle uni,
+                                                  const SkTDArray<SkColor4f>& colors,
+                                                  const GrColorSpaceXform* colorSpaceXform) {
+    int count = colors.count();
+    constexpr int kSmallCount = 10;
+    SkAutoSTArray<4 * kSmallCount, float> vals(4 * count);
+
+    for (int i = 0; i < count; i++) {
+        float a = colors[i].fA;
+        vals[4 * i + 0] = colors[i].fR * a;
+        vals[4 * i + 1] = colors[i].fG * a;
+        vals[4 * i + 2] = colors[i].fB * a;
+        vals[4 * i + 3] = a;
+    }
+
+    if (colorSpaceXform) {
+        for (int i = 0; i < count; i++) {
+            colorSpaceXform->srcToDst().mapScalars(&vals[4 * i]);
+        }
+    }
+
+    pdman.set4fv(uni, count, vals.get());
+}
+
 static inline void set_after_interp_color_uni_array(const GrGLSLProgramDataManager& pdman,
                                        const GrGLSLProgramDataManager::UniformHandle uni,
                                        const SkTDArray<SkColor>& colors) {
     int count = colors.count();
     constexpr int kSmallCount = 10;
 
     SkAutoSTArray<4*kSmallCount, float> vals(4*count);
 
     for (int i = 0; i < colors.count(); i++) {
         // RGBA
@@ skipping 33 matching lines @@
     const GrGradientEffect& e = processor.cast<GrGradientEffect>();
 
     switch (e.getColorType()) {
 #if GR_GL_USE_ACCURATE_HARD_STOP_GRADIENTS
         case GrGradientEffect::kHardStopCentered_ColorType:
         case GrGradientEffect::kHardStopLeftEdged_ColorType:
         case GrGradientEffect::kHardStopRightEdged_ColorType:
 #endif
         case GrGradientEffect::kTwo_ColorType:
         case GrGradientEffect::kThree_ColorType: {
-            if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) {
-                set_before_interp_color_uni_array(pdman, fColorsUni, e.fColors);
+            if (e.fColors4f.count() > 0) {
+                // Gamma-correct / color-space aware
+                if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) {
+                    set_before_interp_color_uni_array(pdman, fColorsUni, e.fColors4f,
+                                                      e.fColorSpaceXform.get());
+                } else {
+                    set_after_interp_color_uni_array(pdman, fColorsUni, e.fColors4f,
+                                                     e.fColorSpaceXform.get());
+                }
             } else {
-                set_after_interp_color_uni_array(pdman, fColorsUni, e.fColors);
+                // Legacy mode. Would be nice if we had converted the 8-bit colors to float earlier
+                if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) {
+                    set_before_interp_color_uni_array(pdman, fColorsUni, e.fColors);
+                } else {
+                    set_after_interp_color_uni_array(pdman, fColorsUni, e.fColors);
+                }
             }
 
             break;
         }
 
         case GrGradientEffect::kTexture_ColorType: {
             SkScalar yCoord = e.getYCoord();
             if (yCoord != fCachedYCoord) {
                 pdman.set1f(fFSYUni, yCoord);
                 fCachedYCoord = yCoord;
@@ skipping 231 matching lines @@
 /////////////////////////////////////////////////////////////////////
 
 GrGradientEffect::GrGradientEffect(const CreateArgs& args) {
     const SkGradientShaderBase& shader(*args.fShader);
 
     fIsOpaque = shader.isOpaque();
 
     fColorType = this->determineColorType(shader);
 
     if (kTexture_ColorType != fColorType) {
-        if (shader.fOrigColors) {
+        SkASSERT(shader.fOrigColors && shader.fOrigColors4f);
+        if (args.fGammaCorrect) {
+            fColors4f = SkTDArray<SkColor4f>(shader.fOrigColors4f, shader.fColorCount);
+            fColorSpaceXform = std::move(args.fColorSpaceXform);
+        } else {
             fColors = SkTDArray<SkColor>(shader.fOrigColors, shader.fColorCount);
         }
 
 #if GR_GL_USE_ACCURATE_HARD_STOP_GRADIENTS
         if (shader.fOrigPos) {
             fPositions = SkTDArray<SkScalar>(shader.fOrigPos, shader.fColorCount);
         }
 #endif
     }
 
@@ skipping 79 matching lines @@
 bool GrGradientEffect::onIsEqual(const GrFragmentProcessor& processor) const {
     const GrGradientEffect& ge = processor.cast<GrGradientEffect>();
 
     if (this->fColorType == ge.getColorType()) {
         if (kTexture_ColorType == fColorType) {
             if (fYCoord != ge.getYCoord()) {
                 return false;
             }
         } else {
             if (this->getPremulType() != ge.getPremulType() ||
-                this->fColors.count() != ge.fColors.count()) {
+                this->fColors.count() != ge.fColors.count() ||
+                this->fColors4f.count() != ge.fColors4f.count()) {
                 return false;
             }
 
             for (int i = 0; i < this->fColors.count(); i++) {
                 if (*this->getColors(i) != *ge.getColors(i)) {
                     return false;
                 }
             }
+            for (int i = 0; i < this->fColors4f.count(); i++) {
+                if (*this->getColors4f(i) != *ge.getColors4f(i)) {
+                    return false;
+                }
+            }
         }
 
+
         SkASSERT(this->useAtlas() == ge.useAtlas());
-        return true;
+        return GrColorSpaceXform::Equals(this->fColorSpaceXform.get(), ge.fColorSpaceXform.get());
     }
 
     return false;
 }
 
 void GrGradientEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     if (fIsOpaque) {
         inout->mulByUnknownOpaqueFourComponents();
     } else {
         inout->mulByUnknownFourComponents();
@@ skipping 18 matching lines @@
             (*stops)[i] = stop;
             stop = i < outColors - 1 ? stop + random->nextUScalar1() * (1.f - stop) : 1.f;
         }
     }
     *tm = static_cast<SkShader::TileMode>(random->nextULessThan(SkShader::kTileModeCount));
 
     return outColors;
 }
 
 #endif