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 b01a2c89df234a0821b76de3df1b3b61551f478b..cff12b57b692650ef0c705241eee958ba0e5e0f6 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 db8735b1fa8a6eb3c8680a390a323b0aba70851a..205112cabf737f4f848ab958e2d8757b3d6e9866 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 089597b3c7b00ac354156ef67b916a2cecef739c..f10c0e360b43c59a2f3da29d75620aa0922fce69 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 231001b9ba669177c57ce3a034b19b48d5b410b2..0db72c8ab0c078032e4e08342c33ae6f8769865e 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);
 }