Implement gradient simplification for 0,0,1 and 0,1,1 gradients

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"
@@ skipping 749 matching lines @@
      SkColor tmp[2];                         \
      do {                                    \
          if (1 == count) {                   \
              tmp[0] = tmp[1] = colors[0];    \
              colors = tmp;                   \
              pos = nullptr;                  \
              count = 2;                      \
          }                                   \
      } while (0)
 
+struct ColorStopOptimizer {
+    ColorStopOptimizer(const SkColor* colors, const SkScalar* pos,
+                       int count, SkShader::TileMode mode)
+        : fColors(colors)
+        , fPos(pos)
+        , fCount(count) {
+
+            if (count != 3) {

[f(malita), 2016/08/19 15:26:20]

We should also bail here if pos is null (which I think is a legal factory
value).

+                return;
+            }
+
+            if (SkScalarNearlyEqual(pos[0], 0.0f) &&
+                SkScalarNearlyEqual(pos[1], 0.0f) &&
+                SkScalarNearlyEqual(pos[2], 1.0f)) {
+
+                if (SkShader::kRepeat_TileMode == mode ||
+                    SkShader::kMirror_TileMode == mode ||
+                    colors[0] == colors[1]) {
+
+                    fColorStorage[0] = colors[1];
+                    fColorStorage[1] = colors[2];
+                    fPosStorage[0] = 0.0f;
+                    fPosStorage[1] = 1.0f;
+
+                    fColors = fColorStorage;
+                    fPos    = fPosStorage;
+                    fCount  = 2;
+                }
+            } else if (SkScalarNearlyEqual(pos[0], 0.0f) &&
+                       SkScalarNearlyEqual(pos[1], 1.0f) &&
+                       SkScalarNearlyEqual(pos[2], 1.0f)) {
+
+                if (SkShader::kRepeat_TileMode == mode ||
+                    SkShader::kMirror_TileMode == mode ||
+                    colors[1] == colors[2]) {
+
+                    fCount  = 2;
+                }
+            }
+    }
+
+    const SkColor*  fColors;
+    const SkScalar* fPos;
+    int             fCount;
+
+    SkColor         fColorStorage[2];
+    SkScalar        fPosStorage[2];
+};
+
 sk_sp<SkShader> SkGradientShader::MakeLinear(const SkPoint pts[2],
-                                         const SkColor colors[],
-                                         const SkScalar pos[], int colorCount,
-                                         SkShader::TileMode mode,
-                                         uint32_t flags,
-                                         const SkMatrix* localMatrix) {
+                                             const SkColor colors[],
+                                             const SkScalar pos[], int colorCount,
+                                             SkShader::TileMode mode,
+                                             uint32_t flags,
+                                             const SkMatrix* localMatrix) {
     if (!pts || !SkScalarIsFinite((pts[1] - pts[0]).length())) {
         return nullptr;
     }
     if (!valid_grad(colors, pos, colorCount, mode)) {
         return nullptr;
     }
     if (1 == colorCount) {
         return SkShader::MakeColorShader(colors[0]);
     }
 
+    ColorStopOptimizer opt(colors, pos, colorCount, mode);
+
     SkGradientShaderBase::Descriptor desc;
-    desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix);
+    desc_init(&desc, opt.fColors, opt.fPos, opt.fCount, mode, flags, localMatrix);
     return sk_make_sp<SkLinearGradient>(pts, desc);
 }
 
 sk_sp<SkShader> SkGradientShader::MakeRadial(const SkPoint& center, SkScalar radius,
                                          const SkColor colors[],
                                          const SkScalar pos[], int colorCount,
                                          SkShader::TileMode mode,
                                          uint32_t flags,
                                          const SkMatrix* localMatrix) {
     if (radius <= 0) {
         return nullptr;
     }
     if (!valid_grad(colors, pos, colorCount, mode)) {
         return nullptr;
     }
     if (1 == colorCount) {
         return SkShader::MakeColorShader(colors[0]);
     }
 
+    ColorStopOptimizer opt(colors, pos, colorCount, mode);
+
     SkGradientShaderBase::Descriptor desc;
-    desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix);
+    desc_init(&desc, opt.fColors, opt.fPos, opt.fCount, mode, flags, localMatrix);
     return sk_make_sp<SkRadialGradient>(center, radius, desc);
 }
 
 sk_sp<SkShader> SkGradientShader::MakeTwoPointConical(const SkPoint& start,
                                                   SkScalar startRadius,
                                                   const SkPoint& end,
                                                   SkScalar endRadius,
                                                   const SkColor colors[],
                                                   const SkScalar pos[],
                                                   int colorCount,
                                                   SkShader::TileMode mode,
                                                   uint32_t flags,
                                                   const SkMatrix* localMatrix) {
     if (startRadius < 0 || endRadius < 0) {
         return nullptr;
     }
     if (!valid_grad(colors, pos, colorCount, mode)) {
         return nullptr;
     }
     if (startRadius == endRadius) {
         if (start == end || startRadius == 0) {
             return SkShader::MakeEmptyShader();
         }
     }
     EXPAND_1_COLOR(colorCount);
 
+    ColorStopOptimizer opt(colors, pos, colorCount, mode);
+
     bool flipGradient = startRadius > endRadius;
 
     SkGradientShaderBase::Descriptor desc;
 
     if (!flipGradient) {
-        desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix);
+        desc_init(&desc, opt.fColors, opt.fPos, opt.fCount, mode, flags, localMatrix);
         return sk_make_sp<SkTwoPointConicalGradient>(start, startRadius, end, endRadius,
                                                      flipGradient, desc);
     } else {
         SkAutoSTArray<8, SkColor> colorsNew(colorCount);
         SkAutoSTArray<8, SkScalar> posNew(colorCount);
         for (int i = 0; i < colorCount; ++i) {
-            colorsNew[i] = colors[colorCount - i - 1];
+            colorsNew[i] = opt.fColors[colorCount - i - 1];
         }
 
         if (pos) {
             for (int i = 0; i < colorCount; ++i) {
-                posNew[i] = 1 - pos[colorCount - i - 1];
+                posNew[i] = 1 - opt.fPos[colorCount - i - 1];
             }
             desc_init(&desc, colorsNew.get(), posNew.get(), colorCount, mode, flags, localMatrix);
         } else {
             desc_init(&desc, colorsNew.get(), nullptr, colorCount, mode, flags, localMatrix);
         }
 
         return sk_make_sp<SkTwoPointConicalGradient>(end, endRadius, start, startRadius,
                                                      flipGradient, desc);
     }
 }
 
 sk_sp<SkShader> SkGradientShader::MakeSweep(SkScalar cx, SkScalar cy,
                                         const SkColor colors[],
                                         const SkScalar pos[],
                                         int colorCount,
                                         uint32_t flags,
                                         const SkMatrix* localMatrix) {
     if (!valid_grad(colors, pos, colorCount, SkShader::kClamp_TileMode)) {
         return nullptr;
     }
     if (1 == colorCount) {
         return SkShader::MakeColorShader(colors[0]);
     }
 
+    auto mode = SkShader::kClamp_TileMode;
+
+    ColorStopOptimizer opt(colors, pos, colorCount, mode);
+
     SkGradientShaderBase::Descriptor desc;
-    desc_init(&desc, colors, pos, colorCount, SkShader::kClamp_TileMode, flags, localMatrix);
+    desc_init(&desc, opt.fColors, opt.fPos, opt.fCount, mode, flags, localMatrix);
     return sk_make_sp<SkSweepGradient>(cx, cy, desc);
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkGradientShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLinearGradient)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkRadialGradient)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSweepGradient)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointConicalGradient)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
@@ skipping 543 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