Simple GPU based dithering

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 "SkBenchmark.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
@@ skipping 16 matching lines @@
     SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
     SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
     SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
     SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
     SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
     SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
     SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
     SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK, // 10 lines, 50 colors
 };
 
+static const SkColor gShallowColors[] = { 0xFF555555, 0xFF444444 };
+
 // We have several special-cases depending on the number (and spacing) of colors, so
 // try to exercise those here.
 static const GradData gGradData[] = {
     { 2, gColors, NULL, "" },
     { 50, gColors, NULL, "_hicolor" }, // many color gradient
     { 3, gColors, NULL, "_3color" },
+    { 2, gShallowColors, NULL, "_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);
 }
 
 static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
                             SkShader::TileMode tm, float scale) {
@@ skipping 140 matching lines @@
             SkDEBUGFAIL("unknown geometry type");
             return "error";
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GradientBench : public SkBenchmark {
     SkString fName;
     SkShader* fShader;
+    bool fDither;
     enum {
         W   = 400,
         H   = 400,
         kRepeat = 15,
     };
 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) {
         fName.printf("gradient_%s_%s", gGrads[gradType].fName,
                      tilemodename(tm));
         if (geomType != kRect_GeomType) {
             fName.append("_");
             fName.append(geomtypename(geomType));
         }
 
         if (scale != 1.f) {
             fName.appendf("_scale_%g", scale);
         }
 
         fName.append(data.fName);
 
-        const SkPoint pts[2] = {
-            { 0, 0 },
-            { SkIntToScalar(W), SkIntToScalar(H) }
-        };
+        fDither = false;
+        fShader = this->makeShader(gradType, data, tm, scale);
+        fGeomType = geomType;
+    }
 
-        fShader = gGrads[gradType].fMaker(pts, data, tm, scale);
-        fGeomType = geomType;
+    GradientBench(GradType gradType, GradData data, bool dither) {
+        const char *tmname = tilemodename(SkShader::kClamp_TileMode);
+        fName.printf("gradient_%s_%s", gGrads[gradType].fName, tmname);
+        fName.append(data.fName);
+
+        if (dither) {
+            fDither = true;
+            fName.appendf("_dither");
+        } else {
+            fDither = false;
+        }
+
+        fShader = this->makeShader(gradType, data, SkShader::kClamp_TileMode, 1.0f);
+        fGeomType = kRect_GeomType;
     }
 
     virtual ~GradientBench() {
         fShader->unref();
     }
 
 protected:
     virtual const char* onGetName() {
         return fName.c_str();
     }
 
     virtual void onDraw(const int loops, SkCanvas* canvas) {
         SkPaint paint;
         this->setupPaint(&paint);
 
         paint.setShader(fShader);
+        if (fDither) {
+            paint.setDither(true);
+        }
 
         SkRect r = { 0, 0, SkIntToScalar(W), SkIntToScalar(H) };
         for (int i = 0; i < loops * kRepeat; i++) {
             switch (fGeomType) {
                case kRect_GeomType:
                    canvas->drawRect(r, paint);
                    break;
                case kOval_GeomType:
                    canvas->drawOval(r, paint);
                    break;
@@ skipping 37 matching lines @@
 DEF_BENCH( return new GradientBench(kConicalZero_GradType); )
 DEF_BENCH( return new GradientBench(kConicalZero_GradType, gGradData[1]); )
 DEF_BENCH( return new GradientBench(kConicalZero_GradType, gGradData[2]); )
 DEF_BENCH( return new GradientBench(kConicalOut_GradType); )
 DEF_BENCH( return new GradientBench(kConicalOut_GradType, gGradData[1]); )
 DEF_BENCH( return new GradientBench(kConicalOut_GradType, gGradData[2]); )
 DEF_BENCH( return new GradientBench(kConicalOutZero_GradType); )
 DEF_BENCH( return new GradientBench(kConicalOutZero_GradType, gGradData[1]); )
 DEF_BENCH( return new GradientBench(kConicalOutZero_GradType, gGradData[2]); )
 
+// Dithering
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[3], true); )
+DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[3], false); )
+DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[3], true); )
+DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[3], false); )
+DEF_BENCH( return new GradientBench(kSweep_GradType, gGradData[3], true); )
+DEF_BENCH( return new GradientBench(kSweep_GradType, gGradData[3], false); )
+DEF_BENCH( return new GradientBench(kConical_GradType, gGradData[3], true); )
+DEF_BENCH( return new GradientBench(kConical_GradType, gGradData[3], false); )
+
 ///////////////////////////////////////////////////////////////////////////////
 
 class Gradient2Bench : public SkBenchmark {
     SkString fName;
     bool     fHasAlpha;
 
 public:
     Gradient2Bench(bool hasAlpha)  {
         fName.printf("gradient_create_%s", hasAlpha ? "alpha" : "opaque");
         fHasAlpha = hasAlpha;
@@ skipping 28 matching lines @@
             canvas->drawRect(r, paint);
         }
     }
 
 private:
     typedef SkBenchmark INHERITED;
 };
 
 DEF_BENCH( return new Gradient2Bench(false); )
 DEF_BENCH( return new Gradient2Bench(true); )