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 "SkCommandLineFlags.h"
 #include "SkData.h"
 #include "SkDocument.h"
 #include "SkGraphics.h"
+#include "SkImage_Base.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"
@@ skipping 142 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);
         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 (kRGBA_F16_SkColorType == win->info().colorType() || fTenBitColor) {
+            // We made an off-screen surface. Get the contents as an SkImage:
+            SkBitmap bm;
+            bm.allocPixels(win->info());
+            canvas->readPixels(&bm, 0, 0);
+            SkPixmap pm;
+            bm.peekPixels(&pm);
+            sk_sp<SkImage> image(SkImage::MakeTextureFromPixmap(fCurContext, pm,
+                                                                SkBudgeted::kNo));
+            GrTexture* texture = as_IB(image)->peekTexture();
+            SkASSERT(texture);
+
+            // With ten-bit output, we need to manually apply the gamma of the output device
+            // (unless we're in non-gamma correct mode, in which case our data is already
+            // fake-sRGB, like we're expected to put in the 10-bit buffer):
+            bool doGamma = fTenBitColor && SkImageInfoIsGammaCorrect(win->info());
+            fCurContext->applyGamma(fCurRenderTarget, texture, doGamma ? 2.2f : 1.0f);
+        } 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);
-            } else if (kRGBA_F16_SkColorType == win->info().colorType()) {
-                SkBitmap bm;
-                bm.allocPixels(win->info());
-                canvas->readPixels(&bm, 0, 0);
-                fCurRenderTarget->writePixels(0, 0, bm.width(), bm.height(),
-                                              SkImageInfo2GrPixelConfig(bm.info(),
+                                              SkImageInfo2GrPixelConfig(bm.colorType(),
+                                                                        bm.alphaType(),
+                                                                        bm.profileType(),
                                                                         *fCurContext->caps()),
                                               bm.getPixels(),
                                               bm.rowBytes(),
                                               GrContext::kFlushWrites_PixelOp);
-            }
+
         }
 #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();
 }