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 737 matching lines @@
     SkASSERT(colorCount > 1);
 
     desc->fColors       = colors;
     desc->fPos          = pos;
     desc->fCount        = colorCount;
     desc->fTileMode     = mode;
     desc->fGradFlags    = flags;
     desc->fLocalMatrix  = localMatrix;
 }
 
+static int simplify(SkScalar* pos, SkColor* colors, int colorCount, SkShader::TileMode mode) {
+    if (pos) {
+        if (3 == colorCount) {
+            // Left-edged hard stop gradients (0, 0, 1) can be simplified
+            // to a 2-color gradient if first two colors are the same
+            if (SkScalarNearlyEqual(pos[0], 0.0f) &&
+                SkScalarNearlyEqual(pos[1], 0.0f) &&
+                SkScalarNearlyEqual(pos[2], 1.0f)) {
+
+                // If the tile mode is repeat or mirror, first color
+                // doesn't matter
+                if (SkShader::kRepeat_TileMode == mode ||
+                    SkShader::kMirror_TileMode == mode ||
+                    colors[0] == colors[1]) {
+
+                    pos[0] = 0.0f;
+                    pos[1] = 1.0f;
+
+                    colors[0] = colors[1];
+                    colors[1] = colors[2];
+
+                    colorCount = 2;

[f(malita), 2016/08/18 22:54:17]

If we fall through here, I think we'll also take the second conditional
unnecessarily (after the optimization, pos is [0, 1, 1]).

I would either return or make the the checks exclusive.

+                }
+            }
+
+            // Right-edged hard stop gradients (0, 1, 1) can be simplified
+            // to a 2-color gradient if last two colors are the same
+            if (SkScalarNearlyEqual(pos[0], 0.0f) &&
+                SkScalarNearlyEqual(pos[1], 1.0f) &&
+                SkScalarNearlyEqual(pos[2], 1.0f)) {
+
+                // If the tile mode is repeat or mirror, last color
+                // doesn't matter
+                if (SkShader::kRepeat_TileMode == mode ||
+                    SkShader::kMirror_TileMode == mode ||
+                    colors[1] == colors[2]) {
+
+                    colorCount = 2;
+                }
+            }
+        }
+    }
+    return colorCount;
+}
+
 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]);
     }
 
+    SkAutoTArray<SkScalar> simplifiedPos(colorCount);
+    SkAutoTArray<SkColor>  simplifiedCol(colorCount);
+    for (int i = 0; i < colorCount; i++) {
+        simplifiedCol[i] = colors[i];
+    }
+    if (pos) {
+        for (int i = 0; i < colorCount; i++) {
+            simplifiedPos[i] = pos[i];
+        }
+        colorCount = simplify(simplifiedPos.get(), simplifiedCol.get(), colorCount, mode);
+    } else {
+        simplifiedPos.reset(0);
+    }

[f(malita), 2016/08/18 22:54:17]

It would be nice to

a) avoid these allocations and copies when the optimization is not applicable
b) only allocate/copy the minimum amount (2), on stack

Can you try refactoring simplify() as a RAII helper, something along these
lines:

struct ColorStopOptimizer {
    
    ColorStopOptimizer(const SkColor* colors, const SkScalar* pos, int count,
SkShader::TileMode mode)
        : fColors(colors)
        , fPos(pos)
        , fCount(count) {

        if (count != 3 || !pos) {
            // the optimization is not applicable, use original data
            return;
        }

        if (<left edge optimization is applicable>) {
            // optimization fired, switch to internal storage
            fColorStorage[0] = colors[1];
            fColorStorage[1] = colors[2];
            fPosStorage[0] = 0;
            fPosStorage[1] = 1;

            fColors = fColorStorage;
            fPos    = fPosStorage;
            fCount  = 2;
        } else if (<right edge optimization is applicable>) {
            ...
        }
    }

    const SkColor*  fColors;
    const SkScalar* fPos;
    int             fCount

    SkColor         fColorStorage[2];
    SkScalar        fPosStorage[2];
}


Then the factories could just do something like this


    ColorStopOptimizer opt(colors, pos, count, mode);
    SkGradientShaderBase::Descriptor desc;
    desc_init(&desc, opt.fColors, opt.fPos, opt.fCount, mode, flags,
localMatrix);

+
     SkGradientShaderBase::Descriptor desc;
-    desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix);
+    desc_init(&desc, simplifiedCol.get(), simplifiedPos.get(), colorCount, 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]);
     }
 
+    SkAutoTArray<SkScalar> simplifiedPos(colorCount);
+    SkAutoTArray<SkColor>  simplifiedCol(colorCount);
+    for (int i = 0; i < colorCount; i++) {
+        simplifiedCol[i] = colors[i];
+    }
+    if (pos) {
+        for (int i = 0; i < colorCount; i++) {
+            simplifiedPos[i] = pos[i];
+        }
+        colorCount = simplify(simplifiedPos.get(), simplifiedCol.get(), colorCount, mode);
+    } else {
+        simplifiedPos.reset(0);
+    }
+
     SkGradientShaderBase::Descriptor desc;
-    desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix);
+    desc_init(&desc, simplifiedCol.get(), simplifiedPos.get(), colorCount, 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();
         }
     }
     if (1 == colorCount) {
         return SkShader::MakeColorShader(colors[0]);
     }
 
+    SkAutoTArray<SkScalar> simplifiedPos(colorCount);
+    SkAutoTArray<SkColor>  simplifiedCol(colorCount);
+    for (int i = 0; i < colorCount; i++) {
+        simplifiedCol[i] = colors[i];
+    }
+    if (pos) {
+        for (int i = 0; i < colorCount; i++) {
+            simplifiedPos[i] = pos[i];
+        }
+        colorCount = simplify(simplifiedPos.get(), simplifiedCol.get(), colorCount, mode);
+    } else {
+        simplifiedPos.reset(0);
+    }
+
     bool flipGradient = startRadius > endRadius;
 
     SkGradientShaderBase::Descriptor desc;
 
     if (!flipGradient) {
-        desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix);
+        desc_init(&desc, simplifiedCol.get(), simplifiedPos.get(), colorCount, 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] = simplifiedCol[colorCount - i - 1];
         }
 
         if (pos) {
             for (int i = 0; i < colorCount; ++i) {
-                posNew[i] = 1 - pos[colorCount - i - 1];
+                posNew[i] = 1 - simplifiedPos[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]);
     }
 
+    SkAutoTArray<SkScalar> simplifiedPos(colorCount);
+    SkAutoTArray<SkColor>  simplifiedCol(colorCount);
+    for (int i = 0; i < colorCount; i++) {
+        simplifiedCol[i] = colors[i];
+    }
+    auto mode = SkShader::kClamp_TileMode; // Bogus tilemode
+    if (pos) {
+        for (int i = 0; i < colorCount; i++) {
+            simplifiedPos[i] = pos[i];
+        }
+        colorCount = simplify(simplifiedPos.get(), simplifiedCol.get(), colorCount, mode);
+    } else {
+        simplifiedPos.reset(0);
+    }
+
     SkGradientShaderBase::Descriptor desc;
-    desc_init(&desc, colors, pos, colorCount, SkShader::kClamp_TileMode, flags, localMatrix);
+    desc_init(&desc, simplifiedCol.get(), simplifiedPos.get(), colorCount, 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