Add sRGB mode toggle to Viewer.

tools/viewer/sk_app/VulkanWindowContext.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContext.h"
 #include "SkSurface.h"
 #include "VulkanWindowContext.h"
 
 #include "vk/GrVkInterface.h"
 #include "vk/GrVkUtil.h"
 #include "vk/GrVkTypes.h"
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 // windows wants to define this as CreateSemaphoreA or CreateSemaphoreW
 #undef CreateSemaphore
 #endif
 
 #define GET_PROC(F) f ## F = (PFN_vk ## F) vkGetInstanceProcAddr(instance, "vk" #F)
 #define GET_DEV_PROC(F) f ## F = (PFN_vk ## F) vkGetDeviceProcAddr(device, "vk" #F)
 
 namespace sk_app {
 
-VulkanWindowContext::VulkanWindowContext(void* platformData, int msaaSampleCount)
+VulkanWindowContext::VulkanWindowContext(void* platformData, const DisplayParams& params)
     : fSurface(VK_NULL_HANDLE)
     , fSwapchain(VK_NULL_HANDLE)
     , fCommandPool(VK_NULL_HANDLE)
     , fBackbuffers(nullptr) {
 
     // any config code here (particularly for msaa)?
 
-    this->initializeContext(platformData);
+    this->initializeContext(platformData, params);
 }
 
-void VulkanWindowContext::initializeContext(void* platformData) {
+void VulkanWindowContext::initializeContext(void* platformData, const DisplayParams& params) {
 
     fBackendContext.reset(GrVkBackendContext::Create(&fPresentQueueIndex, canPresent));
     if (!(fBackendContext->fExtensions & kKHR_surface_GrVkExtensionFlag) ||
         !(fBackendContext->fExtensions & kKHR_swapchain_GrVkExtensionFlag)) {
         fBackendContext.reset(nullptr);
         return;
     }
 
     VkInstance instance = fBackendContext->fInstance;
     VkDevice device = fBackendContext->fDevice;
@@ skipping 18 matching lines @@
 
     VkBool32 supported;
     VkResult res = fGetPhysicalDeviceSurfaceSupportKHR(fBackendContext->fPhysicalDevice,
                                                        fPresentQueueIndex, fSurface,
                                                        &supported);
     if (VK_SUCCESS != res) {
         this->destroyContext();
         return;
     }
 
-    if (!this->createSwapchain(-1, -1)) {
+    if (!this->createSwapchain(-1, -1, params)) {
         this->destroyContext();
         return;
     }
 
     // create presentQueue
     vkGetDeviceQueue(fBackendContext->fDevice, fPresentQueueIndex, 0, &fPresentQueue);
 }
 
-bool VulkanWindowContext::createSwapchain(uint32_t width, uint32_t height) {
+bool VulkanWindowContext::createSwapchain(uint32_t width, uint32_t height,
+                                          const DisplayParams& params) {
     // check for capabilities
     VkSurfaceCapabilitiesKHR caps;
     VkResult res = fGetPhysicalDeviceSurfaceCapabilitiesKHR(fBackendContext->fPhysicalDevice,
                                                             fSurface, &caps);
     if (VK_SUCCESS != res) {
         return false;
     }
 
     uint32_t surfaceFormatCount;
     res = fGetPhysicalDeviceSurfaceFormatsKHR(fBackendContext->fPhysicalDevice, fSurface,
@@ skipping 58 matching lines @@
                                    VK_IMAGE_USAGE_TRANSFER_DST_BIT;
     SkASSERT((caps.supportedUsageFlags & usageFlags) == usageFlags);
     SkASSERT(caps.supportedTransforms & caps.currentTransform);
     SkASSERT(caps.supportedCompositeAlpha & (VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR |
                                              VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR));
     VkCompositeAlphaFlagBitsKHR composite_alpha =
         (caps.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) ?
                                         VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR :
                                         VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
 
-    // Pick our surface format -- for now, the first one
-    VkFormat surfaceFormat = surfaceFormats[0].format;
-    VkColorSpaceKHR colorSpace = surfaceFormats[0].colorSpace;
+    // Pick our surface format. For now, just make sure it matches our sRGB request:
+    VkFormat surfaceFormat = VK_FORMAT_UNDEFINED;
+    VkColorSpaceKHR colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
+    bool wantSRGB = kSRGB_SkColorProfileType == params.fProfileType;
+    for (uint32_t i = 0; i < surfaceFormatCount; ++i) {
+        GrPixelConfig config;
+        if (GrVkFormatToPixelConfig(surfaceFormats[i].format, &config) &&
+            GrPixelConfigIsSRGB(config) == wantSRGB) {
+            surfaceFormat = surfaceFormats[i].format;
+            colorSpace = surfaceFormats[i].colorSpace;
+            break;
+        }
+    }
+    fDisplayParams = params;
+
+    if (VK_FORMAT_UNDEFINED == surfaceFormat) {
+        return false;
+    }
 
     // If mailbox mode is available, use it, as it is the lowest-latency non-
     // tearing mode. If not, fall back to FIFO which is always available.
     VkPresentModeKHR mode = VK_PRESENT_MODE_FIFO_KHR;
     for (uint32_t i = 0; i < presentModeCount; ++i) {
         // use mailbox
         if (VK_PRESENT_MODE_MAILBOX_KHR == presentModes[i]) {
             mode = presentModes[i];
             break;
         }
@@ skipping 67 matching lines @@
         info.fImageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
         info.fImageTiling = VK_IMAGE_TILING_OPTIMAL;
         info.fFormat = format;
         desc.fWidth = fWidth;
         desc.fHeight = fHeight;
         desc.fConfig = fPixelConfig;
         desc.fOrigin = kTopLeft_GrSurfaceOrigin;
         desc.fSampleCnt = 0;
         desc.fStencilBits = 0;
         desc.fRenderTargetHandle = (GrBackendObject) &info;
-        SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
+        SkSurfaceProps props(GrPixelConfigIsSRGB(fPixelConfig)
+                             ? SkSurfaceProps::kGammaCorrect_Flag : 0,
+                             kUnknown_SkPixelGeometry);
         fSurfaces[i] = SkSurface::MakeFromBackendRenderTarget(fContext, desc, &props);
     }
 
     // create the command pool for the command buffers
     if (VK_NULL_HANDLE == fCommandPool) {
         VkCommandPoolCreateInfo commandPoolInfo;
         memset(&commandPoolInfo, 0, sizeof(VkCommandPoolCreateInfo));
         commandPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
         // this needs to be on the render queue
         commandPoolInfo.queueFamilyIndex = fBackendContext->fGraphicsQueueIndex;
@@ skipping 147 matching lines @@
     VkResult res = fAcquireNextImageKHR(fBackendContext->fDevice, fSwapchain, UINT64_MAX,
                                         backbuffer->fAcquireSemaphore, VK_NULL_HANDLE,
                                         &backbuffer->fImageIndex);
     if (VK_ERROR_SURFACE_LOST_KHR == res) {
         // need to figure out how to create a new vkSurface without the platformData*
         // maybe use attach somehow? but need a Window
         return nullptr;
     }
     if (VK_ERROR_OUT_OF_DATE_KHR == res) {
         // tear swapchain down and try again
-        if (!this->createSwapchain(0, 0)) {
+        if (!this->createSwapchain(0, 0, fDisplayParams)) {
             return nullptr;
         }
 
         // acquire the image
         res = fAcquireNextImageKHR(fBackendContext->fDevice, fSwapchain, UINT64_MAX,
                                    backbuffer->fAcquireSemaphore, VK_NULL_HANDLE,
                                    &backbuffer->fImageIndex);
 
         if (VK_SUCCESS != res) {
             return nullptr;
@@ skipping 128 matching lines @@
         &fSwapchain, // pSwapchains
         &backbuffer->fImageIndex, // pImageIndices
         NULL // pResults
     };
 
     fQueuePresentKHR(fPresentQueue, &presentInfo);
 
 }
 
 }   //namespace sk_app