Added --deepColor option to SampleApp, triggers creation of a ten-bit/channel buffer on Windows.

src/gpu/GrContext.cpp

Index: src/gpu/GrContext.cpp
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index a186bd87bc101f1cf9107ccc1903172adf354622..28b59d08044a4db6a8bd8b3b34f0c0ae199253f1 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -20,6 +20,7 @@
 
 #include "batches/GrCopySurfaceBatch.h"
 #include "effects/GrConfigConversionEffect.h"
+#include "effects/GrGammaEffect.h"
 #include "text/GrTextBlobCache.h"
 
 #define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
@@ -529,6 +530,40 @@ bool GrContext::readSurfacePixels(GrSurface* src,
     return true;
 }
 
+bool GrContext::applyGamma(GrRenderTarget* dst, GrTexture* src, SkScalar gamma){
+    ASSERT_SINGLE_OWNER
+    RETURN_FALSE_IF_ABANDONED
+    ASSERT_OWNED_RESOURCE(dst);
+    ASSERT_OWNED_RESOURCE(src);
+    GR_AUDIT_TRAIL_AUTO_FRAME(&fAuditTrail, "GrContext::applyGamma");
+
+    SkSurfaceProps props(SkSurfaceProps::kGammaCorrect_Flag,
+                         SkSurfaceProps::kLegacyFontHost_InitType);
+    sk_sp<GrDrawContext> drawContext(this->drawContext(sk_ref_sp(dst), &props));
+    if (!drawContext) {
+        return false;
+    }
+
+    GrPaint paint;
+    if (SkScalarNearlyEqual(gamma, 1.0f)) {

[bsalomon, 2016/04/29 18:27:20]

Maybe just call copySurface here? Should we also detect the case that the src is
linear and the dst is srgb and the specified gamma was 2.2 and let the hw do it?

[Brian Osman, 2016/05/02 21:02:45]

I tried falling back to copySurface, but that code doesn't enable the
gammaCorrect flag on the deviceContext that it creates. So F16 (offscreen) ->
sRGB (FB0) fails. We pass in gamma 1.0 in that case, expecting the HW to do the
conversion for us. If we use my code, that works (the paint and drawContext are
both flagged gamma correct).

For the second case (detecting other cases where the HW should do the conversion
for us), it's tricky because of the 10-bit case. In that situation, we've
wrapped FB0 in an "sRGB" render target, even though that's only half true. And
when we do the final write, we pass in 2.2, because that's what we need to have
happen. But it's also the case where we need to force the shader to run. The
alternative would be to mark the FB0 render target as non-sRGB in that case, I
guess? That seems like a trap for the unwary user, though.

[bsalomon, 2016/05/02 21:17:40]

Is that what we want copySurface to do? Maybe we should update it to be gamma
correct.
We mark the config of the GrRT that wraps the 10bit surface as sRGB? I was
somewhat assuming "srgb" on GrPixelConfig meant a hw-converted format.

+        paint.addColorTextureProcessor(src, GrCoordTransform::MakeDivByTextureWHMatrix(src));
+    } else {
+        SkAutoTUnref<const GrFragmentProcessor> fp;
+        fp.reset(GrGammaEffect::Create(src, gamma));
+        paint.addColorFragmentProcessor(fp);
+    }
+    paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
+    paint.setGammaCorrect(true);
+
+    SkRect rect;
+    src->getBoundsRect(&rect);
+    drawContext->drawRect(GrClip::WideOpen(), paint, SkMatrix::I(), rect, nullptr);
+
+    this->flushSurfaceWrites(dst);
+
+    return true;
+}
+
 void GrContext::prepareSurfaceForExternalIO(GrSurface* surface) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED