Simple GPU based dithering

src/gpu/SkGr.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGr.h"
 #include "SkColorFilter.h"
 #include "SkConfig8888.h"
 #include "SkData.h"
 #include "SkMessageBus.h"
 #include "SkPixelRef.h"
 #include "GrResourceCache.h"
 #include "GrGpu.h"
+#include "effects/GrDitherEffect.h"
 #include "GrDrawTargetCaps.h"
 
 #ifndef SK_IGNORE_ETC1_SUPPORT
 #  include "ktx.h"
 #  include "etc1.h"
 #endif
 
 /*  Fill out buffer with the compressed format Ganesh expects from a colortable
  based bitmap. [palette (colortable) + indices].
 
@@ skipping 425 matching lines @@
         if (constantColor) {
             SkColor filtered = colorFilter->filterColor(skPaint.getColor());
             grPaint->setColor(SkColor2GrColor(filtered));
         } else {
             SkAutoTUnref<GrEffectRef> effect(colorFilter->asNewEffect(context));
             if (NULL != effect.get()) {
                 grPaint->addColorEffect(effect);
             }
         }
     }
+
+#ifndef SK_IGNORE_GPU_DITHER
+    // If the dither flag is set, then we need to see if the underlying context
+    // supports it. If not, then install a dither effect.
+    if (skPaint.isDither()) {
+        // What are we rendering into?
+        const GrRenderTarget *target = context->getRenderTarget();
+        if (NULL == target) {

[bsalomon, 2014/06/12 16:24:11]

I'd like to understand how this happens. Falling back to the draw state's RT
doesn't seem right.

+            target = context->getGpu()->getDrawState().getRenderTarget();
+        }
+
+        if (NULL != target &&
+            (target->config() == kRGBA_8888_GrPixelConfig ||
+             target->config() == kBGRA_8888_GrPixelConfig)) {
+            // The dither flag is set and the target is likely
+            // not going to be dithered by the GPU.
+            SkAutoTUnref<GrEffectRef> effect(GrDitherEffect::Create());
+            if (NULL != effect.get()) {
+                grPaint->addColorEffect(effect);
+                grPaint->setDither(false);
+            }
+        }
+    }
+#endif
 }
 
 /**
  * Unlike GrContext::AutoMatrix, this doesn't require setting a new matrix. GrContext::AutoMatrix
  * likes to set the new matrix in its constructor because it is usually necessary to simulataneously
  * update a GrPaint. This AutoMatrix is used while initially setting up GrPaint, however.
  */
 class AutoMatrix {
 public:
     AutoMatrix(GrContext* context) {
@@ skipping 31 matching lines @@
     GrEffectRef* grEffect = NULL;
     if (shader->asNewEffect(context, skPaint, NULL, &grColor, &grEffect) && NULL != grEffect) {
         SkAutoTUnref<GrEffectRef> effect(grEffect);
         grPaint->addColorEffect(effect);
         constantColor = false;
     }
     // The grcolor is automatically set when calling asneweffect.
     // If the shader can be seen as an effect it returns true and adds its effect to the grpaint.
     SkPaint2GrPaintNoShader(context, skPaint, grColor, constantColor, grPaint);
 }