From b5dec4d8f20b1ce87c6d06fd48693c187cf7fa74 Mon Sep 17 00:00:00 2001 From: Boris Zanin Date: Tue, 21 Mar 2017 17:06:30 +0100 Subject: [PATCH] Add new tests for VK_KHR_get_display_properties2 Following tests has been implemented: * dEQP-VK.wsi.display.get_display_properties2 * dEQP-VK.wsi.display.get_display_plane_properties2 * dEQP-VK.wsi.display.get_display_mode_properties2 * dEQP-VK.wsi.display.get_display_plane_capabilities2 Components: Vulkan VK_GL_CTS Issue: #168 Change-Id: Ib06dd6837b1348e13ff289df86f446424a4e6a01 --- android/cts/master/vk-master.txt | 4 + .../vulkancts/framework/vulkan/vkBasicTypes.inl | 1 + .../vulkan/vkConcreteInstanceInterface.inl | 4 + .../framework/vulkan/vkFunctionPointerTypes.inl | 4 + .../framework/vulkan/vkGetStructureTypeImpl.inl | 25 + .../vulkan/vkInitInstanceFunctionPointers.inl | 4 + .../framework/vulkan/vkInstanceDriverImpl.inl | 20 + .../vulkan/vkInstanceFunctionPointers.inl | 4 + .../framework/vulkan/vkNullDriverImpl.inl | 37 + external/vulkancts/framework/vulkan/vkStrUtil.inl | 5 + .../vulkancts/framework/vulkan/vkStrUtilImpl.inl | 51 ++ .../vulkancts/framework/vulkan/vkStructTypes.inl | 36 + .../vulkan/vkVirtualInstanceInterface.inl | 4 + .../modules/vulkan/wsi/vktWsiDisplayTests.cpp | 915 ++++++++++++++++++++- external/vulkancts/mustpass/1.1.0/vk-default.txt | 4 + external/vulkancts/scripts/src/vulkan.h.in | 65 ++ 16 files changed, 1141 insertions(+), 42 deletions(-) diff --git a/android/cts/master/vk-master.txt b/android/cts/master/vk-master.txt index 194f28f..aa99679 100755 --- a/android/cts/master/vk-master.txt +++ b/android/cts/master/vk-master.txt @@ -221623,6 +221623,10 @@ dEQP-VK.wsi.display.get_display_mode_properties dEQP-VK.wsi.display.create_display_mode dEQP-VK.wsi.display.get_display_plane_capabilities dEQP-VK.wsi.display.create_display_plane_surface +dEQP-VK.wsi.display.get_display_properties2 +dEQP-VK.wsi.display.get_display_plane_properties2 +dEQP-VK.wsi.display.get_display_mode_properties2 +dEQP-VK.wsi.display.get_display_plane_capabilities2 dEQP-VK.synchronization.smoke.fences dEQP-VK.synchronization.smoke.semaphores dEQP-VK.synchronization.smoke.events diff --git a/external/vulkancts/framework/vulkan/vkBasicTypes.inl b/external/vulkancts/framework/vulkan/vkBasicTypes.inl index 62941e4..7794ca7 100644 --- a/external/vulkancts/framework/vulkan/vkBasicTypes.inl +++ b/external/vulkancts/framework/vulkan/vkBasicTypes.inl @@ -1981,6 +1981,7 @@ VK_DEFINE_PLATFORM_TYPE(RROutput, void*); #define VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT #define VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT #define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2" #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES #define VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO #define VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS diff --git a/external/vulkancts/framework/vulkan/vkConcreteInstanceInterface.inl b/external/vulkancts/framework/vulkan/vkConcreteInstanceInterface.inl index c6bfbc1..7dcdd57 100644 --- a/external/vulkancts/framework/vulkan/vkConcreteInstanceInterface.inl +++ b/external/vulkancts/framework/vulkan/vkConcreteInstanceInterface.inl @@ -51,6 +51,10 @@ virtual VkResult createWin32SurfaceKHR (VkInstance instance, const VkWi virtual VkBool32 getPhysicalDeviceWin32PresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex) const; virtual VkResult getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const; virtual VkResult getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, deUint32* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) const; +virtual VkResult getPhysicalDeviceDisplayProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayProperties2KHR* pProperties) const; +virtual VkResult getPhysicalDeviceDisplayPlaneProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) const; +virtual VkResult getDisplayModeProperties2KHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, deUint32* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) const; +virtual VkResult getDisplayPlaneCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) const; virtual VkResult createDebugReportCallbackEXT (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) const; virtual void destroyDebugReportCallbackEXT (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) const; virtual void debugReportMessageEXT (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, deUint64 object, deUintptr location, deInt32 messageCode, const char* pLayerPrefix, const char* pMessage) const; diff --git a/external/vulkancts/framework/vulkan/vkFunctionPointerTypes.inl b/external/vulkancts/framework/vulkan/vkFunctionPointerTypes.inl index 8340ba7..2af1af2 100644 --- a/external/vulkancts/framework/vulkan/vkFunctionPointerTypes.inl +++ b/external/vulkancts/framework/vulkan/vkFunctionPointerTypes.inl @@ -234,6 +234,10 @@ typedef VKAPI_ATTR VkResult (VKAPI_CALL* ImportFenceFdKHRFunc) (VkDe typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetFenceFdKHRFunc) (VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPhysicalDeviceSurfaceCapabilities2KHRFunc) (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPhysicalDeviceSurfaceFormats2KHRFunc) (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, deUint32* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); +typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPhysicalDeviceDisplayProperties2KHRFunc) (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayProperties2KHR* pProperties); +typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPhysicalDeviceDisplayPlaneProperties2KHRFunc) (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); +typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetDisplayModeProperties2KHRFunc) (VkPhysicalDevice physicalDevice, VkDisplayKHR display, deUint32* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); +typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetDisplayPlaneCapabilities2KHRFunc) (VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); typedef VKAPI_ATTR void (VKAPI_CALL* GetBufferMemoryRequirements2KHRFunc) (VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); typedef VKAPI_ATTR void (VKAPI_CALL* GetImageMemoryRequirements2KHRFunc) (VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); typedef VKAPI_ATTR void (VKAPI_CALL* GetImageSparseMemoryRequirements2KHRFunc) (VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); diff --git a/external/vulkancts/framework/vulkan/vkGetStructureTypeImpl.inl b/external/vulkancts/framework/vulkan/vkGetStructureTypeImpl.inl index fa7b0ef..bfc968f 100644 --- a/external/vulkancts/framework/vulkan/vkGetStructureTypeImpl.inl +++ b/external/vulkancts/framework/vulkan/vkGetStructureTypeImpl.inl @@ -771,6 +771,31 @@ template<> VkStructureType getStructureType (void) return VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR; } +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR; +} + +template<> VkStructureType getStructureType (void) +{ + return VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR; +} + template<> VkStructureType getStructureType (void) { return VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR; diff --git a/external/vulkancts/framework/vulkan/vkInitInstanceFunctionPointers.inl b/external/vulkancts/framework/vulkan/vkInitInstanceFunctionPointers.inl index 6c7e5cf..86a635f 100644 --- a/external/vulkancts/framework/vulkan/vkInitInstanceFunctionPointers.inl +++ b/external/vulkancts/framework/vulkan/vkInitInstanceFunctionPointers.inl @@ -73,6 +73,10 @@ m_vk.createWin32SurfaceKHR = (CreateWin32SurfaceKHRFunc) GET_PROC m_vk.getPhysicalDeviceWin32PresentationSupportKHR = (GetPhysicalDeviceWin32PresentationSupportKHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceWin32PresentationSupportKHR"); m_vk.getPhysicalDeviceSurfaceCapabilities2KHR = (GetPhysicalDeviceSurfaceCapabilities2KHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceSurfaceCapabilities2KHR"); m_vk.getPhysicalDeviceSurfaceFormats2KHR = (GetPhysicalDeviceSurfaceFormats2KHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceSurfaceFormats2KHR"); +m_vk.getPhysicalDeviceDisplayProperties2KHR = (GetPhysicalDeviceDisplayProperties2KHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceDisplayProperties2KHR"); +m_vk.getPhysicalDeviceDisplayPlaneProperties2KHR = (GetPhysicalDeviceDisplayPlaneProperties2KHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceDisplayPlaneProperties2KHR"); +m_vk.getDisplayModeProperties2KHR = (GetDisplayModeProperties2KHRFunc) GET_PROC_ADDR("vkGetDisplayModeProperties2KHR"); +m_vk.getDisplayPlaneCapabilities2KHR = (GetDisplayPlaneCapabilities2KHRFunc) GET_PROC_ADDR("vkGetDisplayPlaneCapabilities2KHR"); m_vk.createDebugReportCallbackEXT = (CreateDebugReportCallbackEXTFunc) GET_PROC_ADDR("vkCreateDebugReportCallbackEXT"); m_vk.destroyDebugReportCallbackEXT = (DestroyDebugReportCallbackEXTFunc) GET_PROC_ADDR("vkDestroyDebugReportCallbackEXT"); m_vk.debugReportMessageEXT = (DebugReportMessageEXTFunc) GET_PROC_ADDR("vkDebugReportMessageEXT"); diff --git a/external/vulkancts/framework/vulkan/vkInstanceDriverImpl.inl b/external/vulkancts/framework/vulkan/vkInstanceDriverImpl.inl index 74e0252..c3672ca 100644 --- a/external/vulkancts/framework/vulkan/vkInstanceDriverImpl.inl +++ b/external/vulkancts/framework/vulkan/vkInstanceDriverImpl.inl @@ -252,6 +252,26 @@ VkResult InstanceDriver::getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice p return m_vk.getPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); } +VkResult InstanceDriver::getPhysicalDeviceDisplayProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayProperties2KHR* pProperties) const +{ + return m_vk.getPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties); +} + +VkResult InstanceDriver::getPhysicalDeviceDisplayPlaneProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) const +{ + return m_vk.getPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties); +} + +VkResult InstanceDriver::getDisplayModeProperties2KHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, deUint32* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) const +{ + return m_vk.getDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties); +} + +VkResult InstanceDriver::getDisplayPlaneCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) const +{ + return m_vk.getDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities); +} + VkResult InstanceDriver::createDebugReportCallbackEXT (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) const { return m_vk.createDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); diff --git a/external/vulkancts/framework/vulkan/vkInstanceFunctionPointers.inl b/external/vulkancts/framework/vulkan/vkInstanceFunctionPointers.inl index 3a12891..a688a47 100644 --- a/external/vulkancts/framework/vulkan/vkInstanceFunctionPointers.inl +++ b/external/vulkancts/framework/vulkan/vkInstanceFunctionPointers.inl @@ -51,6 +51,10 @@ CreateWin32SurfaceKHRFunc createWin32SurfaceKHR; GetPhysicalDeviceWin32PresentationSupportKHRFunc getPhysicalDeviceWin32PresentationSupportKHR; GetPhysicalDeviceSurfaceCapabilities2KHRFunc getPhysicalDeviceSurfaceCapabilities2KHR; GetPhysicalDeviceSurfaceFormats2KHRFunc getPhysicalDeviceSurfaceFormats2KHR; +GetPhysicalDeviceDisplayProperties2KHRFunc getPhysicalDeviceDisplayProperties2KHR; +GetPhysicalDeviceDisplayPlaneProperties2KHRFunc getPhysicalDeviceDisplayPlaneProperties2KHR; +GetDisplayModeProperties2KHRFunc getDisplayModeProperties2KHR; +GetDisplayPlaneCapabilities2KHRFunc getDisplayPlaneCapabilities2KHR; CreateDebugReportCallbackEXTFunc createDebugReportCallbackEXT; DestroyDebugReportCallbackEXTFunc destroyDebugReportCallbackEXT; DebugReportMessageEXTFunc debugReportMessageEXT; diff --git a/external/vulkancts/framework/vulkan/vkNullDriverImpl.inl b/external/vulkancts/framework/vulkan/vkNullDriverImpl.inl index e762992..8197e94 100644 --- a/external/vulkancts/framework/vulkan/vkNullDriverImpl.inl +++ b/external/vulkancts/framework/vulkan/vkNullDriverImpl.inl @@ -1498,6 +1498,39 @@ VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDe return VK_SUCCESS; } +VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayProperties2KHR* pProperties) +{ + DE_UNREF(physicalDevice); + DE_UNREF(pPropertyCount); + DE_UNREF(pProperties); + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPlaneProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) +{ + DE_UNREF(physicalDevice); + DE_UNREF(pPropertyCount); + DE_UNREF(pProperties); + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL getDisplayModeProperties2KHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, deUint32* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) +{ + DE_UNREF(physicalDevice); + DE_UNREF(display); + DE_UNREF(pPropertyCount); + DE_UNREF(pProperties); + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) +{ + DE_UNREF(physicalDevice); + DE_UNREF(pDisplayPlaneInfo); + DE_UNREF(pCapabilities); + return VK_SUCCESS; +} + VKAPI_ATTR void VKAPI_CALL debugReportMessageEXT (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, deUint64 object, deUintptr location, deInt32 messageCode, const char* pLayerPrefix, const char* pMessage) { DE_UNREF(instance); @@ -1851,6 +1884,10 @@ static const tcu::StaticFunctionLibrary::Entry s_instanceFunctions[] = VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalFencePropertiesKHR, getPhysicalDeviceExternalFenceProperties), VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilities2KHR, getPhysicalDeviceSurfaceCapabilities2KHR), VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormats2KHR, getPhysicalDeviceSurfaceFormats2KHR), + VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayProperties2KHR, getPhysicalDeviceDisplayProperties2KHR), + VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPlaneProperties2KHR, getPhysicalDeviceDisplayPlaneProperties2KHR), + VK_NULL_FUNC_ENTRY(vkGetDisplayModeProperties2KHR, getDisplayModeProperties2KHR), + VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneCapabilities2KHR, getDisplayPlaneCapabilities2KHR), VK_NULL_FUNC_ENTRY(vkCreateDebugReportCallbackEXT, createDebugReportCallbackEXT), VK_NULL_FUNC_ENTRY(vkDestroyDebugReportCallbackEXT, destroyDebugReportCallbackEXT), VK_NULL_FUNC_ENTRY(vkDebugReportMessageEXT, debugReportMessageEXT), diff --git a/external/vulkancts/framework/vulkan/vkStrUtil.inl b/external/vulkancts/framework/vulkan/vkStrUtil.inl index 8b54b12..07104e7 100644 --- a/external/vulkancts/framework/vulkan/vkStrUtil.inl +++ b/external/vulkancts/framework/vulkan/vkStrUtil.inl @@ -503,6 +503,11 @@ std::ostream& operator<< (std::ostream& s, const VkFenceGetFdInfoKHR& value); std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceSurfaceInfo2KHR& value); std::ostream& operator<< (std::ostream& s, const VkSurfaceCapabilities2KHR& value); std::ostream& operator<< (std::ostream& s, const VkSurfaceFormat2KHR& value); +std::ostream& operator<< (std::ostream& s, const VkDisplayProperties2KHR& value); +std::ostream& operator<< (std::ostream& s, const VkDisplayPlaneProperties2KHR& value); +std::ostream& operator<< (std::ostream& s, const VkDisplayModeProperties2KHR& value); +std::ostream& operator<< (std::ostream& s, const VkDisplayPlaneInfo2KHR& value); +std::ostream& operator<< (std::ostream& s, const VkDisplayPlaneCapabilities2KHR& value); std::ostream& operator<< (std::ostream& s, const VkImageFormatListCreateInfoKHR& value); std::ostream& operator<< (std::ostream& s, const VkDebugReportCallbackCreateInfoEXT& value); std::ostream& operator<< (std::ostream& s, const VkPipelineRasterizationStateRasterizationOrderAMD& value); diff --git a/external/vulkancts/framework/vulkan/vkStrUtilImpl.inl b/external/vulkancts/framework/vulkan/vkStrUtilImpl.inl index be0a74e..b73e5fa 100644 --- a/external/vulkancts/framework/vulkan/vkStrUtilImpl.inl +++ b/external/vulkancts/framework/vulkan/vkStrUtilImpl.inl @@ -5158,6 +5158,57 @@ std::ostream& operator<< (std::ostream& s, const VkSurfaceFormat2KHR& value) return s; } +std::ostream& operator<< (std::ostream& s, const VkDisplayProperties2KHR& value) +{ + s << "VkDisplayProperties2KHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tdisplayProperties = " << value.displayProperties << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkDisplayPlaneProperties2KHR& value) +{ + s << "VkDisplayPlaneProperties2KHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tdisplayPlaneProperties = " << value.displayPlaneProperties << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkDisplayModeProperties2KHR& value) +{ + s << "VkDisplayModeProperties2KHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tdisplayModeProperties = " << value.displayModeProperties << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkDisplayPlaneInfo2KHR& value) +{ + s << "VkDisplayPlaneInfo2KHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tmode = " << value.mode << '\n'; + s << "\tplaneIndex = " << value.planeIndex << '\n'; + s << '}'; + return s; +} + +std::ostream& operator<< (std::ostream& s, const VkDisplayPlaneCapabilities2KHR& value) +{ + s << "VkDisplayPlaneCapabilities2KHR = {\n"; + s << "\tsType = " << value.sType << '\n'; + s << "\tpNext = " << value.pNext << '\n'; + s << "\tcapabilities = " << value.capabilities << '\n'; + s << '}'; + return s; +} + std::ostream& operator<< (std::ostream& s, const VkImageFormatListCreateInfoKHR& value) { s << "VkImageFormatListCreateInfoKHR = {\n"; diff --git a/external/vulkancts/framework/vulkan/vkStructTypes.inl b/external/vulkancts/framework/vulkan/vkStructTypes.inl index 14ef3c2..649d1d4 100644 --- a/external/vulkancts/framework/vulkan/vkStructTypes.inl +++ b/external/vulkancts/framework/vulkan/vkStructTypes.inl @@ -2192,6 +2192,42 @@ struct VkSurfaceFormat2KHR VkSurfaceFormatKHR surfaceFormat; }; +struct VkDisplayProperties2KHR +{ + VkStructureType sType; + void* pNext; + VkDisplayPropertiesKHR displayProperties; +}; + +struct VkDisplayPlaneProperties2KHR +{ + VkStructureType sType; + void* pNext; + VkDisplayPlanePropertiesKHR displayPlaneProperties; +}; + +struct VkDisplayModeProperties2KHR +{ + VkStructureType sType; + void* pNext; + VkDisplayModePropertiesKHR displayModeProperties; +}; + +struct VkDisplayPlaneInfo2KHR +{ + VkStructureType sType; + const void* pNext; + VkDisplayModeKHR mode; + deUint32 planeIndex; +}; + +struct VkDisplayPlaneCapabilities2KHR +{ + VkStructureType sType; + void* pNext; + VkDisplayPlaneCapabilitiesKHR capabilities; +}; + struct VkImageFormatListCreateInfoKHR { VkStructureType sType; diff --git a/external/vulkancts/framework/vulkan/vkVirtualInstanceInterface.inl b/external/vulkancts/framework/vulkan/vkVirtualInstanceInterface.inl index 76aeff9..dd8977a 100644 --- a/external/vulkancts/framework/vulkan/vkVirtualInstanceInterface.inl +++ b/external/vulkancts/framework/vulkan/vkVirtualInstanceInterface.inl @@ -51,6 +51,10 @@ virtual VkResult createWin32SurfaceKHR (VkInstance instance, const VkWi virtual VkBool32 getPhysicalDeviceWin32PresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex) const = 0; virtual VkResult getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const = 0; virtual VkResult getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, deUint32* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) const = 0; +virtual VkResult getPhysicalDeviceDisplayProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayProperties2KHR* pProperties) const = 0; +virtual VkResult getPhysicalDeviceDisplayPlaneProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) const = 0; +virtual VkResult getDisplayModeProperties2KHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, deUint32* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) const = 0; +virtual VkResult getDisplayPlaneCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) const = 0; virtual VkResult createDebugReportCallbackEXT (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) const = 0; virtual void destroyDebugReportCallbackEXT (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) const = 0; virtual void debugReportMessageEXT (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, deUint64 object, deUintptr location, deInt32 messageCode, const char* pLayerPrefix, const char* pMessage) const = 0; diff --git a/external/vulkancts/modules/vulkan/wsi/vktWsiDisplayTests.cpp b/external/vulkancts/modules/vulkan/wsi/vktWsiDisplayTests.cpp index 2dc48b7..9740506 100644 --- a/external/vulkancts/modules/vulkan/wsi/vktWsiDisplayTests.cpp +++ b/external/vulkancts/modules/vulkan/wsi/vktWsiDisplayTests.cpp @@ -18,7 +18,8 @@ * *//*! * \file - * \brief Vulkan VK_KHR_display extensions coverage tests + * \brief Vulkan coverage tests for extensions VK_KHR_display, + * VK_KHR_get_display_properties2 *//*--------------------------------------------------------------------*/ #include "vktWsiDisplayTests.hpp" @@ -64,6 +65,10 @@ enum DisplayIndexTest DISPLAY_TEST_INDEX_CREATE_DISPLAY_MODE, DISPLAY_TEST_INDEX_GET_DISPLAY_PLANE_CAPABILITIES, DISPLAY_TEST_INDEX_CREATE_DISPLAY_PLANE_SURFACE, + DISPLAY_TEST_INDEX_GET_DISPLAY_PROPERTIES2, + DISPLAY_TEST_INDEX_GET_DISPLAY_PLANES2, + DISPLAY_TEST_INDEX_GET_DISPLAY_MODE2, + DISPLAY_TEST_INDEX_GET_DISPLAY_PLANE_CAPABILITIES2, DISPLAY_TEST_INDEX_LAST }; @@ -80,6 +85,7 @@ public: typedef std::set > DisplaySet; typedef std::vector DisplayVector; typedef std::vector DisplayModePropertiesVector; +typedef std::vector DisplayModeProperties2Vector; const deUint32 DEUINT32_MAX = std::numeric_limits::max(); @@ -164,6 +170,27 @@ private: bool getDisplaysForPlane (deUint32 plane, DisplayVector& displays); bool getDisplayModeProperties (VkDisplayKHR display, DisplayModePropertiesVector& modeProperties); + bool getDisplays2 (DisplayVector& displays); + bool getDisplayModeProperties2 (VkDisplayKHR display, DisplayModeProperties2Vector& modeProperties); + + void validateDisplayProperties ( tcu::ResultCollector& results, + const VkDisplayPropertiesKHR& toValidate, + const VkDisplayPropertiesKHR& nonUpdated); + + void validateDisplayPlaneProperties ( tcu::ResultCollector& results, + const VkDisplayPlanePropertiesKHR& toValidate, + const VkDisplayPlanePropertiesKHR& nonUpdated, + DisplaySet& displaySet); + + void validateDisplayPlaneCapabilities ( tcu::ResultCollector& results, + const VkDisplayPlaneCapabilitiesKHR& toValidate, + const VkDisplayPlaneCapabilitiesKHR& nonUpdated); + + void validateDisplayModeProperties ( tcu::ResultCollector& results, + const VkDisplayModePropertiesKHR& toValidate, + const VkDisplayModePropertiesKHR& nonUpdated); + + // VK_KHR_display extension tests tcu::TestStatus testGetPhysicalDeviceDisplayPropertiesKHR (void); tcu::TestStatus testGetPhysicalDeviceDisplayPlanePropertiesKHR (void); tcu::TestStatus testGetDisplayPlaneSupportedDisplaysKHR (void); @@ -171,7 +198,13 @@ private: tcu::TestStatus testCreateDisplayModeKHR (void); tcu::TestStatus testGetDisplayPlaneCapabilitiesKHR (void); tcu::TestStatus testCreateDisplayPlaneSurfaceKHR (void); - tcu::TestStatus testCreateSharedSwapchainsKHR (void); + + // VK_KHR_get_display_properties2 extension tests + tcu::TestStatus testGetPhysicalDeviceDisplayProperties2KHR (void); + tcu::TestStatus testGetPhysicalDeviceDisplayPlaneProperties2KHR (void); + tcu::TestStatus testGetDisplayModeProperties2KHR (void); + tcu::TestStatus testGetDisplayPlaneCapabilities2KHR (void); + tcu::TestStatus iterate (void); void testCreateSharedSwapchainsKHRforSurface (VkSurfaceKHR& surface, VkDisplayModePropertiesKHR& modeProperties); @@ -204,6 +237,27 @@ DisplayCoverageTestInstance::DisplayCoverageTestInstance (Context& context, cons if(!de::contains(context.getInstanceExtensions().begin(), context.getInstanceExtensions().end(), extensionName)) TCU_THROW(NotSupportedError, std::string(extensionName + " is not supported").c_str()); + + switch (m_testId) + { + case DISPLAY_TEST_INDEX_GET_DISPLAY_PROPERTIES2: + case DISPLAY_TEST_INDEX_GET_DISPLAY_PLANES2: + case DISPLAY_TEST_INDEX_GET_DISPLAY_MODE2: + case DISPLAY_TEST_INDEX_GET_DISPLAY_PLANE_CAPABILITIES2: + { + const std::string extensionNameAddition("VK_KHR_get_display_properties2"); + + if(!de::contains(context.getInstanceExtensions().begin(), context.getInstanceExtensions().end(), extensionNameAddition)) + TCU_THROW(NotSupportedError, std::string(extensionNameAddition + " is not supported").c_str()); + + break; + } + + default: + { + break; + } + } } /*--------------------------------------------------------------------*//*! @@ -223,6 +277,10 @@ tcu::TestStatus DisplayCoverageTestInstance::iterate (void) case DISPLAY_TEST_INDEX_CREATE_DISPLAY_MODE: return testCreateDisplayModeKHR(); break; case DISPLAY_TEST_INDEX_GET_DISPLAY_PLANE_CAPABILITIES: return testGetDisplayPlaneCapabilitiesKHR(); break; case DISPLAY_TEST_INDEX_CREATE_DISPLAY_PLANE_SURFACE: return testCreateDisplayPlaneSurfaceKHR(); break; + case DISPLAY_TEST_INDEX_GET_DISPLAY_PROPERTIES2: return testGetPhysicalDeviceDisplayProperties2KHR(); break; + case DISPLAY_TEST_INDEX_GET_DISPLAY_PLANES2: return testGetPhysicalDeviceDisplayPlaneProperties2KHR(); break; + case DISPLAY_TEST_INDEX_GET_DISPLAY_MODE2: return testGetDisplayModeProperties2KHR(); break; + case DISPLAY_TEST_INDEX_GET_DISPLAY_PLANE_CAPABILITIES2: return testGetDisplayPlaneCapabilities2KHR(); break; default: { DE_FATAL("Impossible"); @@ -238,7 +296,7 @@ tcu::TestStatus DisplayCoverageTestInstance::iterate (void) * \param displays The vector filled with display handles * \return true on success, false on error *//*--------------------------------------------------------------------*/ -bool DisplayCoverageTestInstance::getDisplays(DisplayVector& displays) +bool DisplayCoverageTestInstance::getDisplays (DisplayVector& displays) { deUint32 countReported = 0u; deUint32 countRetrieved = 0u; @@ -426,6 +484,265 @@ bool DisplayCoverageTestInstance::getDisplayModeProperties(VkDisplayKHR display, } /*--------------------------------------------------------------------*//*! + * \brief Fills vector with available displays. Clears passed vector at start. + * + * Uses VK_KHR_get_display_properties2 extension API. + * Clears passed vector at start. + * + * \param displays The vector filled with display handles + * \return true on success, false on error + *//*--------------------------------------------------------------------*/ +bool DisplayCoverageTestInstance::getDisplays2 (DisplayVector& displays) +{ + deUint32 countReported = 0u; + deUint32 countRetrieved = 0u; + std::vector displaysProps; + VkResult result; + + displays.clear(); + + result = m_vki.getPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, // VkPhysicalDevice physicalDevice + &countReported, // uint32_t* pPropertyCount + DE_NULL); // VkDisplayProperties2KHR* pProperties + + if (result != VK_SUCCESS) + { + m_log << tcu::TestLog::Message + << "vkGetPhysicalDeviceDisplayProperties2KHR failed with " << getResultAsString(result) + << " reported items count " << countReported + << tcu::TestLog::EndMessage; + + return false; + } + + displaysProps.resize(countReported); + + countRetrieved = countReported; + + result = m_vki.getPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, // VkPhysicalDevice physicalDevice + &countRetrieved, // uint32_t* pPropertyCount + &displaysProps[0]); // VkDisplayPropertiesKHR* pProperties + + if (result != VK_SUCCESS || countRetrieved > countReported) + { + m_log << tcu::TestLog::Message + << "vkGetPhysicalDeviceDisplayProperties2KHR failed with " << getResultAsString(result) + << " reported items count " << countReported + << " retrieved items count " << countRetrieved + << tcu::TestLog::EndMessage; + + return false; + } + + displays.reserve(countRetrieved); + + for (deUint32 displayIndex = 0; + displayIndex < countRetrieved; + displayIndex++) + { + const VkDisplayKHR display = displaysProps[displayIndex].displayProperties.display; + + if (display == DE_NULL) + { + displays.clear(); + + return false; + } + + displays.push_back(display); + } + + return true; +} + +/*--------------------------------------------------------------------*//*! + * \brief Fills vector with available modes properties for display specified. + * + * Uses VK_KHR_get_display_properties2 extension API. + * Clears passed vector at start and on error. + * + * \param display The display to get modes for + * \param modes The vector filled with display mode properties structures + * \return true on success, false on error + *//*--------------------------------------------------------------------*/ +bool DisplayCoverageTestInstance::getDisplayModeProperties2 (VkDisplayKHR display, DisplayModeProperties2Vector& modeProperties) +{ + deUint32 countReported = 0u; + deUint32 countRetrieved = 0u; + VkResult result; + + modeProperties.clear(); + + result = m_vki.getDisplayModeProperties2KHR( m_physicalDevice, // VkPhysicalDevice physicalDevice + display, // VkDisplayKHR display + &countReported, // uint32_t* pPropertyCount + DE_NULL); // VkDisplayModeProperties2KHR* pProperties + + if (result != VK_SUCCESS) + { + m_log << tcu::TestLog::Message + << "vkGetDisplayModeProperties2KHR failed with " << getResultAsString(result) + << " for display " << display + << " reported items count " << countReported + << tcu::TestLog::EndMessage; + + return false; + } + + modeProperties.resize(countReported); + + countRetrieved = countReported; + + result = m_vki.getDisplayModeProperties2KHR( m_physicalDevice, // VkPhysicalDevice physicalDevice + display, // VkDisplayKHR display + &countRetrieved, // uint32_t* pPropertyCount + &modeProperties[0]); // VkDisplayModeProperties2KHR* pProperties + + if (result != VK_SUCCESS || countRetrieved > countReported) + { + m_log << tcu::TestLog::Message + << "vkGetDisplayModeProperties2KHR failed with " << getResultAsString(result) + << " for display " << display + << " reported items count " << countReported + << " retrieved items count " << countReported + << tcu::TestLog::EndMessage; + + modeProperties.clear(); + + return false; + } + + if (countRetrieved < countReported) + modeProperties.resize(countRetrieved); + + return true; +} + +/*--------------------------------------------------------------------*//*! + * \brief Validate display properties and report failures + * into results collector + * + * \param results Results collector + * \param toValidate Display properties to validate + * \param nonUpdated Display properties to compare with + *//*--------------------------------------------------------------------*/ +void DisplayCoverageTestInstance::validateDisplayProperties ( tcu::ResultCollector& results, + const VkDisplayPropertiesKHR& toValidate, + const VkDisplayPropertiesKHR& nonUpdated) +{ + results.check( toValidate.display != nonUpdated.display, + "Invalid display handle"); + + results.check( toValidate.planeReorderPossible == VK_TRUE || toValidate.planeReorderPossible == VK_FALSE, + "planeReorderPossible neither VK_TRUE, nor VK_FALSE"); + + results.check( toValidate.persistentContent == VK_TRUE || toValidate.persistentContent == VK_FALSE, + "persistentContent neither VK_TRUE, nor VK_FALSE"); + + results.check( (toValidate.supportedTransforms & nonUpdated.supportedTransforms) == 0, + "supportedTransforms contains unrecognized flags"); + + // Outside specification, but resolution 0x0 pixels will break many applications + results.check( toValidate.physicalResolution.height != 0, + "physicalResolution.height cannot be zero"); + + // Outside specification, but resolution 0x0 pixels will break many applications + results.check( toValidate.physicalResolution.width != 0, + "physicalResolution.width cannot be zero"); +} + +/*--------------------------------------------------------------------*//*! + * \brief Validates display plane properties and report failures + * into results collector + * + * \param results Results collector + * \param toValidate Display plane properties to validate + * \param nonUpdated Display plane properties to compare with + * \param displaySet Set of valid display handles + *//*--------------------------------------------------------------------*/ +void DisplayCoverageTestInstance::validateDisplayPlaneProperties ( tcu::ResultCollector& results, + const VkDisplayPlanePropertiesKHR& toValidate, + const VkDisplayPlanePropertiesKHR& nonUpdated, + DisplaySet& displaySet) +{ + const VkDisplayKHR currentDisplay = toValidate.currentDisplay; + + results.check( toValidate.currentStackIndex < nonUpdated.currentStackIndex, + "CurrentStackIndex must be less than the number of planes reported " + de::toString(nonUpdated.currentStackIndex)); + + results.check( currentDisplay == DE_NULL || de::contains(displaySet, currentDisplay), + "Plane bound to invalid handle " + de::toString(toValidate.currentDisplay)); +} + +/*--------------------------------------------------------------------*//*! + * \brief Validate display plane capabilities and report failures + * into results collector + * + * \param results Results collector + * \param toValidate Display plane capabilities to validate + * \param nonUpdated Display plane capabilities to compare with + *//*--------------------------------------------------------------------*/ +void DisplayCoverageTestInstance::validateDisplayPlaneCapabilities ( tcu::ResultCollector& results, + const VkDisplayPlaneCapabilitiesKHR& toValidate, + const VkDisplayPlaneCapabilitiesKHR& nonUpdated) +{ + results.check( (toValidate.supportedAlpha & nonUpdated.supportedAlpha) == 0, + "supportedAlpha contains unrecognized value"); + + results.check( toValidate.minSrcPosition.x >= 0, + "minSrcPosition.x >= 0"); + + results.check( toValidate.minSrcPosition.y >= 0, + "minSrcPosition.y >= 0"); + + results.check( toValidate.maxSrcPosition.x >= 0, + "maxSrcPosition.x >= 0"); + + results.check( toValidate.maxSrcPosition.y >= 0, + "maxSrcPosition.y >= 0"); + + results.check( toValidate.minSrcPosition.x <= toValidate.maxSrcPosition.x, + "minSrcPosition.x <= maxSrcPosition.x"); + + results.check( toValidate.minSrcPosition.y <= toValidate.maxSrcPosition.y, + "minSrcPosition.y <= maxSrcPosition.y"); + + results.check( toValidate.minDstPosition.x <= toValidate.maxDstPosition.x, + "minDstPosition.x <= maxDstPosition.x"); + + results.check( toValidate.minDstPosition.y <= toValidate.maxDstPosition.y, + "minDstPosition.y <= maxDstPosition.y"); + + results.check( toValidate.minSrcExtent.width <= toValidate.maxSrcExtent.width, + "minSrcExtent.width <= maxSrcExtent.width"); + + results.check( toValidate.minSrcExtent.height <= toValidate.maxSrcExtent.height, + "minSrcExtent.height <= maxSrcExtent.height"); + + results.check( toValidate.minDstExtent.width <= toValidate.maxDstExtent.width, + "minDstExtent.width <= maxDstExtent.width"); + + results.check( toValidate.minDstExtent.height <= toValidate.maxDstExtent.height, + "minDstExtent.height <= maxDstExtent.height"); +} + +/*--------------------------------------------------------------------*//*! + * \brief Validate display mode properties and report failures + * into results collector + * + * \param results Results collector + * \param toValidate Display mode properties to validate + * \param nonUpdated Display mode properties to compare with + *//*--------------------------------------------------------------------*/ +void DisplayCoverageTestInstance::validateDisplayModeProperties ( tcu::ResultCollector& results, + const VkDisplayModePropertiesKHR& toValidate, + const VkDisplayModePropertiesKHR& nonUpdated) +{ + results.check( toValidate.displayMode != nonUpdated.displayMode, + "Invalid mode display handle reported"); +} + +/*--------------------------------------------------------------------*//*! * \brief Display enumeration coverage test * * Throws ResourceError exception in case no displays available. @@ -433,7 +750,7 @@ bool DisplayCoverageTestInstance::getDisplayModeProperties(VkDisplayKHR display, * * \return tcu::TestStatus::pass on success *//*--------------------------------------------------------------------*/ -tcu::TestStatus DisplayCoverageTestInstance::testGetPhysicalDeviceDisplayPropertiesKHR(void) +tcu::TestStatus DisplayCoverageTestInstance::testGetPhysicalDeviceDisplayPropertiesKHR (void) { deUint32 displayCountReported = 0u; deUint32 displayCountToTest = 0u; @@ -571,7 +888,7 @@ tcu::TestStatus DisplayCoverageTestInstance::testGetPhysicalDeviceDisplayPropert * * \return tcu::TestStatus::pass on success *//*--------------------------------------------------------------------*/ -tcu::TestStatus DisplayCoverageTestInstance::testGetPhysicalDeviceDisplayPlanePropertiesKHR(void) +tcu::TestStatus DisplayCoverageTestInstance::testGetPhysicalDeviceDisplayPlanePropertiesKHR (void) { DisplayVector displaysVector; DisplaySet displaySet; @@ -696,7 +1013,7 @@ tcu::TestStatus DisplayCoverageTestInstance::testGetPhysicalDeviceDisplayPlanePr * * \return tcu::TestStatus::pass on success *//*--------------------------------------------------------------------*/ -tcu::TestStatus DisplayCoverageTestInstance::testGetDisplayPlaneSupportedDisplaysKHR(void) +tcu::TestStatus DisplayCoverageTestInstance::testGetDisplayPlaneSupportedDisplaysKHR (void) { deUint32 planeCountReported = 0u; deUint32 planeCountTested = 0u; @@ -823,7 +1140,7 @@ tcu::TestStatus DisplayCoverageTestInstance::testGetDisplayPlaneSupportedDisplay * * \return tcu::TestStatus::pass on success *//*--------------------------------------------------------------------*/ -tcu::TestStatus DisplayCoverageTestInstance::testGetDisplayModePropertiesKHR(void) +tcu::TestStatus DisplayCoverageTestInstance::testGetDisplayModePropertiesKHR (void) { VkResult result; DisplayVector displaysVector; @@ -915,7 +1232,7 @@ tcu::TestStatus DisplayCoverageTestInstance::testGetDisplayModePropertiesKHR(voi * * \return tcu::TestStatus::pass on success *//*--------------------------------------------------------------------*/ -tcu::TestStatus DisplayCoverageTestInstance::testCreateDisplayModeKHR(void) +tcu::TestStatus DisplayCoverageTestInstance::testCreateDisplayModeKHR (void) { DisplayVector displaysVector; VkResult result; @@ -1024,7 +1341,7 @@ tcu::TestStatus DisplayCoverageTestInstance::testCreateDisplayModeKHR(void) * * \return tcu::TestStatus::pass on success *//*--------------------------------------------------------------------*/ -tcu::TestStatus DisplayCoverageTestInstance::testGetDisplayPlaneCapabilitiesKHR(void) +tcu::TestStatus DisplayCoverageTestInstance::testGetDisplayPlaneCapabilitiesKHR (void) { deUint32 planeCountReported = 0u; VkResult result; @@ -1165,7 +1482,7 @@ tcu::TestStatus DisplayCoverageTestInstance::testGetDisplayPlaneCapabilitiesKHR( * * \return tcu::TestStatus::pass on success *//*--------------------------------------------------------------------*/ -tcu::TestStatus DisplayCoverageTestInstance::testCreateDisplayPlaneSurfaceKHR(void) +tcu::TestStatus DisplayCoverageTestInstance::testCreateDisplayPlaneSurfaceKHR (void) { deUint32 planeCountReported = 0u; deUint32 planeCountTested = 0u; @@ -1322,50 +1639,564 @@ tcu::TestStatus DisplayCoverageTestInstance::testCreateDisplayPlaneSurfaceKHR(vo return tcu::TestStatus::pass("pass"); } - /*--------------------------------------------------------------------*//*! - * \brief Display coverage tests case class + * \brief Display enumeration coverage test using VK_KHR_get_display_properties2 + * + * Throws ResourceError exception in case no displays available. + * Throws an exception on fail. + * + * \return tcu::TestStatus::pass on success *//*--------------------------------------------------------------------*/ -class DisplayCoverageTestsCase : public vkt::TestCase +tcu::TestStatus DisplayCoverageTestInstance::testGetPhysicalDeviceDisplayProperties2KHR (void) { -public: - DisplayCoverageTestsCase (tcu::TestContext &context, const char *name, const char *description, const DisplayIndexTest testId) - : TestCase (context, name, description) - , m_testId (testId) + deUint32 displayCountReported = 0u; + deUint32 displayCountToTest = 0u; + tcu::ResultCollector results (m_log); + VkResult result; + + result = m_vki.getPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, // VkPhysicalDevice physicalDevice + &displayCountReported, // uint32_t* pPropertyCount + DE_NULL); // VkDisplayProperties2KHR* pProperties + + if ( result != VK_SUCCESS + && result != VK_INCOMPLETE + && result != VK_ERROR_OUT_OF_HOST_MEMORY + && result != VK_ERROR_OUT_OF_DEVICE_MEMORY + ) { + TCU_FAIL_STR(string("Invalid result ") + getResultAsString(result)); } -private: - const DisplayIndexTest m_testId; - vkt::TestInstance* createInstance (vkt::Context& context) const + if (result != VK_SUCCESS) + TCU_FAIL_STR(string("Expected VK_SUCCESS. Have ") + getResultAsString(result)); + + if (displayCountReported == 0) + TCU_THROW(ResourceError, std::string("Cannot perform test: no displays found").c_str()); + + displayCountToTest = displayCountReported; + if (displayCountReported > MAX_TESTED_DISPLAY_COUNT) { - return new DisplayCoverageTestInstance(context, m_testId); + m_log << tcu::TestLog::Message + << "Number of displays reported is too high " << displayCountReported + << ". Test is limited to " << MAX_TESTED_DISPLAY_COUNT + << tcu::TestLog::EndMessage; + + displayCountToTest = MAX_TESTED_DISPLAY_COUNT; } -}; + // Test the call correctly writes data in various size arrays + for (deUint32 displayCountRequested = 0; + displayCountRequested < displayCountToTest + 2; + displayCountRequested++) + { + const deUint32 displayCountExpected = std::min(displayCountRequested, displayCountReported); + const VkDisplayPropertiesKHR nonUpdatedDisplayProperties = { // Most values are set to fail the test to make sure driver updates them + DE_NULL, // VkDisplayKHR display + DE_NULL, // const char* displayName + {0, 0}, // VkExtent2D physicalDimensions + {0, 0}, // VkExtent2D physicalResolution + ~RECOGNIZED_SURFACE_TRANSFORM_FLAGS, // VkSurfaceTransformFlagsKHR supportedTransforms + (vk::VkBool32)(VK_TRUE + 1), // VkBool32 planeReorderPossible + (vk::VkBool32)(VK_TRUE + 1) // VkBool32 persistentContent + }; + const VkStructureType queryStructureType = VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR; + const VkDisplayProperties2KHR nonUpdatedDisplayProperties2 = { + queryStructureType, // VkStructureType sType + DE_NULL, // void* pNext + nonUpdatedDisplayProperties // VkDisplayPropertiesKHR displayProperties + }; + VkStructureType canaryItem = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; // Some invalid but compilable value + const deUint32 canaryItemCount = 1; + std::vector displaysProps2 (displayCountRequested + canaryItemCount, nonUpdatedDisplayProperties2); + deUint32 displayCountRetrieved = displayCountRequested; + DisplaySet displaySet; + + displaysProps2[displayCountExpected].sType = canaryItem; -/*--------------------------------------------------------------------*//*! - * \brief Adds a test into group - *//*--------------------------------------------------------------------*/ -static void addTest (tcu::TestCaseGroup* group, const DisplayIndexTest testId, const char* name, const char* description) -{ - tcu::TestContext& testCtx = group->getTestContext(); + result = m_vki.getPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, // VkPhysicalDevice physicalDevice + &displayCountRetrieved, // uint32_t* pPropertyCount + &displaysProps2[0]); // VkDisplayProperties2KHR* pProperties - group->addChild(new DisplayCoverageTestsCase(testCtx, name, description, testId)); -} + // Check amount of data written equals to expected + if (displayCountRetrieved != displayCountExpected) + TCU_FAIL_STR( string("displayCountRetrieved != displayCountExpected, ") + + de::toString(displayCountRetrieved) + " != " + de::toString(displayCountExpected)); -/*--------------------------------------------------------------------*//*! - * \brief Adds VK_KHR_display and VK_KHR_display_swapchain extension tests into group - *//*--------------------------------------------------------------------*/ -void createDisplayCoverageTests (tcu::TestCaseGroup* group) -{ - addTest(group, DISPLAY_TEST_INDEX_GET_DISPLAY_PROPERTIES, "get_display_properties", "Display enumeration coverage test"); - addTest(group, DISPLAY_TEST_INDEX_GET_DISPLAY_PLANES, "get_display_plane_properties", "Planes enumeration coverage test"); - addTest(group, DISPLAY_TEST_INDEX_GET_DISPLAY_PLANE_SUPPORTED_DISPLAY, "get_display_plane_supported_displays", "Display plane support coverage test"); - addTest(group, DISPLAY_TEST_INDEX_GET_DISPLAY_MODE, "get_display_mode_properties", "Display mode properties coverage test"); - addTest(group, DISPLAY_TEST_INDEX_CREATE_DISPLAY_MODE, "create_display_mode", "Create display mode coverage test"); - addTest(group, DISPLAY_TEST_INDEX_GET_DISPLAY_PLANE_CAPABILITIES, "get_display_plane_capabilities", "Display-plane capabilities coverage test"); - addTest(group, DISPLAY_TEST_INDEX_CREATE_DISPLAY_PLANE_SURFACE, "create_display_plane_surface", "Create display plane surface coverage test"); + if (displayCountRequested >= displayCountReported) + { + if (result != VK_SUCCESS) + TCU_FAIL_STR(string("Expected VK_SUCCESS. Have ") + getResultAsString(result)); + } + else + { + if (result != VK_INCOMPLETE) + TCU_FAIL_STR(string("Expected VK_INCOMPLETE. Have ") + getResultAsString(result)); + } + + // Check the driver has written something + for (deUint32 displayIndex = 0; + displayIndex < displayCountRetrieved; + displayIndex++) + { + const VkDisplayProperties2KHR& properties2 = displaysProps2[displayIndex]; + const VkDisplayPropertiesKHR& properties = properties2.displayProperties; + + displaySet.insert(properties.display); + + results.check( properties2.sType == queryStructureType, + "sType has changed to " + de::toString(properties2.sType)); + + results.check( properties2.pNext == DE_NULL, + "pNext has changed to " + de::toString(properties2.pNext)); + + validateDisplayProperties(results, properties, nonUpdatedDisplayProperties); + + if (results.getResult() != QP_TEST_RESULT_PASS) + { + m_log << tcu::TestLog::Message + << "Error detected " << results.getMessage() + << " for display " << displayIndex << " with properties " << properties2 + << " non updated display properties are " << nonUpdatedDisplayProperties2 + << tcu::TestLog::EndMessage; + + TCU_FAIL_STR(results.getMessage()); + } + } + + // Check the driver has not written more than requested + if (displaysProps2[displayCountExpected].sType != canaryItem) + TCU_FAIL("Memory damage detected: driver has written more than expected"); + + // Check display handle uniqueness + if (displaySet.size() != displayCountRetrieved) + TCU_FAIL("Display handle duplication detected"); + } + + return tcu::TestStatus::pass("pass"); +} + +/*--------------------------------------------------------------------*//*! + * \brief Plane enumeration coverage test using VK_KHR_get_display_properties2 + * + * Throws an exception on fail. + * + * \return tcu::TestStatus::pass on success + *//*--------------------------------------------------------------------*/ +tcu::TestStatus DisplayCoverageTestInstance::testGetPhysicalDeviceDisplayPlaneProperties2KHR (void) +{ + DisplayVector displaysVector; + DisplaySet displaySet; + deUint32 planeCountReported = 0u; + deUint32 planeCountTested = 0u; + tcu::ResultCollector results (m_log); + VkResult result; + + // Create a list of displays available + if (!getDisplays2(displaysVector)) + TCU_FAIL("Failed to retrieve displays"); + + if (displaysVector.empty()) + TCU_FAIL("No displays reported"); + + displaySet = DisplaySet(displaysVector.begin(), displaysVector.end()); + + // Get planes to test + result = m_vki.getPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, // VkPhysicalDevice physicalDevice + &planeCountReported, // uint32_t* pPropertyCount + DE_NULL); // VkDisplayPlaneProperties2KHR* pProperties + + if ( result != VK_SUCCESS + && result != VK_INCOMPLETE + && result != VK_ERROR_OUT_OF_HOST_MEMORY + && result != VK_ERROR_OUT_OF_DEVICE_MEMORY + ) + { + TCU_FAIL_STR(string("Invalid result ") + getResultAsString(result)); + } + + if (result != VK_SUCCESS) + TCU_FAIL_STR(string("Expected VK_SUCCESS. Have ") + getResultAsString(result)); + + if (planeCountReported == 0) + TCU_THROW(ResourceError, "Cannot perform test: no planes found"); + + planeCountTested = planeCountReported; + if (planeCountReported > MAX_TESTED_PLANE_COUNT) + { + m_log << tcu::TestLog::Message + << "Number of planes reported is too high " << planeCountReported + << ". Test is limited to " << MAX_TESTED_PLANE_COUNT + << tcu::TestLog::EndMessage; + + planeCountTested = MAX_TESTED_PLANE_COUNT; + } + + // Test the call correctly writes data in various size arrays + for (deUint32 planeCountRequested = 0; + planeCountRequested < planeCountTested + 2; + planeCountRequested++) + { + const deUint32 planeCountExpected = std::min(planeCountRequested, planeCountReported); + const VkDisplayPlanePropertiesKHR nonUpdatedPlaneProperties = { // Most values are set to fail the test to make sure driver updates them + DE_NULL, // VkDisplayKHR currentDisplay + planeCountReported // deUint32 currentStackIndex + }; + const VkStructureType queryStructureType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR; + const VkDisplayPlaneProperties2KHR nonUpdatedPlaneProperties2 = { + queryStructureType, // VkStructureType sType + DE_NULL, // void* pNext + nonUpdatedPlaneProperties // VkDisplayPlanePropertiesKHR displayPlaneProperties + }; + VkStructureType canaryItem = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; // Some invalid but compilable value + const deUint32 canaryItemCount = 1; + std::vector planeProps2 (planeCountRequested + canaryItemCount, nonUpdatedPlaneProperties2); + deUint32 planeCountRetrieved = planeCountRequested; + + planeProps2[planeCountExpected].sType = canaryItem; + + result = m_vki.getPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, // VkPhysicalDevice physicalDevice + &planeCountRetrieved, // uint32_t* pPropertyCount + &planeProps2[0]); // VkDisplayPlaneProperties2KHR* pProperties + + // Check amount of data written equals to expected + if (planeCountRetrieved != planeCountExpected) + TCU_FAIL_STR( string("planeCountRetrieved != planeCountExpected, ") + + de::toString(planeCountRetrieved) + " != " + de::toString(planeCountExpected)); + + if (planeCountRequested >= planeCountReported) + { + if (result != VK_SUCCESS) + TCU_FAIL_STR(string("Expected VK_SUCCESS. Have ") + getResultAsString(result)); + } + else + { + if (result != VK_INCOMPLETE) + TCU_FAIL_STR(string("Expected VK_INCOMPLETE. Have ") + getResultAsString(result)); + } + + // Check the driver has written something + for (deUint32 planeIndex = 0; + planeIndex < planeCountRetrieved; + planeIndex++) + { + const VkDisplayPlaneProperties2KHR& properties2 = planeProps2[planeIndex]; + const VkDisplayPlanePropertiesKHR& properties = properties2.displayPlaneProperties; + + results.check( properties2.sType == queryStructureType, + "sType has changed to " + de::toString(properties2.sType)); + + results.check( properties2.pNext == DE_NULL, + "pNext has changed to " + de::toString(properties2.pNext)); + + validateDisplayPlaneProperties(results, properties, nonUpdatedPlaneProperties, displaySet); + + if (results.getResult() != QP_TEST_RESULT_PASS) + { + m_log << tcu::TestLog::Message + << "Error detected " << results.getMessage() + << " for plane " << planeIndex << " with properties " << properties2 + << tcu::TestLog::EndMessage; + + TCU_FAIL_STR(results.getMessage()); + } + } + + // Check the driver has not written more than requested + if (planeProps2[planeCountExpected].sType != canaryItem) + TCU_FAIL("Memory damage detected: driver has written more than expected"); + } + + return tcu::TestStatus::pass("pass"); +} + +/*--------------------------------------------------------------------*//*! + * \brief Display-plane capabilities coverage test using VK_KHR_get_display_properties2 + * + * Throws an exception on fail. + * + * \return tcu::TestStatus::pass on success + *//*--------------------------------------------------------------------*/ +tcu::TestStatus DisplayCoverageTestInstance::testGetDisplayPlaneCapabilities2KHR (void) +{ + deUint32 planeCountReported = 0u; + VkResult result; + + result = m_vki.getPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, // VkPhysicalDevice physicalDevice + &planeCountReported, // uint32_t* pPropertyCount + DE_NULL); // VkDisplayPlaneProperties2KHR* pProperties + + if (result != VK_SUCCESS) + TCU_FAIL_STR(string("Expected VK_SUCCESS. Have ") + getResultAsString(result)); + + if (planeCountReported == 0) + TCU_FAIL("No planes defined"); + + if (planeCountReported > MAX_TESTED_PLANE_COUNT) + { + m_log << tcu::TestLog::Message + << "Number of planes reported is too high " << planeCountReported + << ". Test is limited to " << MAX_TESTED_PLANE_COUNT + << tcu::TestLog::EndMessage; + + planeCountReported = MAX_TESTED_PLANE_COUNT; + } + + for (deUint32 planeIndex = 0; + planeIndex < planeCountReported; + planeIndex++) + { + std::vector displaysForPlane; + + if (!getDisplaysForPlane(planeIndex, displaysForPlane)) + TCU_FAIL_STR("Failed to retrieve displays list for plane " + de::toString(planeIndex)); + + if (displaysForPlane.empty()) + continue; + + // Check the driver has written something + for (deUint32 displayIndex = 0; + displayIndex < displaysForPlane.size(); + displayIndex++) + { + const VkDisplayKHR display = displaysForPlane[displayIndex]; + std::vector modesPropertiesForDisplay; + + if (!getDisplayModeProperties2(display, modesPropertiesForDisplay)) + TCU_FAIL("Failed to retrieve display mode properties"); + + for (deUint32 modeIndex = 0; + modeIndex < modesPropertiesForDisplay.size(); + modeIndex++) + { + const VkDisplayModeKHR displayMode = modesPropertiesForDisplay[modeIndex].displayModeProperties.displayMode; + const deUint32 unrecognizedAlphaFlags = ~RECOGNIZED_DISPLAY_PLANE_ALPHA_FLAGS; + const VkDisplayPlaneInfo2KHR planeInfo2 = { + VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR, // VkStructureType sType + DE_NULL, // const void* pNext + displayMode, // VkDisplayModeKHR mode + planeIndex // uint32_t planeIndex + }; + VkDisplayPlaneCapabilitiesKHR planeCapabilities = { + unrecognizedAlphaFlags, // VkDisplayPlaneAlphaFlagsKHR supportedAlpha + { -1, -1 }, // VkOffset2D minSrcPosition + { -1, -1 }, // VkOffset2D maxSrcPosition + { 1, 1 }, // VkExtent2D minSrcExtent + { 0, 0 }, // VkExtent2D maxSrcExtent + { 1, 1 }, // VkOffset2D minDstPosition + { 0, 0 }, // VkOffset2D maxDstPosition + { 1, 1 }, // VkExtent2D minDstExtent + { 0, 0 }, // VkExtent2D maxDstExtent + }; + const VkStructureType queryStructureType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR; + VkDisplayPlaneCapabilities2KHR planeCapabilities2 = { + queryStructureType, // VkStructureType sType + DE_NULL, // void* pNext + planeCapabilities // VkDisplayPlaneCapabilitiesKHR capabilities + }; + tcu::ResultCollector results (m_log); + + result = m_vki.getDisplayPlaneCapabilities2KHR( m_physicalDevice, // VkPhysicalDevice physicalDevice + &planeInfo2, // const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo + &planeCapabilities2); // VkDisplayPlaneCapabilities2KHR* pCapabilities + + results.check( result == VK_SUCCESS, + string("Expected VK_SUCCESS. Have ") + getResultAsString(result)); + + results.check( planeCapabilities2.sType == queryStructureType, + "sType has changed to " + de::toString(planeCapabilities2.sType)); + + results.check( planeCapabilities2.pNext == DE_NULL, + "pNext has changed to " + de::toString(planeCapabilities2.pNext)); + + // Validate results returned by driver in planeCapabilities2 using non-updated planeCapabilities + validateDisplayPlaneCapabilities(results, planeCapabilities2.capabilities, planeCapabilities); + + if (results.getResult() != QP_TEST_RESULT_PASS) + { + m_log << tcu::TestLog::Message + << "Error detected " << results.getMessage() + << " for plane's " << planeIndex + << " display " << displayIndex + << " and mode " << modeIndex + << " with capabilities " << planeCapabilities2 + << tcu::TestLog::EndMessage; + + TCU_FAIL_STR(results.getMessage()); + } + } + } + } + + return tcu::TestStatus::pass("pass"); +} + +/*--------------------------------------------------------------------*//*! + * \brief Display mode properties coverage test using VK_KHR_get_display_properties2 + * + * Throws an exception on fail. + * + * \return tcu::TestStatus::pass on success + *//*--------------------------------------------------------------------*/ +tcu::TestStatus DisplayCoverageTestInstance::testGetDisplayModeProperties2KHR (void) +{ + VkResult result; + tcu::ResultCollector results (m_log); + DisplayVector displaysVector; + + if (!getDisplays2(displaysVector)) + TCU_FAIL("Failed to retrieve displays list"); + + if (displaysVector.empty()) + TCU_FAIL("No displays reported"); + + for (DisplayVector::iterator it = displaysVector.begin(); + it != displaysVector.end(); + it++) + { + VkDisplayKHR display = *it; + deUint32 modesCountReported = 0u; + + result = m_vki.getDisplayModeProperties2KHR( m_physicalDevice, // VkPhysicalDevice physicalDevice + display, // VkDisplayKHR display + &modesCountReported, // uint32_t* pPropertyCount + DE_NULL); // VkDisplayModeProperties2KHR* pProperties + + // Test the call correctly writes data in various size arrays + for (deUint32 modesCountRequested = 0; + modesCountRequested < modesCountReported + 2; + modesCountRequested = nextTestNumber(modesCountRequested, modesCountReported + 2)) + { + const deUint32 modesCountExpected = std::min(modesCountRequested, modesCountReported); + const VkDisplayModeKHR nullDisplayMode = DE_NULL; + const VkDisplayModePropertiesKHR nonUpdatedModeProperties = { + nullDisplayMode, // VkDisplayModeKHR displayMode + { // VkDisplayModeParametersKHR parameters + {0, 0}, // VkExtent2D visibleRegion + 0 // uint32_t refreshRate + } + }; + const VkStructureType queryStructureType = VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR; + const VkDisplayModeProperties2KHR nonUpdatedModeProperties2 = { + queryStructureType, // VkStructureType sType + DE_NULL, // void* pNext + nonUpdatedModeProperties // VkDisplayModePropertiesKHR displayModeProperties + }; + VkStructureType canaryItem = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; // Some invalid but compilable value + const deUint32 canaryItemCount = 1; + std::vector modesProperties2 (modesCountRequested + canaryItemCount, nonUpdatedModeProperties2); + deUint32 modesCountRetrieved = modesCountRequested; + + modesProperties2[modesCountExpected].sType = canaryItem; + + result = m_vki.getDisplayModeProperties2KHR(m_physicalDevice, // VkPhysicalDevice physicalDevice + display, // VkDisplayKHR display + &modesCountRetrieved, // uint32_t* pPropertyCount + &modesProperties2[0]); // VkDisplayModeProperties2KHR* pProperties + + // Check amount of data written equals to expected + if (modesCountRetrieved != modesCountExpected) + TCU_FAIL_STR( string("modesCountRetrieved != modesCountExpected, ") + + de::toString(modesCountRetrieved) + " != " + de::toString(modesCountExpected)); + + if (modesCountRequested >= modesCountReported) + { + if (result != VK_SUCCESS) + TCU_FAIL_STR(string("Expected VK_SUCCESS. Have ") + getResultAsString(result)); + } + else + { + if (result != VK_INCOMPLETE) + TCU_FAIL_STR(string("Expected VK_INCOMPLETE. Have ") + getResultAsString(result)); + } + + // Check the driver has written something + for (deUint32 modeIndex = 0; + modeIndex < modesCountExpected; + modeIndex++) + { + const VkDisplayModeProperties2KHR& properties2 = modesProperties2[modeIndex]; + const VkDisplayModePropertiesKHR& properties = properties2.displayModeProperties; + + results.check( properties2.sType == queryStructureType, + "sType has changed to " + de::toString(properties2.sType)); + + results.check( properties2.pNext == DE_NULL, + "pNext has changed to " + de::toString(properties2.pNext)); + + validateDisplayModeProperties(results, properties, nonUpdatedModeProperties); + + if (results.getResult() != QP_TEST_RESULT_PASS) + { + m_log << tcu::TestLog::Message + << "Error detected " << results.getMessage() + << " for mode " << modeIndex << " with properties " << properties2 + << " non updated mode properties are " << nonUpdatedModeProperties2 + << tcu::TestLog::EndMessage; + + TCU_FAIL_STR(results.getMessage()); + } + } + + // Check the driver has not written more than requested + if (modesProperties2[modesCountExpected].sType != canaryItem) + TCU_FAIL("Memory damage detected: driver has written more than expected"); + } + } + + return tcu::TestStatus::pass("pass"); +} + + +/*--------------------------------------------------------------------*//*! + * \brief Display coverage tests case class + *//*--------------------------------------------------------------------*/ +class DisplayCoverageTestsCase : public vkt::TestCase +{ +public: + DisplayCoverageTestsCase (tcu::TestContext &context, const char *name, const char *description, const DisplayIndexTest testId) + : TestCase (context, name, description) + , m_testId (testId) + { + } +private: + const DisplayIndexTest m_testId; + + vkt::TestInstance* createInstance (vkt::Context& context) const + { + return new DisplayCoverageTestInstance(context, m_testId); + } +}; + + +/*--------------------------------------------------------------------*//*! + * \brief Adds a test into group + *//*--------------------------------------------------------------------*/ +static void addTest (tcu::TestCaseGroup* group, const DisplayIndexTest testId, const char* name, const char* description) +{ + tcu::TestContext& testCtx = group->getTestContext(); + + group->addChild(new DisplayCoverageTestsCase(testCtx, name, description, testId)); +} + +/*--------------------------------------------------------------------*//*! + * \brief Adds VK_KHR_display and VK_KHR_display_swapchain extension tests into group + *//*--------------------------------------------------------------------*/ +void createDisplayCoverageTests (tcu::TestCaseGroup* group) +{ + // VK_KHR_display extension tests + addTest(group, DISPLAY_TEST_INDEX_GET_DISPLAY_PROPERTIES, "get_display_properties", "Display enumeration coverage test"); + addTest(group, DISPLAY_TEST_INDEX_GET_DISPLAY_PLANES, "get_display_plane_properties", "Planes enumeration coverage test"); + addTest(group, DISPLAY_TEST_INDEX_GET_DISPLAY_PLANE_SUPPORTED_DISPLAY, "get_display_plane_supported_displays", "Display plane support coverage test"); + addTest(group, DISPLAY_TEST_INDEX_GET_DISPLAY_MODE, "get_display_mode_properties", "Display mode properties coverage test"); + addTest(group, DISPLAY_TEST_INDEX_CREATE_DISPLAY_MODE, "create_display_mode", "Create display mode coverage test"); + addTest(group, DISPLAY_TEST_INDEX_GET_DISPLAY_PLANE_CAPABILITIES, "get_display_plane_capabilities", "Display-plane capabilities coverage test"); + addTest(group, DISPLAY_TEST_INDEX_CREATE_DISPLAY_PLANE_SURFACE, "create_display_plane_surface", "Create display plane surface coverage test"); + + // VK_KHR_get_display_properties2 extension tests + addTest(group, DISPLAY_TEST_INDEX_GET_DISPLAY_PROPERTIES2, "get_display_properties2", "Display enumeration coverage test using VK_KHR_get_display_properties2"); + addTest(group, DISPLAY_TEST_INDEX_GET_DISPLAY_PLANES2, "get_display_plane_properties2", "Planes enumeration coverage test using VK_KHR_get_display_properties2"); + addTest(group, DISPLAY_TEST_INDEX_GET_DISPLAY_MODE2, "get_display_mode_properties2", "Display mode properties coverage test using VK_KHR_get_display_properties2"); + addTest(group, DISPLAY_TEST_INDEX_GET_DISPLAY_PLANE_CAPABILITIES2, "get_display_plane_capabilities2", "Display-plane capabilities coverage test using VK_KHR_get_display_properties2"); } } //wsi diff --git a/external/vulkancts/mustpass/1.1.0/vk-default.txt b/external/vulkancts/mustpass/1.1.0/vk-default.txt index b379a73..84af97c 100755 --- a/external/vulkancts/mustpass/1.1.0/vk-default.txt +++ b/external/vulkancts/mustpass/1.1.0/vk-default.txt @@ -221899,6 +221899,10 @@ dEQP-VK.wsi.display.get_display_mode_properties dEQP-VK.wsi.display.create_display_mode dEQP-VK.wsi.display.get_display_plane_capabilities dEQP-VK.wsi.display.create_display_plane_surface +dEQP-VK.wsi.display.get_display_properties2 +dEQP-VK.wsi.display.get_display_plane_properties2 +dEQP-VK.wsi.display.get_display_mode_properties2 +dEQP-VK.wsi.display.get_display_plane_capabilities2 dEQP-VK.synchronization.smoke.fences dEQP-VK.synchronization.smoke.semaphores dEQP-VK.synchronization.smoke.events diff --git a/external/vulkancts/scripts/src/vulkan.h.in b/external/vulkancts/scripts/src/vulkan.h.in index 89e6b33..531cc9b 100644 --- a/external/vulkancts/scripts/src/vulkan.h.in +++ b/external/vulkancts/scripts/src/vulkan.h.in @@ -5780,6 +5780,71 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( VkSurfaceFormat2KHR* pSurfaceFormats); #endif +#define VK_KHR_get_display_properties2 1 +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2" + +typedef struct VkDisplayProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPropertiesKHR displayProperties; +} VkDisplayProperties2KHR; + +typedef struct VkDisplayPlaneProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlanePropertiesKHR displayPlaneProperties; +} VkDisplayPlaneProperties2KHR; + +typedef struct VkDisplayModeProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayModePropertiesKHR displayModeProperties; +} VkDisplayModeProperties2KHR; + +typedef struct VkDisplayPlaneInfo2KHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeKHR mode; + uint32_t planeIndex; +} VkDisplayPlaneInfo2KHR; + +typedef struct VkDisplayPlaneCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlaneCapabilitiesKHR capabilities; +} VkDisplayPlaneCapabilities2KHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlaneProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModeProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR* pCapabilities); +#endif + + #define VK_KHR_variable_pointers 1 typedef VkPhysicalDeviceVariablePointerFeatures VkPhysicalDeviceVariablePointerFeaturesKHR; -- 2.7.4