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

samplecode/SampleApp.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 "SampleApp.h"
 
 #include "OverView.h"
 #include "Resources.h"
 #include "SampleCode.h"
 #include "SkAnimTimer.h"
 #include "SkCanvas.h"
+#include "SkColorSpace.h"
 #include "SkCommandLineFlags.h"
 #include "SkData.h"
 #include "SkDocument.h"
 #include "SkGraphics.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkPaint.h"
 #include "SkPaintFilterCanvas.h"
 #include "SkPicture.h"
 #include "SkPictureRecorder.h"
 #include "SkPM4fPriv.h"
 #include "SkStream.h"
 #include "SkSurface.h"
 #include "SkTemplates.h"
 #include "SkTSort.h"
 #include "SkTime.h"
 #include "SkTypeface.h"
 #include "SkWindow.h"
 #include "sk_tool_utils.h"
 
 #if SK_SUPPORT_GPU
 #   include "gl/GrGLInterface.h"
 #   include "gl/GrGLUtil.h"
 #   include "GrRenderTarget.h"
+#   include "effects/GrColorSpaceEffect.h"
 #   include "GrContext.h"
+#   include "GrDrawContext.h"
 #   include "SkGr.h"
 #   if SK_ANGLE
 #       include "gl/angle/GLTestContext_angle.h"
 #   endif
 #else
 class GrContext;
 #endif
 
 const struct {
     SkColorType         fColorType;
@@ skipping 121 matching lines @@
 
 class SampleWindow::DefaultDeviceManager : public SampleWindow::DeviceManager {
 public:
 
     DefaultDeviceManager() {
 #if SK_SUPPORT_GPU
         fCurContext = nullptr;
         fCurIntf = nullptr;
         fCurRenderTarget = nullptr;
         fMSAASampleCount = 0;
+        fTenBitColor = false;
 #endif
         fBackend = kNone_BackEndType;
     }
 
     virtual ~DefaultDeviceManager() {
 #if SK_SUPPORT_GPU
         SkSafeUnref(fCurContext);
         SkSafeUnref(fCurIntf);
         SkSafeUnref(fCurRenderTarget);
 #endif
     }
 
-    void setUpBackend(SampleWindow* win, int msaaSampleCount) override {
+    void setUpBackend(SampleWindow* win, int msaaSampleCount, bool tenBitColor) override {
         SkASSERT(kNone_BackEndType == fBackend);
 
         fBackend = kNone_BackEndType;
 
 #if SK_SUPPORT_GPU
         switch (win->getDeviceType()) {
             case kRaster_DeviceType:    // fallthrough
             case kGPU_DeviceType:
                 // all these guys use the native backend
                 fBackend = kNativeGL_BackEndType;
                 break;
 #if SK_ANGLE
             case kANGLE_DeviceType:
                 // ANGLE is really the only odd man out
                 fBackend = kANGLE_BackEndType;
                 break;
 #endif // SK_ANGLE
 #if SK_COMMAND_BUFFER
             case kCommandBuffer_DeviceType:
                 // Command buffer is really the only other odd man out :D
                 fBackend = kCommandBuffer_BackEndType;
                 break;
 #endif // SK_COMMAND_BUFFER
             default:
                 SkASSERT(false);
                 break;
         }
         AttachmentInfo attachmentInfo;
-        bool result = win->attach(fBackend, msaaSampleCount, &attachmentInfo);
+        bool result = win->attach(fBackend, msaaSampleCount, tenBitColor, &attachmentInfo);

[Brian Osman, 2016/04/27 19:55:01]

Seems like I should add fColorBits to AttachmentInfo, so we can determine if we
actually got a 10 bpc window back?

         if (!result) {
             SkDebugf("Failed to initialize GL");
             return;
         }
         fMSAASampleCount = msaaSampleCount;
+        fTenBitColor = tenBitColor;
 
         SkASSERT(nullptr == fCurIntf);
         SkAutoTUnref<const GrGLInterface> glInterface;
         switch (win->getDeviceType()) {
             case kRaster_DeviceType:    // fallthrough
             case kGPU_DeviceType:
                 // all these guys use the native interface
                 glInterface.reset(GrGLCreateNativeInterface());
                 break;
 #if SK_ANGLE
@@ skipping 49 matching lines @@
         fCurRenderTarget = nullptr;
 #endif
         win->release();
         fBackend = kNone_BackEndType;
     }
 
     SkSurface* createSurface(SampleWindow::DeviceType dType, SampleWindow* win) override {
 #if SK_SUPPORT_GPU
         if (IsGpuDeviceType(dType) && fCurContext) {
             SkSurfaceProps props(win->getSurfaceProps());
-            if (kRGBA_F16_SkColorType == win->info().colorType()) {
+            if (kRGBA_F16_SkColorType == win->info().colorType() || fTenBitColor) {
                 // Need to make an off-screen F16 surface - the current render target is
-                // (probably) the wrong format.
+                // (probably) the wrong format. If we're using a 10-bit surface, we definitely
+                // need an off-screen surface, because 10-bit behaves strangely wrt gamma.
                 return SkSurface::MakeRenderTarget(fCurContext, SkBudgeted::kNo, win->info(),
                                                    fMSAASampleCount, &props).release();
             } else {
                 return SkSurface::MakeRenderTargetDirect(fCurRenderTarget, &props).release();
             }
         }
 #endif
         return nullptr;
     }
 
     void publishCanvas(SampleWindow::DeviceType dType,
                        SkCanvas* canvas, SampleWindow* win) override {
 #if SK_SUPPORT_GPU
         if (fCurContext) {
             // in case we have queued drawing calls
             fCurContext->flush();
 
-            if (!IsGpuDeviceType(dType)) {
+            if (fTenBitColor) {
+                SkBitmap bm;
+                bm.allocPixels(win->info());
+                canvas->readPixels(&bm, 0, 0);

[Brian Osman, 2016/04/27 19:55:01]

This is really ugly, but I couldn't find a way to get from SkCanvas to any of
the "modern" types (SkSurface or SkImage)? The canvas is attached to the surface
we created above, but we've lost that reference, and can't get it back. Surface
has makeImageSnapshot, but that's it. So yeah - this code is stuck going through
SkBitmap and readPixels...

Another option is to alter the signatures of functions on SkView, so we pass the
surface in addition to (or instead of) the canvas, but that's somewhat
invasive...

[bsalomon, 2016/04/27 20:28:24]

My gut take is that this adds too much technical debt
(writePixelsWithColorSpace) than is justified by the end result of making
SampleApp work with ten bit. I think we should push harder on making it possible
to get a SkImage here. Even conceding that we can't directly get a SkImage from
the canvas, taking bm and here and wrapping it via
SkImage::MakeTextureFromPixmap and then having something like a

GrTexture* GrContext::applyColorSpace(GrTexture*, colorSpace)

function would be a big improvement.

+                if (SkImageInfoIsGammaCorrect(win->info())) {
+                    // For now, assuming source and destination are both sRGB.
+                    // TODO: Fetch destination space from device, or allow it to be specified
+                    //       on the command line, etc...
+                    sk_sp<SkColorSpace> srgb(SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named));
+
+                    fCurRenderTarget->writePixelsWithColorSpace(
+                        0, 0, bm.width(), bm.height(),
+                        SkImageInfo2GrPixelConfig(bm.info(), *fCurContext->caps()),
+                        srgb.get(), srgb.get(), bm.getPixels(), bm.rowBytes(),
+                        GrContext::kManualDstGamma_ColorSpaceOpsFlag);
+                } else {
+                    // We rendered to L32 (legacy mode). That matches the semantics of the windowing
+                    // system's 10-bit buffer (data is treated as sRGB, but not gamma-corrected on
+                    // write). We can just do a writePixels, which is just a copy of values.
+                    fCurRenderTarget->writePixels(0, 0, bm.width(), bm.height(),
+                                                  SkImageInfo2GrPixelConfig(bm.info(),
+                                                                            *fCurContext->caps()),
+                                                  bm.getPixels(),
+                                                  bm.rowBytes(),
+                                                  GrContext::kFlushWrites_PixelOp);
+                }
+            } else if (!IsGpuDeviceType(dType)) {
                 // need to send the raster bits to the (gpu) window
                 const SkBitmap& bm = win->getBitmap();
                 fCurRenderTarget->writePixels(0, 0, bm.width(), bm.height(),
                                              SkImageInfo2GrPixelConfig(bm.colorType(),
                                                                        bm.alphaType(),
                                                                        bm.profileType(),
                                                                        *fCurContext->caps()),
                                              bm.getPixels(),
                                              bm.rowBytes(),
                                              GrContext::kFlushWrites_PixelOp);
@@ skipping 11 matching lines @@
         }
 #endif
 
         win->present();
     }
 
     void windowSizeChanged(SampleWindow* win) override {
 #if SK_SUPPORT_GPU
         if (fCurContext) {
             AttachmentInfo attachmentInfo;
-            win->attach(fBackend, fMSAASampleCount, &attachmentInfo);
+            win->attach(fBackend, fMSAASampleCount, fTenBitColor, &attachmentInfo);
             SkSafeUnref(fCurRenderTarget);
             fCurRenderTarget = win->renderTarget(attachmentInfo, fCurIntf, fCurContext);
         }
 #endif
     }
 
     GrContext* getGrContext() override {
 #if SK_SUPPORT_GPU
         return fCurContext;
 #else
         return nullptr;
 #endif
     }
 
     GrRenderTarget* getGrRenderTarget() override {
 #if SK_SUPPORT_GPU
         return fCurRenderTarget;
 #else
         return nullptr;
 #endif
     }
 
 private:
 
 #if SK_SUPPORT_GPU
     GrContext*              fCurContext;
     const GrGLInterface*    fCurIntf;
     GrRenderTarget*         fCurRenderTarget;
     int fMSAASampleCount;
+    bool fTenBitColor;
 #endif
 
     SkOSWindow::SkBackEndTypes fBackend;
 
     typedef SampleWindow::DeviceManager INHERITED;
 };
 
 ///////////////
 static const char view_inval_msg[] = "view-inval-msg";
 
@@ skipping 377 matching lines @@
             newCount += 1;
         }
     }
     if (newCount) {
         factories.setCount(newCount);
     }
 }
 
 DEFINE_string(slide, "", "Start on this sample.");
 DEFINE_int32(msaa, 0, "Request multisampling with this count.");
+DEFINE_bool(tenBit, false, "Request 10-bit/channel display buffer.");
 DEFINE_string(pictureDir, "", "Read pictures from here.");
 DEFINE_string(picture, "", "Path to single picture.");
 DEFINE_string(sequence, "", "Path to file containing the desired samples/gms to show.");
 DEFINE_bool(sort, false, "Sort samples by title.");
 DEFINE_bool(list, false, "List samples?");
 DEFINE_bool(gpu, false, "Start up with gpu?");
 DEFINE_bool(redraw, false, "Force continuous redrawing, for profiling or debugging tools.");
 DEFINE_string(key, "", "");  // dummy to enable gm tests that have platform-specific names
 #ifdef SAMPLE_PDF_FILE_VIEWER
 DEFINE_string(pdfPath, "", "Path to direcotry of pdf files.");
@@ skipping 68 matching lines @@
 
     if (!FLAGS_slide.isEmpty()) {
         fCurrIndex = findByTitle(FLAGS_slide[0]);
         if (fCurrIndex < 0) {
             fprintf(stderr, "Unknown sample \"%s\"\n", FLAGS_slide[0]);
             listTitles();
         }
     }
 
     fMSAASampleCount = FLAGS_msaa;
+    fTenBitColor = FLAGS_tenBit;
 
     if (FLAGS_list) {
         listTitles();
     }
 
     if (fCurrIndex < 0) {
         SkString title;
         if (readTitleFromPrefs(&title)) {
             fCurrIndex = findByTitle(title.c_str());
         }
@@ skipping 142 matching lines @@
     this->setClipToBounds(false);
 
     this->loadView((*fSamples[fCurrIndex])());
 
     if (nullptr == devManager) {
         fDevManager = new DefaultDeviceManager();
     } else {
         devManager->ref();
         fDevManager = devManager;
     }
-    fDevManager->setUpBackend(this, fMSAASampleCount);
+    fDevManager->setUpBackend(this, fMSAASampleCount, fTenBitColor);
 
     // If another constructor set our dimensions, ensure that our
     // onSizeChange gets called.
     if (this->height() && this->width()) {
         this->onSizeChange();
     }
 
     // can't call this synchronously, since it may require a subclass to
     // to implement, or the caller may need us to have returned from the
     // constructor first. Hence we post an event to ourselves.
@@ skipping 803 matching lines @@
     }
     return this->INHERITED::onHandleChar(uni);
 }
 
 void SampleWindow::setDeviceType(DeviceType type) {
     if (type == fDeviceType)
         return;
 
     fDevManager->tearDownBackend(this);
     fDeviceType = type;
-    fDevManager->setUpBackend(this, fMSAASampleCount);
+    fDevManager->setUpBackend(this, fMSAASampleCount, fTenBitColor);
 
     this->updateTitle();
     this->inval(nullptr);
 }
 
 void SampleWindow::setDeviceColorType(SkColorType ct, SkColorProfileType pt) {
     this->setColorType(ct, pt);
 
     fDevManager->tearDownBackend(this);
-    fDevManager->setUpBackend(this, fMSAASampleCount);
+    fDevManager->setUpBackend(this, fMSAASampleCount, fTenBitColor);
 
     this->updateTitle();
     this->inval(nullptr);
 }
 
 void SampleWindow::toggleSlideshow() {
     fAnimating = !fAnimating;
     this->postAnimatingEvent();
     this->updateTitle();
 }
 
 void SampleWindow::toggleRendering() {
     this->setDeviceType(cycle_devicetype(fDeviceType));
     this->updateTitle();
     this->inval(nullptr);
 }
 
 void SampleWindow::toggleFPS() {
     fMeasureFPS = !fMeasureFPS;
     this->updateTitle();
     this->inval(nullptr);
 }
 
 void SampleWindow::toggleDistanceFieldFonts() {
     // reset backend
     fDevManager->tearDownBackend(this);
-    fDevManager->setUpBackend(this, fMSAASampleCount);
+    fDevManager->setUpBackend(this, fMSAASampleCount, fTenBitColor);
 
     SkSurfaceProps props = this->getSurfaceProps();
     uint32_t flags = props.flags() ^ SkSurfaceProps::kUseDeviceIndependentFonts_Flag;
     this->setSurfaceProps(SkSurfaceProps(flags, props.pixelGeometry()));
 
     this->updateTitle();
     this->inval(nullptr);
 }
 
 void SampleWindow::setPixelGeometry(int pixelGeometryIndex) {
     // reset backend
     fDevManager->tearDownBackend(this);
-    fDevManager->setUpBackend(this, fMSAASampleCount);
+    fDevManager->setUpBackend(this, fMSAASampleCount, fTenBitColor);
 
     const SkSurfaceProps& oldProps = this->getSurfaceProps();
     SkSurfaceProps newProps(oldProps.flags(), SkSurfaceProps::kLegacyFontHost_InitType);
     if (pixelGeometryIndex > 0) {
         newProps = SkSurfaceProps(oldProps.flags(),
                                   gPixelGeometryStates[pixelGeometryIndex].pixelGeometry);
     }
     this->setSurfaceProps(newProps);
 
     this->updateTitle();
@@ skipping 244 matching lines @@
         fDevManager &&
         fDevManager->getGrRenderTarget() &&
         fDevManager->getGrRenderTarget()->numColorSamples() > 0) {
         title.appendf(" [MSAA: %d]",
                        fDevManager->getGrRenderTarget()->numColorSamples());
     }
 #endif
 
     title.appendf(" %s", find_config_name(this->info()));
 
+    if (fTenBitColor) {
+        title.append(" 10 bpc");
+    }
+
     if (gTreatSkColorAsSRGB) {
         title.append(" sRGB");
     }
 
     this->setTitle(title.c_str());
 }
 
 void SampleWindow::onSizeChange() {
     this->INHERITED::onSizeChange();
 
@@ skipping 226 matching lines @@
 #ifdef SK_BUILD_FOR_MAC
     setenv("ANDROID_ROOT", "/android/device/data", 0);
 #endif
     SkGraphics::Init();
     SkEvent::Init();
 }
 
 void application_term() {
     SkEvent::Term();
 }