Include sRGB -> Linear in the cached "from sRGB" xform

This simplifies the handling of paint color conversion, as well as
GrDrawVerticesOp and the default geometry processor. We don't need
to track "linearize" separate from the color space xform. We only
supply an xform if needed. The linearize is now done automatically
by the xform, though we aren't converting to destination gamma.

https://skia-review.googlesource.com/c/skia/+/132090 will fix that.

Change-Id: I0af3f29c123c3dadb818f87c5d295bc78e2ff079
Reviewed-on: https://skia-review.googlesource.com/135141
Reviewed-by: Brian Osman <brianosman@google.com>
Commit-Queue: Brian Osman <brianosman@google.com>

7 files changed, 33 insertions, 95 deletions

diff --git a/src/gpu/GrColorSpaceInfo.cpp b/src/gpu/GrColorSpaceInfo.cpp
index 1a49e8622d..73218b26c5 100644
--- a/src/gpu/GrColorSpaceInfo.cpp
+++ b/src/gpu/GrColorSpaceInfo.cpp
@@ -15,10 +15,9 @@ GrColorSpaceInfo::GrColorSpaceInfo(sk_sp<SkColorSpace> colorSpace, GrPixelConfig
 GrColorSpaceXform* GrColorSpaceInfo::colorSpaceXformFromSRGB() const {
     // TODO: Make this atomic if we start accessing this on multiple threads.
     if (!fInitializedColorSpaceXformFromSRGB) {
-        // sRGB sources are very common (SkColor, etc...), so we cache that gamut transformation
+        // sRGB sources are very common (SkColor, etc...), so we cache that transformation
         auto srgbColorSpace = SkColorSpace::MakeSRGB();
-        fColorXformFromSRGB = GrColorSpaceXform::MakeGamutXform(srgbColorSpace.get(),
-                                                                fColorSpace.get());
+        fColorXformFromSRGB = GrColorSpaceXform::Make(srgbColorSpace.get(), fColorSpace.get());
         fInitializedColorSpaceXformFromSRGB = true;
     }
     // You can't be color-space aware in legacy mode
diff --git a/src/gpu/GrDefaultGeoProcFactory.cpp b/src/gpu/GrDefaultGeoProcFactory.cpp
index 2f96ade450..defb214eb0 100644
--- a/src/gpu/GrDefaultGeoProcFactory.cpp
+++ b/src/gpu/GrDefaultGeoProcFactory.cpp
@@ -27,8 +27,6 @@ enum GPFlag {
     kColorAttributeIsSkColor_GPFlag = 0x2,
     kLocalCoordAttribute_GPFlag     = 0x4,
     kCoverageAttribute_GPFlag       = 0x8,
-
-    kLinearizeColorAttribute_GPFlag = 0x10,
 };
 
 class DefaultGeoProc : public GrGeometryProcessor {
@@ -58,12 +56,6 @@ public:
     bool localCoordsWillBeRead() const { return fLocalCoordsWillBeRead; }
     uint8_t coverage() const { return fCoverage; }
     bool hasVertexCoverage() const { return SkToBool(fInCoverage); }
-    bool linearizeColor() const {
-        // Linearization should only happen with SkColor
-        bool linearize = SkToBool(fFlags & kLinearizeColorAttribute_GPFlag);
-        SkASSERT(!linearize || (fFlags & kColorAttributeIsSkColor_GPFlag));
-        return linearize;
-    }
 
     class GLSLProcessor : public GrGLSLGeometryProcessor {
     public:
@@ -88,39 +80,22 @@ public:
                 // There are several optional steps to process the color. Start with the attribute:
                 vertBuilder->codeAppendf("half4 color = %s;", gp.inColor()->name());
 
-                // Linearize
-                if (gp.linearizeColor()) {
-                    SkString srgbFuncName;
-                    static const GrShaderVar gSrgbArgs[] = {
-                        GrShaderVar("x", kHalf_GrSLType),
-                    };
-                    vertBuilder->emitFunction(kHalf_GrSLType,
-                                              "srgb_to_linear",
-                                              SK_ARRAY_COUNT(gSrgbArgs),
-                                              gSrgbArgs,
-                                              "return (x <= 0.04045) ? (x / 12.92) "
-                                              ": pow((x + 0.055) / 1.055, 2.4);",
-                                              &srgbFuncName);
-                    vertBuilder->codeAppendf("color = half4(%s(%s.r), %s(%s.g), %s(%s.b), %s.a);",
-                                             srgbFuncName.c_str(), gp.inColor()->name(),
-                                             srgbFuncName.c_str(), gp.inColor()->name(),
-                                             srgbFuncName.c_str(), gp.inColor()->name(),
-                                             gp.inColor()->name());
-                }
-
-                // For SkColor, do a red/blue swap and premul
+                // For SkColor, do a red/blue swap, possible color space conversion, and premul
                 if (gp.fFlags & kColorAttributeIsSkColor_GPFlag) {
-                    vertBuilder->codeAppend("color = half4(color.a * color.bgr, color.a);");
+                    vertBuilder->codeAppend("color = color.bgra;");
+
+                    if (gp.fColorSpaceXform) {
+                        fColorSpaceHelper.emitCode(uniformHandler, gp.fColorSpaceXform.get(),
+                                                   kVertex_GrShaderFlag);
+                        SkString xformedColor;
+                        vertBuilder->appendColorGamutXform(&xformedColor, "color",
+                                                           &fColorSpaceHelper);
+                        vertBuilder->codeAppendf("color = %s;", xformedColor.c_str());
+                    }
+
+                    vertBuilder->codeAppend("color = half4(color.rgb * color.a, color.a);");
                 }
 
-                // Do color-correction to destination gamut
-                if (gp.linearizeColor()) {
-                    fColorSpaceHelper.emitCode(uniformHandler, gp.fColorSpaceXform.get(),
-                                               kVertex_GrShaderFlag);
-                    SkString xformedColor;
-                    vertBuilder->appendColorGamutXform(&xformedColor, "color", &fColorSpaceHelper);
-                    vertBuilder->codeAppendf("color = %s;", xformedColor.c_str());
-                }
                 vertBuilder->codeAppendf("%s = color;\n", varying.vsOut());
                 fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, varying.fsIn());
             } else {
@@ -180,9 +155,7 @@ public:
             key |= (def.localCoordsWillBeRead() && def.localMatrix().hasPerspective()) ? 0x20 : 0x0;
             key |= ComputePosKey(def.viewMatrix()) << 20;
             b->add32(key);
-            if (def.linearizeColor()) {
-                b->add32(GrColorSpaceXform::XformKey(def.fColorSpaceXform.get()));
-            }
+            b->add32(GrColorSpaceXform::XformKey(def.fColorSpaceXform.get()));
         }
 
         void setData(const GrGLSLProgramDataManager& pdman,
@@ -210,9 +183,7 @@ public:
             }
             this->setTransformDataHelper(dgp.fLocalMatrix, pdman, &transformIter);
 
-            if (dgp.linearizeColor() && dgp.fColorSpaceXform) {
-                fColorSpaceHelper.setData(pdman, dgp.fColorSpaceXform.get());
-            }
+            fColorSpaceHelper.setData(pdman, dgp.fColorSpaceXform.get());
         }
 
     private:
@@ -318,12 +289,6 @@ sk_sp<GrGeometryProcessor> GrDefaultGeoProcFactory::Make(const Color& color,
     } else if (Color::kUnpremulSkColorAttribute_Type == color.fType) {
         flags |= kColorAttribute_GPFlag | kColorAttributeIsSkColor_GPFlag;
     }
-    if (color.fLinearize) {
-        // It only makes sense to linearize SkColors (which are always sRGB). GrColor values should
-        // have been linearized and gamut-converted during paint conversion
-        SkASSERT(Color::kUnpremulSkColorAttribute_Type == color.fType);
-        flags |= kLinearizeColorAttribute_GPFlag;
-    }
     flags |= coverage.fType == Coverage::kAttribute_Type ? kCoverageAttribute_GPFlag : 0;
     flags |= localCoords.fType == LocalCoords::kHasExplicit_Type ? kLocalCoordAttribute_GPFlag : 0;
 
diff --git a/src/gpu/GrDefaultGeoProcFactory.h b/src/gpu/GrDefaultGeoProcFactory.h
index 66f27589dd..314c1bb963 100644
--- a/src/gpu/GrDefaultGeoProcFactory.h
+++ b/src/gpu/GrDefaultGeoProcFactory.h
@@ -70,12 +70,10 @@ namespace GrDefaultGeoProcFactory {
         explicit Color(GrColor color)
                 : fType(kPremulGrColorUniform_Type)
                 , fColor(color)
-                , fLinearize(false)
                 , fColorSpaceXform(nullptr) {}
         Color(Type type)
                 : fType(type)
                 , fColor(GrColor_ILLEGAL)
-                , fLinearize(false)
                 , fColorSpaceXform(nullptr) {
             SkASSERT(type != kPremulGrColorUniform_Type);
         }
@@ -83,9 +81,8 @@ namespace GrDefaultGeoProcFactory {
         Type fType;
         GrColor fColor;
 
-        // These options only apply to SkColor. Any GrColors are assumed to have been color managed
+        // This only applies to SkColor. Any GrColors are assumed to have been color converted
         // during paint conversion.
-        bool fLinearize;
         sk_sp<GrColorSpaceXform> fColorSpaceXform;
     };
 
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index d8298108ab..ebb0054f40 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -856,7 +856,6 @@ void GrRenderTargetContext::drawVertices(const GrClip& clip,
     GrAAType aaType = this->chooseAAType(GrAA::kNo, GrAllowMixedSamples::kNo);
     std::unique_ptr<GrDrawOp> op = GrDrawVerticesOp::Make(
             fContext, std::move(paint), std::move(vertices), viewMatrix, aaType,
-            this->colorSpaceInfo().isGammaCorrect(),
             this->colorSpaceInfo().refColorSpaceXformFromSRGB(), overridePrimType);
     this->addDrawOp(clip, std::move(op));
 }
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 69df337dfc..9a13398c33 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -210,7 +210,7 @@ sk_sp<GrTextureProxy> GrMakeCachedImageProxy(GrProxyProvider* proxyProvider,
 ///////////////////////////////////////////////////////////////////////////////
 
 GrColor4f SkColorToPremulGrColor4f(SkColor c, const GrColorSpaceInfo& colorSpaceInfo) {
-    // We want to premultiply after linearizing, so this is easy:
+    // We want to premultiply after color space conversion, so this is easy:
     return SkColorToUnpremulGrColor4f(c, colorSpaceInfo).premul();
 }
 
@@ -219,19 +219,10 @@ GrColor4f SkColorToPremulGrColor4fLegacy(SkColor c) {
 }
 
 GrColor4f SkColorToUnpremulGrColor4f(SkColor c, const GrColorSpaceInfo& colorSpaceInfo) {
-    GrColor4f color;
-    if (colorSpaceInfo.colorSpace()) {
-        // SkColor4f::FromColor does sRGB -> Linear
-        color = GrColor4f::FromSkColor4f(SkColor4f::FromColor(c));
-    } else {
-        // GrColor4f::FromGrColor just multiplies by 1/255
-        color = GrColor4f::FromGrColor(SkColorToUnpremulGrColor(c));
-    }
-
+    GrColor4f color = GrColor4f::FromGrColor(SkColorToUnpremulGrColor(c));
     if (auto* xform = colorSpaceInfo.colorSpaceXformFromSRGB()) {
         color = xform->clampedXform(color);
     }
-
     return color;
 }
 
@@ -308,7 +299,7 @@ static inline bool skpaint_to_grpaint_impl(GrContext* context,
                                            std::unique_ptr<GrFragmentProcessor>* shaderProcessor,
                                            SkBlendMode* primColorMode,
                                            GrPaint* grPaint) {
-    // Convert SkPaint color to 4f format, including optional linearizing and gamut conversion.
+    // Convert SkPaint color to 4f format in the destination color space
     GrColor4f origColor = SkColorToUnpremulGrColor4f(skPaint.getColor(), colorSpaceInfo);
 
     const GrFPArgs fpArgs(context, &viewM, skPaint.getFilterQuality(), &colorSpaceInfo);
diff --git a/src/gpu/ops/GrDrawVerticesOp.cpp b/src/gpu/ops/GrDrawVerticesOp.cpp
index 4103387551..c968611152 100644
--- a/src/gpu/ops/GrDrawVerticesOp.cpp
+++ b/src/gpu/ops/GrDrawVerticesOp.cpp
@@ -16,21 +16,19 @@ std::unique_ptr<GrDrawOp> GrDrawVerticesOp::Make(GrContext* context,
                                                  sk_sp<SkVertices> vertices,
                                                  const SkMatrix& viewMatrix,
                                                  GrAAType aaType,
-                                                 bool gammaCorrect,
                                                  sk_sp<GrColorSpaceXform> colorSpaceXform,
                                                  GrPrimitiveType* overridePrimType) {
     SkASSERT(vertices);
     GrPrimitiveType primType = overridePrimType ? *overridePrimType
                                                 : SkVertexModeToGrPrimitiveType(vertices->mode());
     return Helper::FactoryHelper<GrDrawVerticesOp>(context, std::move(paint), std::move(vertices),
-                                                   primType, aaType, gammaCorrect,
-                                                   std::move(colorSpaceXform), viewMatrix);
+                                                   primType, aaType, std::move(colorSpaceXform),
+                                                   viewMatrix);
 }
 
 GrDrawVerticesOp::GrDrawVerticesOp(const Helper::MakeArgs& helperArgs, GrColor color,
                                    sk_sp<SkVertices> vertices, GrPrimitiveType primitiveType,
-                                   GrAAType aaType, bool gammaCorrect,
-                                   sk_sp<GrColorSpaceXform> colorSpaceXform,
+                                   GrAAType aaType, sk_sp<GrColorSpaceXform> colorSpaceXform,
                                    const SkMatrix& viewMatrix)
         : INHERITED(ClassID())
         , fHelper(helperArgs, aaType)
@@ -42,9 +40,6 @@ GrDrawVerticesOp::GrDrawVerticesOp(const Helper::MakeArgs& helperArgs, GrColor c
     fIndexCount = vertices->indexCount();
     fColorArrayType = vertices->hasColors() ? ColorArrayType::kSkColor
                                             : ColorArrayType::kPremulGrColor;
-    // GrColor is linearized (and gamut converted) during paint conversion, but SkColors need to be
-    // handled in the shader
-    fLinearizeColors = gammaCorrect && vertices->hasColors();
 
     Mesh& mesh = fMeshes.push_back();
     mesh.fColor = color;
@@ -98,7 +93,6 @@ GrDrawOp::RequiresDstTexture GrDrawVerticesOp::finalize(const GrCaps& caps,
         fMeshes.front().fIgnoreColors = true;
         fFlags &= ~kRequiresPerVertexColors_Flag;
         fColorArrayType = ColorArrayType::kPremulGrColor;
-        fLinearizeColors = false;
     }
     if (!fHelper.usesLocalCoords()) {
         fMeshes[0].fIgnoreTexCoords = true;
@@ -128,11 +122,12 @@ sk_sp<GrGeometryProcessor> GrDrawVerticesOp::makeGP(bool* hasColorAttribute,
 
     Color color(fMeshes[0].fColor);
     if (this->requiresPerVertexColors()) {
-        color.fType = (fColorArrayType == ColorArrayType::kPremulGrColor)
-                              ? Color::kPremulGrColorAttribute_Type
-                              : Color::kUnpremulSkColorAttribute_Type;
-        color.fLinearize = fLinearizeColors;
-        color.fColorSpaceXform = fColorSpaceXform;
+        if (fColorArrayType == ColorArrayType::kPremulGrColor) {
+            color.fType = Color::kPremulGrColorAttribute_Type;
+        } else {
+            color.fType = Color::kUnpremulSkColorAttribute_Type;
+            color.fColorSpaceXform = fColorSpaceXform;
+        }
         *hasColorAttribute = true;
     } else {
         *hasColorAttribute = false;
@@ -272,10 +267,6 @@ bool GrDrawVerticesOp::onCombineIfPossible(GrOp* t, const GrCaps& caps) {
         return false;
     }
 
-    if (fLinearizeColors != that->fLinearizeColors) {
-        return false;
-    }
-
     if (fVertexCount + that->fVertexCount > SkTo<int>(UINT16_MAX)) {
         return false;
     }
@@ -390,7 +381,6 @@ GR_DRAW_OP_TEST_DEFINE(GrDrawVerticesOp) {
     bool hasTexCoords = random->nextBool();
     bool hasIndices = random->nextBool();
     bool hasColors = random->nextBool();
-    bool linearizeColors = random->nextBool();
 
     uint32_t vertexCount = seed_vertices(type) + (primitiveCount - 1) * primitive_vertices(type);
 
@@ -420,7 +410,7 @@ GR_DRAW_OP_TEST_DEFINE(GrDrawVerticesOp) {
         aaType = GrAAType::kMSAA;
     }
     return GrDrawVerticesOp::Make(context, std::move(paint), std::move(vertices), viewMatrix,
-                                  aaType, linearizeColors, std::move(colorSpaceXform), &type);
+                                  aaType, std::move(colorSpaceXform), &type);
 }
 
 #endif
diff --git a/src/gpu/ops/GrDrawVerticesOp.h b/src/gpu/ops/GrDrawVerticesOp.h
index dccb5ecccb..6d35c0d0e9 100644
--- a/src/gpu/ops/GrDrawVerticesOp.h
+++ b/src/gpu/ops/GrDrawVerticesOp.h
@@ -33,20 +33,18 @@ public:
      * Draw a SkVertices. The GrPaint param's color is used if the vertices lack per-vertex color.
      * If the vertices lack local coords then the vertex positions are used as local coords. The
      * primitive type drawn is derived from the SkVertices object, unless overridePrimType is
-     * specified. If gammaCorrect is true, the vertex colors will be linearized in the shader to get
-     * correct rendering.
+     * specified.
      */
     static std::unique_ptr<GrDrawOp> Make(GrContext* context,
                                           GrPaint&&,
                                           sk_sp<SkVertices>,
                                           const SkMatrix& viewMatrix,
                                           GrAAType,
-                                          bool gammaCorrect,
                                           sk_sp<GrColorSpaceXform>,
                                           GrPrimitiveType* overridePrimType = nullptr);
 
     GrDrawVerticesOp(const Helper::MakeArgs& helperArgs, GrColor, sk_sp<SkVertices>,
-                     GrPrimitiveType, GrAAType, bool gammaCorrect, sk_sp<GrColorSpaceXform>,
+                     GrPrimitiveType, GrAAType, sk_sp<GrColorSpaceXform>,
                      const SkMatrix& viewMatrix);
 
     const char* name() const override { return "DrawVerticesOp"; }
@@ -130,7 +128,6 @@ private:
     int fVertexCount;
     int fIndexCount;
     ColorArrayType fColorArrayType;
-    bool fLinearizeColors;
     sk_sp<GrColorSpaceXform> fColorSpaceXform;
 
     typedef GrMeshDrawOp INHERITED;