Add vulkan 1.1 function entrypoints

Implement vkGetDeviceGroupSurfacePresentModesKHR,
vkGetDeviceGroupPresentCapabilitiesKHR, vkAcquireNextImage2KHR and
vkGetPhysicalDevicePresentRectanglesKHR function entrypoints in the
layer.

We assume that if the layer should not handle the surface the device or
instance should handle it as appropriate and fallback to this
implmentation.

Change-Id: Iafc585d8738ad80413ad616d834d966f92c4f8cb
Signed-off-by: Ben Davis <ben.davis@arm.com>

diff --git a/layer/layer.cpp b/layer/layer.cpp
index b01a2c8..cff12b5 100644 (file)
--- a/layer/layer.cpp
+++ b/layer/layer.cpp
@@ -435,6 +435,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI_CALL wsi_layer_vkGetDeviceProcAddr(VkDe
    GET_PROC_ADDR(vkAcquireNextImageKHR);
    GET_PROC_ADDR(vkQueuePresentKHR);
 
+   GET_PROC_ADDR(vkGetDeviceGroupSurfacePresentModesKHR);
+   GET_PROC_ADDR(vkGetDeviceGroupPresentCapabilitiesKHR);
+   GET_PROC_ADDR(vkAcquireNextImage2KHR);
+
    return layer::device_private_data::get(device).disp.GetDeviceProcAddr(device, funcName);
 }
 
@@ -460,6 +464,8 @@ VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL wsi_layer_vkGetInstance
    GET_PROC_ADDR(vkEnumerateDeviceExtensionProperties);
    GET_PROC_ADDR(vkEnumerateInstanceLayerProperties);
 
+   GET_PROC_ADDR(vkGetPhysicalDevicePresentRectanglesKHR);
+
    return layer::instance_private_data::get(instance).disp.GetInstanceProcAddr(instance, funcName);
 }
 } /* extern "C" */

diff --git a/layer/private_data.hpp b/layer/private_data.hpp
index db8735b..205112c 100644 (file)
--- a/layer/private_data.hpp
+++ b/layer/private_data.hpp
@@ -58,7 +58,8 @@ namespace layer
    OPTIONAL(GetPhysicalDeviceSurfacePresentModesKHR)    \
    OPTIONAL(GetPhysicalDeviceSurfaceSupportKHR)         \
    OPTIONAL(GetPhysicalDeviceImageFormatProperties2KHR) \
-   OPTIONAL(GetPhysicalDeviceFormatProperties2KHR)
+   OPTIONAL(GetPhysicalDeviceFormatProperties2KHR)      \
+   OPTIONAL(GetPhysicalDevicePresentRectanglesKHR)
 
 struct instance_dispatch_table
 {
@@ -116,7 +117,10 @@ struct instance_dispatch_table
    OPTIONAL(AcquireNextImageKHR)                    \
    OPTIONAL(QueuePresentKHR)                        \
    OPTIONAL(GetMemoryFdPropertiesKHR)               \
-   OPTIONAL(BindImageMemory2KHR)
+   OPTIONAL(BindImageMemory2KHR)                    \
+   OPTIONAL(GetDeviceGroupSurfacePresentModesKHR)   \
+   OPTIONAL(GetDeviceGroupPresentCapabilitiesKHR)   \
+   OPTIONAL(AcquireNextImage2KHR)
 
 struct device_dispatch_table
 {

diff --git a/layer/swapchain_api.cpp b/layer/swapchain_api.cpp
index 089597b..f10c0e3 100644 (file)
--- a/layer/swapchain_api.cpp
+++ b/layer/swapchain_api.cpp
@@ -166,4 +166,104 @@ VKAPI_ATTR VkResult wsi_layer_vkQueuePresentKHR(VkQueue queue, const VkPresentIn
    return ret;
 }
 
+VKAPI_ATTR VkResult wsi_layer_vkGetDeviceGroupPresentCapabilitiesKHR(
+   VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
+{
+   assert(pDeviceGroupPresentCapabilities != nullptr);
+
+   pDeviceGroupPresentCapabilities->presentMask[0] = 1;
+   pDeviceGroupPresentCapabilities->modes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
+
+   for (uint32_t i = 1; i < VK_MAX_DEVICE_GROUP_SIZE_KHR; i++)
+   {
+      pDeviceGroupPresentCapabilities->presentMask[i] = 0;
+   }
+
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult wsi_layer_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface,
+                                                                     VkDeviceGroupPresentModeFlagsKHR *pModes)
+{
+   assert(pModes != nullptr);
+
+   auto &device_data = layer::device_private_data::get(device);
+   auto &instance = device_data.instance_data;
+
+   if (!instance.should_layer_handle_surface(device_data.physical_device, surface))
+   {
+      return device_data.disp.GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
+   }
+
+   *pModes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
+   return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult wsi_layer_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,
+                                                                      VkSurfaceKHR surface, uint32_t *pRectCount,
+                                                                      VkRect2D *pRects)
+{
+   assert(surface);
+   assert(pRectCount != nullptr);
+
+   auto &instance = layer::instance_private_data::get(physicalDevice);
+
+   if (!instance.should_layer_handle_surface(physicalDevice, surface))
+   {
+      return instance.disp.GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
+   }
+
+   VkResult result;
+   wsi::surface_properties *props = wsi::get_surface_properties(surface);
+   assert(props);
+
+   if (nullptr == pRects)
+   {
+      *pRectCount = 1;
+      result = VK_SUCCESS;
+   }
+   else if (0 == *pRectCount)
+   {
+      result = VK_INCOMPLETE;
+   }
+   else
+   {
+      *pRectCount = 1;
+
+      VkSurfaceCapabilitiesKHR surface_caps;
+      result = props->get_surface_capabilities(physicalDevice, surface, &surface_caps);
+
+      if (result != VK_SUCCESS)
+      {
+         return result;
+      }
+
+      pRects[0].offset.x = 0;
+      pRects[0].offset.y = 0;
+      pRects[0].extent = surface_caps.currentExtent;
+   }
+
+   return result;
+}
+
+VKAPI_ATTR VkResult wsi_layer_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo,
+                                                     uint32_t *pImageIndex)
+{
+   assert(pAcquireInfo != VK_NULL_HANDLE);
+   assert(pAcquireInfo->swapchain != VK_NULL_HANDLE);
+   assert(pAcquireInfo->semaphore != VK_NULL_HANDLE || pAcquireInfo->fence != VK_NULL_HANDLE);
+   assert(pImageIndex != nullptr);
+
+   auto &device_data = layer::device_private_data::get(device);
+
+   if (!device_data.layer_owns_swapchain(pAcquireInfo->swapchain))
+   {
+      return device_data.disp.AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
+   }
+
+   wsi::swapchain_base *sc = reinterpret_cast<wsi::swapchain_base *>(pAcquireInfo->swapchain);
+
+   return sc->acquire_next_image(pAcquireInfo->timeout, pAcquireInfo->semaphore, pAcquireInfo->fence, pImageIndex);
+}
+
 } /* extern "C" */

diff --git a/layer/swapchain_api.hpp b/layer/swapchain_api.hpp
index 231001b..0db72c8 100644 (file)
--- a/layer/swapchain_api.hpp
+++ b/layer/swapchain_api.hpp
@@ -49,4 +49,17 @@ extern "C"
 
    VKAPI_ATTR VkResult wsi_layer_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo);
 
+   /* 1.1 entrypoints */
+   VKAPI_ATTR VkResult wsi_layer_vkGetDeviceGroupPresentCapabilitiesKHR(
+      VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities);
+
+   VKAPI_ATTR VkResult wsi_layer_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface,
+                                                                        VkDeviceGroupPresentModeFlagsKHR *pModes);
+
+   VKAPI_ATTR VkResult wsi_layer_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,
+                                                                         VkSurfaceKHR surface, uint32_t *pRectCount,
+                                                                         VkRect2D *pRects);
+
+   VKAPI_ATTR VkResult wsi_layer_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo,
+                                                        uint32_t *pImageIndex);
 }