Revise WSI setup.

tools/vulkan/VulkanTestContext.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 "VulkanTestContext.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)
+
 VulkanTestContext::VulkanTestContext(void* platformData, int msaaSampleCount) 
                                  : fSurface(VK_NULL_HANDLE)
                                  , fSwapchain(VK_NULL_HANDLE)
                                  , fCommandPool(VK_NULL_HANDLE)
                                  , fBackbuffers(nullptr) {
 
     // any config code here (particularly for msaa)?
 
     this->initializeContext(platformData);
 }
 
 void VulkanTestContext::initializeContext(void* platformData) {
 
-    fBackendContext.reset(GrVkBackendContext::Create());
+    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;
+    GET_PROC(DestroySurfaceKHR);
+    GET_PROC(GetPhysicalDeviceSurfaceSupportKHR);
+    GET_PROC(GetPhysicalDeviceSurfaceCapabilitiesKHR);
+    GET_PROC(GetPhysicalDeviceSurfaceFormatsKHR);
+    GET_PROC(GetPhysicalDeviceSurfacePresentModesKHR);
+    GET_DEV_PROC(CreateSwapchainKHR);
+    GET_DEV_PROC(DestroySwapchainKHR);
+    GET_DEV_PROC(GetSwapchainImagesKHR);
+    GET_DEV_PROC(AcquireNextImageKHR);
+    GET_DEV_PROC(QueuePresentKHR);
 
     fContext = GrContext::Create(kVulkan_GrBackend, (GrBackendContext)fBackendContext.get());
 
-    fSurface = createVkSurface(platformData);
+    fSurface = createVkSurface(instance, platformData);
     if (VK_NULL_HANDLE == fSurface) {
         fBackendContext.reset(nullptr);
         return;
     }
 
     // query to get the initial queue props size
     uint32_t queueCount;
     GR_VK_CALL(fBackendContext->fInterface, 
                GetPhysicalDeviceQueueFamilyProperties(fBackendContext->fPhysicalDevice, &queueCount,
                                                       nullptr));
     SkASSERT(queueCount >= 1);
 
     SkAutoMalloc queuePropsAlloc(queueCount * sizeof(VkQueueFamilyProperties));
     // now get the actual queue props
     VkQueueFamilyProperties* queueProps = (VkQueueFamilyProperties*)queuePropsAlloc.get();
 
     GR_VK_CALL(fBackendContext->fInterface,
                GetPhysicalDeviceQueueFamilyProperties(fBackendContext->fPhysicalDevice, &queueCount,
                                                       queueProps));
 
-    // iterate to find the present queue
-    fPresentQueueIndex = -1;
-    for (uint32_t i = 0; i < queueCount; i++) {
-        if ((queueProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) && canPresent(i)) {
-            fPresentQueueIndex = i;
-            break;
-        }
-    }
-    SkASSERT(fPresentQueueIndex < queueCount);
-
     VkBool32 supported;
-    VkResult res = GR_VK_CALL(fBackendContext->fInterface,
-                              GetPhysicalDeviceSurfaceSupportKHR(fBackendContext->fPhysicalDevice,
-                                                                 fPresentQueueIndex,
-                                                                 fSurface,
-                                                                 &supported));
+    VkResult res = fGetPhysicalDeviceSurfaceSupportKHR(fBackendContext->fPhysicalDevice,
+                                                       fPresentQueueIndex, fSurface,
+                                                       &supported);
     if (VK_SUCCESS != res) {
         this->destroyContext();
         return;
     }
 
     if (!this->createSwapchain(-1, -1)) {
         this->destroyContext();
         return;
     }
 
     // create presentQueue
     vkGetDeviceQueue(fBackendContext->fDevice, fPresentQueueIndex, 0, &fPresentQueue);
-
-
 }
 
 bool VulkanTestContext::createSwapchain(uint32_t width, uint32_t height)
 {
     // check for capabilities
     VkSurfaceCapabilitiesKHR caps;
-    VkResult res = GR_VK_CALL(fBackendContext->fInterface,
-                           GetPhysicalDeviceSurfaceCapabilitiesKHR(fBackendContext->fPhysicalDevice,
-                                                                   fSurface,
-                                                                   &caps));
+    VkResult res = fGetPhysicalDeviceSurfaceCapabilitiesKHR(fBackendContext->fPhysicalDevice,
+                                                            fSurface, &caps);
     if (VK_SUCCESS != res) {
         return false;
     }
 
     uint32_t surfaceFormatCount;
-    res = GR_VK_CALL(fBackendContext->fInterface,
-                     GetPhysicalDeviceSurfaceFormatsKHR(fBackendContext->fPhysicalDevice,
-                                                        fSurface,
-                                                        &surfaceFormatCount,
-                                                        nullptr));
+    res = fGetPhysicalDeviceSurfaceFormatsKHR(fBackendContext->fPhysicalDevice, fSurface,
+                                              &surfaceFormatCount, nullptr);
     if (VK_SUCCESS != res) {
         return false;
     }
 
     SkAutoMalloc surfaceFormatAlloc(surfaceFormatCount * sizeof(VkSurfaceFormatKHR));
     VkSurfaceFormatKHR* surfaceFormats = (VkSurfaceFormatKHR*)surfaceFormatAlloc.get();
-    res = GR_VK_CALL(fBackendContext->fInterface,
-                     GetPhysicalDeviceSurfaceFormatsKHR(fBackendContext->fPhysicalDevice,
-                                                        fSurface,
-                                                        &surfaceFormatCount,
-                                                        surfaceFormats));
+    res = fGetPhysicalDeviceSurfaceFormatsKHR(fBackendContext->fPhysicalDevice, fSurface,
+                                              &surfaceFormatCount, surfaceFormats);
     if (VK_SUCCESS != res) {
         return false;
     }
 
     uint32_t presentModeCount;
-    res = GR_VK_CALL(fBackendContext->fInterface,
-                     GetPhysicalDeviceSurfacePresentModesKHR(fBackendContext->fPhysicalDevice,
-                                                             fSurface,
-                                                             &presentModeCount,
-                                                             nullptr));
+    res = fGetPhysicalDeviceSurfacePresentModesKHR(fBackendContext->fPhysicalDevice, fSurface,
+                                                   &presentModeCount, nullptr);
     if (VK_SUCCESS != res) {
         return false;
     }
 
     SkAutoMalloc presentModeAlloc(presentModeCount * sizeof(VkPresentModeKHR));
     VkPresentModeKHR* presentModes = (VkPresentModeKHR*)presentModeAlloc.get();
-    res = GR_VK_CALL(fBackendContext->fInterface,
-                     GetPhysicalDeviceSurfacePresentModesKHR(fBackendContext->fPhysicalDevice,
-                                                             fSurface,
-                                                             &presentModeCount,
-                                                             presentModes));
+    res = fGetPhysicalDeviceSurfacePresentModesKHR(fBackendContext->fPhysicalDevice, fSurface,
+                                                    &presentModeCount, presentModes);
     if (VK_SUCCESS != res) {
         return false;
     }
 
     VkExtent2D extent = caps.currentExtent;
     // use the hints
     if (extent.width == (uint32_t)-1) {
         extent.width = width;
         extent.height = height;
     }
@@ skipping 46 matching lines @@
     memset(&swapchainCreateInfo, 0, sizeof(VkSwapchainCreateInfoKHR));
     swapchainCreateInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
     swapchainCreateInfo.surface = fSurface;
     swapchainCreateInfo.minImageCount = imageCount;
     swapchainCreateInfo.imageFormat = surfaceFormats[0].format;       // for now, use the first one
     swapchainCreateInfo.imageColorSpace = surfaceFormats[0].colorSpace;
     swapchainCreateInfo.imageExtent = extent;
     swapchainCreateInfo.imageArrayLayers = 1;
     swapchainCreateInfo.imageUsage = usageFlags;
 
-    uint32_t queueFamilies[] = { fBackendContext->fQueueFamilyIndex, fPresentQueueIndex };
-    if (fBackendContext->fQueueFamilyIndex != fPresentQueueIndex) {
+    uint32_t queueFamilies[] = { fBackendContext->fGraphicsQueueIndex, fPresentQueueIndex };
+    if (fBackendContext->fGraphicsQueueIndex != fPresentQueueIndex) {
         swapchainCreateInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
         swapchainCreateInfo.queueFamilyIndexCount = 2;
         swapchainCreateInfo.pQueueFamilyIndices = queueFamilies;
     } else {
         swapchainCreateInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
         swapchainCreateInfo.queueFamilyIndexCount = 0;
         swapchainCreateInfo.pQueueFamilyIndices = nullptr;
     }
 
     swapchainCreateInfo.preTransform = caps.currentTransform;;
     swapchainCreateInfo.compositeAlpha = composite_alpha;
     swapchainCreateInfo.presentMode = mode;
     swapchainCreateInfo.clipped = true;
     swapchainCreateInfo.oldSwapchain = fSwapchain;
 
-    res = GR_VK_CALL(fBackendContext->fInterface,
-                     CreateSwapchainKHR(fBackendContext->fDevice,
-                                        &swapchainCreateInfo, nullptr, &fSwapchain));
+    res = fCreateSwapchainKHR(fBackendContext->fDevice, &swapchainCreateInfo, nullptr, &fSwapchain);
     if (VK_SUCCESS != res) {
         return false;
     }
 
     // destroy the old swapchain
     if (swapchainCreateInfo.oldSwapchain != VK_NULL_HANDLE) {
         GR_VK_CALL(fBackendContext->fInterface, DeviceWaitIdle(fBackendContext->fDevice));
 
         this->destroyBuffers();
 
-        GR_VK_CALL(fBackendContext->fInterface, DestroySwapchainKHR(fBackendContext->fDevice,
-                                                                   swapchainCreateInfo.oldSwapchain,
-                                                                   nullptr));
+        fDestroySwapchainKHR(fBackendContext->fDevice, swapchainCreateInfo.oldSwapchain, nullptr);
     }
 
     GrVkFormatToPixelConfig(swapchainCreateInfo.imageFormat, &fPixelConfig);
 
     this->createBuffers();
 
     return true;
 }
 
 void VulkanTestContext::createBuffers() {
-    GR_VK_CALL_ERRCHECK(fBackendContext->fInterface, GetSwapchainImagesKHR(fBackendContext->fDevice,
-                                                                           fSwapchain,
-                                                                           &fImageCount,
-                                                                           nullptr));
+    fGetSwapchainImagesKHR(fBackendContext->fDevice, fSwapchain, &fImageCount, nullptr);
     SkASSERT(fImageCount);
     fImages = new VkImage[fImageCount];
-    GR_VK_CALL_ERRCHECK(fBackendContext->fInterface, GetSwapchainImagesKHR(fBackendContext->fDevice,
-                                                                           fSwapchain,
-                                                                           &fImageCount,
-                                                                           fImages));
+    fGetSwapchainImagesKHR(fBackendContext->fDevice, fSwapchain, &fImageCount, fImages);
 
     // set up initial image layouts and create surfaces
     fImageLayouts = new VkImageLayout[fImageCount];
     fSurfaces = new sk_sp<SkSurface>[fImageCount];
     for (uint32_t i = 0; i < fImageCount; ++i) {
         fImageLayouts[i] = VK_IMAGE_LAYOUT_UNDEFINED;
 
         GrBackendRenderTargetDesc desc;
         GrVkTextureInfo info;
         info.fImage = fImages[i];
@@ skipping 10 matching lines @@
         SkSurfaceProps props(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->fQueueFamilyIndex;
+        commandPoolInfo.queueFamilyIndex = fBackendContext->fGraphicsQueueIndex;
         commandPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
         GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
                             CreateCommandPool(fBackendContext->fDevice, &commandPoolInfo,
                                               nullptr, &fCommandPool));
     }
 
     // set up the backbuffers
     VkSemaphoreCreateInfo semaphoreInfo;
     memset(&semaphoreInfo, 0, sizeof(VkSemaphoreCreateInfo));
     semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
@@ skipping 87 matching lines @@
 
     this->destroyBuffers();
 
     if (VK_NULL_HANDLE != fCommandPool) {
         GR_VK_CALL(fBackendContext->fInterface, DestroyCommandPool(fBackendContext->fDevice,
                                                                    fCommandPool, nullptr));
         fCommandPool = VK_NULL_HANDLE;
     }
 
     if (VK_NULL_HANDLE != fSwapchain) {
-        GR_VK_CALL(fBackendContext->fInterface, DestroySwapchainKHR(fBackendContext->fDevice,
-                                                                    fSwapchain, nullptr));
+        fDestroySwapchainKHR(fBackendContext->fDevice, fSwapchain, nullptr);
         fSwapchain = VK_NULL_HANDLE;
     }
 
     if (VK_NULL_HANDLE != fSurface) {
-        GR_VK_CALL(fBackendContext->fInterface, DestroySurfaceKHR(fBackendContext->fInstance,
-                                                                  fSurface, nullptr));
+        fDestroySurfaceKHR(fBackendContext->fInstance, fSurface, nullptr);
         fSurface = VK_NULL_HANDLE;
     }
 
     delete fContext;
 
     fBackendContext.reset(nullptr);
 }
 
 VulkanTestContext::BackbufferInfo* VulkanTestContext::getAvailableBackbuffer() {
     SkASSERT(fBackbuffers);
@@ skipping 14 matching lines @@
 SkSurface* VulkanTestContext::getBackbufferSurface() {
     BackbufferInfo* backbuffer = this->getAvailableBackbuffer();
     SkASSERT(backbuffer);
 
     // reset the fence
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
                         ResetFences(fBackendContext->fDevice, 2, backbuffer->fUsageFences));
     // semaphores should be in unsignaled state
 
     // acquire the image
-    VkResult res = GR_VK_CALL(fBackendContext->fInterface,
-                              AcquireNextImageKHR(fBackendContext->fDevice, 
-                                                  fSwapchain,
-                                                  UINT64_MAX,
-                                                  backbuffer->fAcquireSemaphore,
-                                                  VK_NULL_HANDLE,
-                                                  &backbuffer->fImageIndex));
+    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)) {
             return nullptr;
         }
 
         // acquire the image
-        res = GR_VK_CALL(fBackendContext->fInterface,
-                         AcquireNextImageKHR(fBackendContext->fDevice,
-                                             fSwapchain,
-                                             UINT64_MAX,
-                                             backbuffer->fAcquireSemaphore,
-                                             VK_NULL_HANDLE,
-                                             &backbuffer->fImageIndex));
+        res = fAcquireNextImageKHR(fBackendContext->fDevice,  fSwapchain, UINT64_MAX,
+                                   backbuffer->fAcquireSemaphore, VK_NULL_HANDLE,
+                                   &backbuffer->fImageIndex);
 
         if (VK_SUCCESS != res) {
             return nullptr;
         }
     }
 
     // set up layout transfer from initial to color attachment
     VkImageLayout layout = fImageLayouts[backbuffer->fImageIndex];
     VkPipelineStageFlags srcStageMask = (VK_IMAGE_LAYOUT_UNDEFINED == layout) ?
                                         VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT :
                                         VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
     VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
     VkAccessFlags srcAccessMask = (VK_IMAGE_LAYOUT_UNDEFINED == layout) ? 
                                   0 : VK_ACCESS_MEMORY_READ_BIT;
     VkAccessFlags dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 
     VkImageMemoryBarrier imageMemoryBarrier = {
         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,   // sType
         NULL,                                     // pNext
         srcAccessMask,                            // outputMask
         dstAccessMask,                            // inputMask
         layout,                                   // oldLayout
         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // newLayout
         fPresentQueueIndex,                       // srcQueueFamilyIndex
-        fBackendContext->fQueueFamilyIndex,       // dstQueueFamilyIndex
+        fBackendContext->fGraphicsQueueIndex,     // dstQueueFamilyIndex
         fImages[backbuffer->fImageIndex],         // image
         { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 } // subresourceRange
     };
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
                         ResetCommandBuffer(backbuffer->fTransitionCmdBuffers[0], 0));
     VkCommandBufferBeginInfo info;
     memset(&info, 0, sizeof(VkCommandBufferBeginInfo));
     info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     info.flags = 0;
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
@@ skipping 38 matching lines @@
     VkAccessFlags srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
     VkAccessFlags dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
 
     VkImageMemoryBarrier imageMemoryBarrier = {
         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,   // sType
         NULL,                                     // pNext
         srcAccessMask,                            // outputMask
         dstAccessMask,                            // inputMask
         layout,                                   // oldLayout
         VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,          // newLayout
-        fBackendContext->fQueueFamilyIndex,       // srcQueueFamilyIndex
+        fBackendContext->fGraphicsQueueIndex,     // srcQueueFamilyIndex
         fPresentQueueIndex,                       // dstQueueFamilyIndex
         fImages[backbuffer->fImageIndex],         // image
         { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 } // subresourceRange
     };
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
                         ResetCommandBuffer(backbuffer->fTransitionCmdBuffers[1], 0));
     VkCommandBufferBeginInfo info;
     memset(&info, 0, sizeof(VkCommandBufferBeginInfo));
     info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     info.flags = 0;
@@ skipping 31 matching lines @@
         VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, // sType
         NULL, // pNext
         1, // waitSemaphoreCount
         &backbuffer->fRenderSemaphore, // pWaitSemaphores
         1, // swapchainCount
         &fSwapchain, // pSwapchains
         &backbuffer->fImageIndex, // pImageIndices
         NULL // pResults
     };
 
-    GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
-                        QueuePresentKHR(fPresentQueue, &presentInfo));
+    fQueuePresentKHR(fPresentQueue, &presentInfo);
 
 }