(Some) gradients are gamma and gamut correct on GPU

src/effects/gradients/SkGradientShaderPriv.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkGradientShaderPriv_DEFINED
 #define SkGradientShaderPriv_DEFINED
 
 #include "SkGradientBitmapCache.h"
 #include "SkGradientShader.h"
 #include "SkClampRange.h"
 #include "SkColorPriv.h"
+#include "SkColorSpace.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkMallocPixelRef.h"
 #include "SkUtils.h"
 #include "SkShader.h"
 #include "SkOnce.h"
 
 #if SK_SUPPORT_GPU
     #define GR_GL_USE_ACCURATE_HARD_STOP_GRADIENTS 1
 #endif
@@ skipping 51 matching lines @@
 
 class SkGradientShaderBase : public SkShader {
 public:
     struct Descriptor {
         Descriptor() {
             sk_bzero(this, sizeof(*this));
             fTileMode = SkShader::kClamp_TileMode;
         }
 
         const SkMatrix*     fLocalMatrix;
         const SkColor*      fColors;

[f(malita), 2016/09/14 23:32:23]

Could we drop fColors from Descriptor?  IIRC it's a private struct used to hold
gradient info temporarily, so as long as we're keeping the most accurate
representation (fColors4f + fColorSpace) we should be able to reconstruct the
other format when needed.

I guess it adds an extra transformation on legacy gradient data (SkColor[] ->
SkColor4f[] -> SkColor[]), but it should allow us to get rid of one of the
branches in SkGradientShaderBase(), right?

+        const SkColor4f*    fColors4f;
+        sk_sp<SkColorSpace> fColorSpace;
         const SkScalar*     fPos;
         int                 fCount;
         SkShader::TileMode  fTileMode;
         uint32_t            fGradFlags;
 
         void flatten(SkWriteBuffer&) const;
     };
 
     class DescriptorScope : public Descriptor {
     public:
@@ skipping 137 matching lines @@
      * The rec src and dst are only assumed to be valid if count > 2
      */
     static void FlipGradientColors(SkColor* colorDst, Rec* recDst,
                                    SkColor* colorSrc, Rec* recSrc,
                                    int count);
 
 private:
     enum {
         kColorStorageCount = 4, // more than this many colors, and we'll use sk_malloc for the space
 
-        kStorageSize = kColorStorageCount * (sizeof(SkColor) + sizeof(SkScalar) + sizeof(Rec))
+        kStorageSize = kColorStorageCount *
+                       (sizeof(SkColor) + sizeof(SkScalar) + sizeof(Rec) + sizeof(SkColor4f))
     };
-    SkColor     fStorage[(kStorageSize + 3) >> 2];
+    SkColor             fStorage[(kStorageSize + 3) >> 2];
 public:
-    SkColor*    fOrigColors; // original colors, before modulation by paint in context.
-    SkScalar*   fOrigPos;   // original positions
-    int         fColorCount;
+    SkColor*            fOrigColors;   // original colors, before modulation by paint in context.
+    SkColor4f*          fOrigColors4f; // original colors, as linear floats
+    SkScalar*           fOrigPos;      // original positions
+    int                 fColorCount;
+    sk_sp<SkColorSpace> fColorSpace; // color space of gradient stops
 
     bool colorsAreOpaque() const { return fColorsAreOpaque; }
 
     TileMode getTileMode() const { return fTileMode; }
     Rec* getRecs() const { return fRecs; }
 
 private:
-    bool        fColorsAreOpaque;
+    bool                fColorsAreOpaque;
 
     GradientShaderCache* refCache(U8CPU alpha, bool dither) const;
     mutable SkMutex                           fCacheMutex;
     mutable SkAutoTUnref<GradientShaderCache> fCache;
 
     void initCommon();
 
     typedef SkShader INHERITED;
 };
 
@@ skipping 12 matching lines @@
 }
 
 static inline int next_dither_toggle16(int toggle) {
     return toggle ^ SkGradientShaderBase::kDitherStride16;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
+#include "GrColorSpaceXform.h"
 #include "GrCoordTransform.h"
 #include "GrFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 
 class GrInvariantOutput;
 
 /*
  * The interpretation of the texture matrix depends on the sample mode. The
  * texture matrix is applied both when the texture coordinates are explicit
@@ skipping 19 matching lines @@
 
  class GrTextureStripAtlas;
 
 // Base class for Gr gradient effects
 class GrGradientEffect : public GrFragmentProcessor {
 public:
     struct CreateArgs {
         CreateArgs(GrContext* context,
                    const SkGradientShaderBase* shader,
                    const SkMatrix* matrix,
-                   SkShader::TileMode tileMode)
+                   SkShader::TileMode tileMode,
+                   sk_sp<GrColorSpaceXform> colorSpaceXform,
+                   bool gammaCorrect)
             : fContext(context)
             , fShader(shader)
             , fMatrix(matrix)
-            , fTileMode(tileMode) {}
+            , fTileMode(tileMode)
+            , fColorSpaceXform(std::move(colorSpaceXform))
+            , fGammaCorrect(gammaCorrect) {}
 
         GrContext*                  fContext;
         const SkGradientShaderBase* fShader;
         const SkMatrix*             fMatrix;
         SkShader::TileMode          fTileMode;
+        sk_sp<GrColorSpaceXform>    fColorSpaceXform;
+        bool                        fGammaCorrect;
     };
 
     class GLSLProcessor;
 
     GrGradientEffect(const CreateArgs&);
 
     virtual ~GrGradientEffect();
 
     bool useAtlas() const { return SkToBool(-1 != fRow); }
     SkScalar getYCoord() const { return fYCoord; }
@@ skipping 27 matching lines @@
     };
 
     PremulType getPremulType() const { return fPremulType; }
 
     const SkColor* getColors(int pos) const {
         SkASSERT(fColorType != kTexture_ColorType);
         SkASSERT(pos < fColors.count());
         return &fColors[pos];
     }
 
+    const SkColor4f* getColors4f(int pos) const {
+        SkASSERT(fColorType != kTexture_ColorType);
+        SkASSERT(pos < fColors4f.count());
+        return &fColors4f[pos];
+    }
+
 protected:
     /** Populates a pair of arrays with colors and stop info to construct a random gradient.
         The function decides whether stop values should be used or not. The return value indicates
         the number of colors, which will be capped by kMaxRandomGradientColors. colors should be
         sized to be at least kMaxRandomGradientColors. stops is a pointer to an array of at least
         size kMaxRandomGradientColors. It may be updated to nullptr, indicating that nullptr should
         be passed to the gradient factory rather than the array.
     */
     static const int kMaxRandomGradientColors = 4;
     static int RandomGradientParams(SkRandom* r,
                                     SkColor colors[kMaxRandomGradientColors],
                                     SkScalar** stops,
                                     SkShader::TileMode* tm);
 
     bool onIsEqual(const GrFragmentProcessor&) const override;
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
 
     const GrCoordTransform& getCoordTransform() const { return fCoordTransform; }
 
 private:
     static const GrCoordSet kCoordSet = kLocal_GrCoordSet;
 
-    SkTDArray<SkColor>  fColors;
-    SkTDArray<SkScalar> fPositions;
-    SkShader::TileMode  fTileMode;
+    // If we're in legacy mode, then fColors will be populated. If we're gamma-correct, then
+    // fColors4f and fColorSpaceXform will be populated.

[reed1, 2016/09/14 19:03:53]

not specific to this CL... but you went from 2 mallocs to 3. I wonder if we can
collapse all 3 into 1 storage?

[Brian Osman, 2016/09/14 20:30:20]

Probably. Although we still only have 2 (only one of fColors and fColors4f will
be allocated).

+    SkTDArray<SkColor>       fColors;
+
+    SkTDArray<SkColor4f>     fColors4f;
+    sk_sp<GrColorSpaceXform> fColorSpaceXform;
+
+    SkTDArray<SkScalar>      fPositions;
+    SkShader::TileMode       fTileMode;
 
     GrCoordTransform fCoordTransform;
     GrTextureAccess fTextureAccess;
     SkScalar fYCoord;
     GrTextureStripAtlas* fAtlas;
     int fRow;
     bool fIsOpaque;
     ColorType fColorType;
     PremulType fPremulType; // This is already baked into the table for texture gradients, and
                             // only changes behavior for gradients that don't use a texture.
@@ skipping 65 matching lines @@
     SkScalar fCachedYCoord;
     GrGLSLProgramDataManager::UniformHandle fColorsUni;
     GrGLSLProgramDataManager::UniformHandle fFSYUni;
 
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 
 #endif
 
 #endif