Add 4f linear gradient benches

bench/GradientBench.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "Benchmark.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkGradientShader.h"
+#include "SkLinearGradient.h"
 #include "SkPaint.h"
 #include "SkShader.h"
 #include "SkString.h"
 
 struct GradData {
     int             fCount;
     const SkColor*  fColors;
     const SkScalar* fPos;
     const char*     fName;
 };
@@ skipping 17 matching lines @@
 // try to exercise those here.
 static const GradData gGradData[] = {
     { 2, gColors, nullptr, "" },
     { 50, gColors, nullptr, "_hicolor" }, // many color gradient
     { 3, gColors, nullptr, "_3color" },
     { 2, gShallowColors, nullptr, "_shallow" },
 };
 
 /// Ignores scale
 static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
-                            SkShader::TileMode tm, float scale) {
-    return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos, data.fCount, tm);
+                            SkShader::TileMode tm, float scale, bool force4f) {
+    const uint32_t flags = force4f ? SkLinearGradient::kForce4fContext_PrivateFlag : 0;
+    return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
+                                          data.fCount, tm, flags, nullptr);
 }
 
 static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
-                            SkShader::TileMode tm, float scale) {
+                            SkShader::TileMode tm, float scale, bool force4f) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
     return SkGradientShader::CreateRadial(center, center.fX * scale,
                                           data.fColors,
                                           data.fPos, data.fCount, tm);
 }
 
 /// Ignores scale
 static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
-                           SkShader::TileMode tm, float scale) {
+                           SkShader::TileMode tm, float scale, bool force4f) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
     return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors,
                                          data.fPos, data.fCount);
 }
 
 /// Ignores scale
 static SkShader* MakeConical(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, float scale) {
+                             SkShader::TileMode tm, float scale, bool force4f) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
     center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
     return SkGradientShader::CreateTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7,
                                                    center0, (pts[1].fX - pts[0].fX) / 2,
                                                    data.fColors, data.fPos, data.fCount, tm);
 }
 
 /// Ignores scale
 static SkShader* MakeConicalZeroRad(const SkPoint pts[2], const GradData& data,
-                                    SkShader::TileMode tm, float scale) {
+                                    SkShader::TileMode tm, float scale, bool force4f) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
     center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
     return SkGradientShader::CreateTwoPointConical(center1, 0.0,
                                                    center0, (pts[1].fX - pts[0].fX) / 2,
                                                    data.fColors, data.fPos, data.fCount, tm);
 }
 
 /// Ignores scale
 static SkShader* MakeConicalOutside(const SkPoint pts[2], const GradData& data,
-                                    SkShader::TileMode tm, float scale) {
+                                    SkShader::TileMode tm, float scale, bool force4f) {
     SkPoint center0, center1;
     SkScalar radius0 = (pts[1].fX - pts[0].fX) / 10;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
     center0.set(pts[0].fX + radius0, pts[0].fY + radius0);
     center1.set(pts[1].fX - radius1, pts[1].fY - radius1);
     return SkGradientShader::CreateTwoPointConical(center0, radius0,
                                                    center1, radius1,
                                                    data.fColors, data.fPos,
                                                    data.fCount, tm);
 }
 
 /// Ignores scale
 static SkShader* MakeConicalOutsideZeroRad(const SkPoint pts[2], const GradData& data,
-                                           SkShader::TileMode tm, float scale) {
+                                           SkShader::TileMode tm, float scale, bool force4f) {
     SkPoint center0, center1;
     SkScalar radius0 = (pts[1].fX - pts[0].fX) / 10;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
     center0.set(pts[0].fX + radius0, pts[0].fY + radius0);
     center1.set(pts[1].fX - radius1, pts[1].fY - radius1);
     return SkGradientShader::CreateTwoPointConical(center0, 0.0,
                                                    center1, radius1,
                                                    data.fColors, data.fPos,
                                                    data.fCount, tm);
 }
 
 typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
-                               SkShader::TileMode tm, float scale);
+                               SkShader::TileMode tm, float scale, bool force4f);
 
 static const struct {
     GradMaker   fMaker;
     const char* fName;
 } gGrads[] = {
     { MakeLinear,                 "linear"  },
     { MakeRadial,                 "radial1" },
     { MakeSweep,                  "sweep"   },
     { MakeConical,                "conical" },
     { MakeConicalZeroRad,         "conicalZero" },
@@ skipping 38 matching lines @@
             return "oval";
         default:
             SkDEBUGFAIL("unknown geometry type");
             return "error";
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GradientBench : public Benchmark {
-    SkString fName;
-    SkShader* fShader;
-    bool fDither;
-    enum {
-        W   = 400,
-        H   = 400,
-    };
 public:
-    SkShader* makeShader(GradType gradType, GradData data, SkShader::TileMode tm, float scale) {
-        const SkPoint pts[2] = {
-            { 0, 0 },
-            { SkIntToScalar(W), SkIntToScalar(H) }
-        };
-
-        return gGrads[gradType].fMaker(pts, data, tm, scale);
-    }
-
     GradientBench(GradType gradType,
                   GradData data = gGradData[0],
                   SkShader::TileMode tm = SkShader::kClamp_TileMode,
                   GeomType geomType = kRect_GeomType,
-                  float scale = 1.0f) {
+                  float scale = 1.0f,
+                  bool force4f = false)
+        : fGeomType(geomType) {
+
         fName.printf("gradient_%s_%s", gGrads[gradType].fName,
                      tilemodename(tm));
         if (geomType != kRect_GeomType) {
-            fName.append("_");
-            fName.append(geomtypename(geomType));
+            fName.appendf("_%s", geomtypename(geomType));
         }
 
         if (scale != 1.f) {
             fName.appendf("_scale_%g", scale);
         }
 
         fName.append(data.fName);
 
-        fDither = false;
-        fShader = this->makeShader(gradType, data, tm, scale);
-        fGeomType = geomType;
+        if (force4f) {
+            fName.append("_4f");
+        }
+
+        SkAutoTUnref<SkShader> shader(MakeShader(gradType, data, tm, scale, force4f));
+        this->setupPaint(&fPaint);
+        fPaint.setShader(shader);
     }
 
-    GradientBench(GradType gradType, GradData data, bool dither) {
+    GradientBench(GradType gradType, GradData data, bool dither, bool force4f = false)
+        : fGeomType(kRect_GeomType) {
+
         const char *tmname = tilemodename(SkShader::kClamp_TileMode);
         fName.printf("gradient_%s_%s", gGrads[gradType].fName, tmname);
         fName.append(data.fName);
 
-        fDither = dither;
         if (dither) {
             fName.appendf("_dither");
         }
 
-        fShader = this->makeShader(gradType, data, SkShader::kClamp_TileMode, 1.0f);
-        fGeomType = kRect_GeomType;
-    }
-
-    virtual ~GradientBench() {
-        fShader->unref();
+        SkAutoTUnref<SkShader> shader(
+            MakeShader(gradType, data, SkShader::kClamp_TileMode, 1.0f, force4f));
+        this->setupPaint(&fPaint);
+        fPaint.setShader(shader);
+        fPaint.setDither(dither);
     }
 
 protected:
-    virtual const char* onGetName() {
+    const char* onGetName() override {
         return fName.c_str();
     }
 
-    virtual void onDraw(int loops, SkCanvas* canvas) {
-        SkPaint paint;
-        this->setupPaint(&paint);
+    SkIPoint onGetSize() override {
+        return SkIPoint::Make(kSize, kSize);
+    }
 
-        paint.setShader(fShader);
-        if (fDither) {
-            paint.setDither(true);
-        }
+    void onDraw(int loops, SkCanvas* canvas) override {
+        const SkRect r = SkRect::MakeIWH(kSize, kSize);
 
-        SkRect r = { 0, 0, SkIntToScalar(W), SkIntToScalar(H) };
         for (int i = 0; i < loops; i++) {
             switch (fGeomType) {
                case kRect_GeomType:
-                   canvas->drawRect(r, paint);
+                   canvas->drawRect(r, fPaint);
                    break;
                case kOval_GeomType:
-                   canvas->drawOval(r, paint);
+                   canvas->drawOval(r, fPaint);
                    break;
             }
         }
     }
 
 private:
     typedef Benchmark INHERITED;
 
-    GeomType fGeomType;
+    SkShader* MakeShader(GradType gradType, GradData data,
+                         SkShader::TileMode tm, float scale, bool force4f) {
+        const SkPoint pts[2] = {
+            { 0, 0 },
+            { SkIntToScalar(kSize), SkIntToScalar(kSize) }
+        };
+
+        return gGrads[gradType].fMaker(pts, data, tm, scale, force4f);
+    }
+
+    static const int kSize = 400;
+
+    SkString       fName;
+    SkPaint        fPaint;
+    const GeomType fGeomType;
 };
 
-DEF_BENCH( return new GradientBench(kLinear_GradType); )
+// 4f
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkShader::kClamp_TileMode,
+                                    kRect_GeomType, 1, true); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1], SkShader::kClamp_TileMode,
+                                    kRect_GeomType, 1, true); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2], SkShader::kClamp_TileMode,
+                                    kRect_GeomType, 1, true); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkShader::kRepeat_TileMode,
+                                    kRect_GeomType, 1, true); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1], SkShader::kRepeat_TileMode,
+                                    kRect_GeomType, 1, true); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2], SkShader::kRepeat_TileMode,
+                                    kRect_GeomType, 1, true); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkShader::kMirror_TileMode,
+                                    kRect_GeomType, 1, true); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1], SkShader::kMirror_TileMode,
+                                    kRect_GeomType, 1, true); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2], SkShader::kMirror_TileMode,
+                                    kRect_GeomType, 1, true); )
+
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0]); )
 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1]); )
 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2]); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkShader::kRepeat_TileMode); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1], SkShader::kRepeat_TileMode); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2], SkShader::kRepeat_TileMode); )
 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkShader::kMirror_TileMode); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1], SkShader::kMirror_TileMode); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2], SkShader::kMirror_TileMode); )
 
 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0]); )
 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[1]); )
 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[2]); )
 // Draw a radial gradient of radius 1/2 on a rectangle; half the lines should
 // be completely pinned, the other half should pe partially pinned
 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkShader::kClamp_TileMode, kRect_GeomType, 0.5f); )
 
 // Draw a radial gradient on a circle of equal size; all the lines should
 // hit the unpinned fast path (so long as GradientBench.W == H)
@@ skipping 68 matching lines @@
             canvas->drawRect(r, paint);
         }
     }
 
 private:
     typedef Benchmark INHERITED;
 };
 
 DEF_BENCH( return new Gradient2Bench(false); )
 DEF_BENCH( return new Gradient2Bench(true); )