dEQP-VK.wsi.android.surface.create_simulate_oom
dEQP-VK.wsi.android.surface.query_support
dEQP-VK.wsi.android.surface.query_capabilities
+dEQP-VK.wsi.android.surface.query_capabilities2
dEQP-VK.wsi.android.surface.query_formats
+dEQP-VK.wsi.android.surface.query_formats2
dEQP-VK.wsi.android.surface.query_present_modes
dEQP-VK.wsi.android.surface.destroy_null_handle
dEQP-VK.wsi.android.surface.initial_size
VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004,
VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005,
VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
+ VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
+ VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
};
enum VkSystemAllocationScope
virtual void getPhysicalDeviceQueueFamilyProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties) const;
virtual void getPhysicalDeviceMemoryProperties2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties) const;
virtual void getPhysicalDeviceSparseImageFormatProperties2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, deUint32* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties) 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 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;
typedef VKAPI_ATTR void (VKAPI_CALL* GetPhysicalDeviceMemoryProperties2KHRFunc) (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties);
typedef VKAPI_ATTR void (VKAPI_CALL* GetPhysicalDeviceSparseImageFormatProperties2KHRFunc) (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, deUint32* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties);
typedef VKAPI_ATTR void (VKAPI_CALL* TrimCommandPoolKHRFunc) (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags);
+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* CreateDebugReportCallbackEXTFunc) (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
typedef VKAPI_ATTR void (VKAPI_CALL* DestroyDebugReportCallbackEXTFunc) (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
typedef VKAPI_ATTR void (VKAPI_CALL* DebugReportMessageEXTFunc) (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, deUint64 object, deUintptr location, deInt32 messageCode, const char* pLayerPrefix, const char* pMessage);
m_vk.getPhysicalDeviceQueueFamilyProperties2KHR = (GetPhysicalDeviceQueueFamilyProperties2KHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceQueueFamilyProperties2KHR");
m_vk.getPhysicalDeviceMemoryProperties2KHR = (GetPhysicalDeviceMemoryProperties2KHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceMemoryProperties2KHR");
m_vk.getPhysicalDeviceSparseImageFormatProperties2KHR = (GetPhysicalDeviceSparseImageFormatProperties2KHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
+m_vk.getPhysicalDeviceSurfaceCapabilities2KHR = (GetPhysicalDeviceSurfaceCapabilities2KHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceSurfaceCapabilities2KHR");
+m_vk.getPhysicalDeviceSurfaceFormats2KHR = (GetPhysicalDeviceSurfaceFormats2KHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceSurfaceFormats2KHR");
m_vk.createDebugReportCallbackEXT = (CreateDebugReportCallbackEXTFunc) GET_PROC_ADDR("vkCreateDebugReportCallbackEXT");
m_vk.destroyDebugReportCallbackEXT = (DestroyDebugReportCallbackEXTFunc) GET_PROC_ADDR("vkDestroyDebugReportCallbackEXT");
m_vk.debugReportMessageEXT = (DebugReportMessageEXTFunc) GET_PROC_ADDR("vkDebugReportMessageEXT");
m_vk.getPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
}
+VkResult InstanceDriver::getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const
+{
+ return m_vk.getPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
+}
+
+VkResult InstanceDriver::getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, deUint32* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) const
+{
+ return m_vk.getPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
+}
+
VkResult InstanceDriver::createDebugReportCallbackEXT (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) const
{
return m_vk.createDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
GetPhysicalDeviceQueueFamilyProperties2KHRFunc getPhysicalDeviceQueueFamilyProperties2KHR;
GetPhysicalDeviceMemoryProperties2KHRFunc getPhysicalDeviceMemoryProperties2KHR;
GetPhysicalDeviceSparseImageFormatProperties2KHRFunc getPhysicalDeviceSparseImageFormatProperties2KHR;
+GetPhysicalDeviceSurfaceCapabilities2KHRFunc getPhysicalDeviceSurfaceCapabilities2KHR;
+GetPhysicalDeviceSurfaceFormats2KHRFunc getPhysicalDeviceSurfaceFormats2KHR;
CreateDebugReportCallbackEXTFunc createDebugReportCallbackEXT;
DestroyDebugReportCallbackEXTFunc destroyDebugReportCallbackEXT;
DebugReportMessageEXTFunc debugReportMessageEXT;
DE_UNREF(flags);
}
+VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
+{
+ DE_UNREF(physicalDevice);
+ DE_UNREF(pSurfaceInfo);
+ DE_UNREF(pSurfaceCapabilities);
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, deUint32* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats)
+{
+ DE_UNREF(physicalDevice);
+ DE_UNREF(pSurfaceInfo);
+ DE_UNREF(pSurfaceFormatCount);
+ DE_UNREF(pSurfaceFormats);
+ 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);
VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties2KHR, getPhysicalDeviceQueueFamilyProperties2KHR),
VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties2KHR, getPhysicalDeviceMemoryProperties2KHR),
VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties2KHR, getPhysicalDeviceSparseImageFormatProperties2KHR),
+ VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilities2KHR, getPhysicalDeviceSurfaceCapabilities2KHR),
+ VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormats2KHR, getPhysicalDeviceSurfaceFormats2KHR),
VK_NULL_FUNC_ENTRY(vkCreateDebugReportCallbackEXT, createDebugReportCallbackEXT),
VK_NULL_FUNC_ENTRY(vkDestroyDebugReportCallbackEXT, destroyDebugReportCallbackEXT),
VK_NULL_FUNC_ENTRY(vkDebugReportMessageEXT, debugReportMessageEXT),
std::ostream& operator<< (std::ostream& s, const VkRectLayerKHR& value);
std::ostream& operator<< (std::ostream& s, const VkPresentRegionKHR& value);
std::ostream& operator<< (std::ostream& s, const VkPresentRegionsKHR& 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 VkDebugReportCallbackCreateInfoEXT& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineRasterizationStateRasterizationOrderAMD& value);
std::ostream& operator<< (std::ostream& s, const VkDebugMarkerObjectNameInfoEXT& value);
case VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX: return "VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX";
case VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX: return "VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX";
case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: return "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR";
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR";
+ case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: return "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR";
default: return DE_NULL;
}
}
return s;
}
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceSurfaceInfo2KHR& value)
+{
+ s << "VkPhysicalDeviceSurfaceInfo2KHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tsurface = " << value.surface << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkSurfaceCapabilities2KHR& value)
+{
+ s << "VkSurfaceCapabilities2KHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tsurfaceCapabilities = " << value.surfaceCapabilities << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkSurfaceFormat2KHR& value)
+{
+ s << "VkSurfaceFormat2KHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tsurfaceFormat = " << value.surfaceFormat << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkDebugReportCallbackCreateInfoEXT& value)
{
s << "VkDebugReportCallbackCreateInfoEXT = {\n";
const VkPresentRegionKHR* pRegions;
};
+struct VkPhysicalDeviceSurfaceInfo2KHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkSurfaceKHR surface;
+};
+
+struct VkSurfaceCapabilities2KHR
+{
+ VkStructureType sType;
+ void* pNext;
+ VkSurfaceCapabilitiesKHR surfaceCapabilities;
+};
+
+struct VkSurfaceFormat2KHR
+{
+ VkStructureType sType;
+ void* pNext;
+ VkSurfaceFormatKHR surfaceFormat;
+};
+
struct VkDebugReportCallbackCreateInfoEXT
{
VkStructureType sType;
virtual void getPhysicalDeviceQueueFamilyProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties) const = 0;
virtual void getPhysicalDeviceMemoryProperties2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties) const = 0;
virtual void getPhysicalDeviceSparseImageFormatProperties2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, deUint32* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties) 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 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;
"VK_KHR_xcb_surface",
"VK_KHR_xlib_surface",
"VK_KHR_get_physical_device_properties2",
+ "VK_KHR_get_surface_capabilities2",
};
checkKhrExtensions(results, extensions, DE_LENGTH_OF_ARRAY(s_allowedInstanceKhrExtensions), s_allowedInstanceKhrExtensions);
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
+#include "deMemory.h"
namespace vk
{
return !(a != b);
}
+inline bool operator!= (const VkExtent2D& a, const VkExtent2D& b)
+{
+ return (a.width != b.width) || (a.height != b.height);
+}
+
+inline bool operator!= (const VkSurfaceCapabilitiesKHR& a, const VkSurfaceCapabilitiesKHR& b)
+{
+ return (a.minImageCount != b.minImageCount) ||
+ (a.maxImageCount != b.maxImageCount) ||
+ (a.currentExtent != b.currentExtent) ||
+ (a.minImageExtent != b.minImageExtent) ||
+ (a.maxImageExtent != b.maxImageExtent) ||
+ (a.maxImageArrayLayers != b.maxImageArrayLayers) ||
+ (a.supportedTransforms != b.supportedTransforms) ||
+ (a.currentTransform != b.currentTransform) ||
+ (a.supportedCompositeAlpha != b.supportedCompositeAlpha) ||
+ (a.supportedUsageFlags != b.supportedUsageFlags);
+}
+
} // vk
namespace vkt
Move<VkInstance> createInstanceWithWsi (const PlatformInterface& vkp,
const Extensions& supportedExtensions,
Type wsiType,
+ const vector<string> extraExtensions,
const VkAllocationCallbacks* pAllocator = DE_NULL)
{
- vector<string> extensions;
+ vector<string> extensions = extraExtensions;
extensions.push_back("VK_KHR_surface");
extensions.push_back(getExtensionName(wsiType));
, instance (createInstanceWithWsi(context.getPlatformInterface(),
supportedExtensions,
wsiType,
+ vector<string>(),
+ pAllocator))
+ , vki (context.getPlatformInterface(), *instance)
+ {}
+
+ InstanceHelper (Context& context, Type wsiType, const vector<string>& extensions, const VkAllocationCallbacks* pAllocator = DE_NULL)
+ : supportedExtensions (enumerateInstanceExtensionProperties(context.getPlatformInterface(),
+ DE_NULL))
+ , instance (createInstanceWithWsi(context.getPlatformInterface(),
+ supportedExtensions,
+ wsiType,
+ extensions,
pAllocator))
, vki (context.getPlatformInterface(), *instance)
{}
return tcu::TestStatus(results.getResult(), results.getMessage());
}
+tcu::TestStatus querySurfaceCapabilities2Test (Context& context, Type wsiType)
+{
+ tcu::TestLog& log = context.getTestContext().getLog();
+ tcu::ResultCollector results (log);
+
+ const InstanceHelper instHelper (context, wsiType, vector<string>(1, string("VK_KHR_get_surface_capabilities2")));
+ const NativeObjects native (context, instHelper.supportedExtensions, wsiType);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
+ const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
+
+ for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
+ {
+ if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
+ {
+ const VkSurfaceCapabilitiesKHR refCapabilities = getPhysicalDeviceSurfaceCapabilities(instHelper.vki,
+ physicalDevices[deviceNdx],
+ *surface);
+ VkSurfaceCapabilities2KHR extCapabilities;
+
+ deMemset(&extCapabilities, 0xcd, sizeof(VkSurfaceCapabilities2KHR));
+ extCapabilities.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR;
+ extCapabilities.pNext = DE_NULL;
+
+ {
+ const VkPhysicalDeviceSurfaceInfo2KHR surfaceInfo =
+ {
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
+ DE_NULL,
+ *surface
+ };
+ VkPhysicalDeviceSurfaceInfo2KHR infoCopy;
+
+ deMemcpy(&infoCopy, &surfaceInfo, sizeof(VkPhysicalDeviceSurfaceInfo2KHR));
+
+ VK_CHECK(instHelper.vki.getPhysicalDeviceSurfaceCapabilities2KHR(physicalDevices[deviceNdx], &surfaceInfo, &extCapabilities));
+
+ results.check(deMemoryEqual(&surfaceInfo, &infoCopy, sizeof(VkPhysicalDeviceSurfaceInfo2KHR)) == DE_TRUE, "Driver wrote into input struct");
+ }
+
+ results.check(extCapabilities.sType == VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR &&
+ extCapabilities.pNext == DE_NULL,
+ "sType/pNext modified");
+
+ if (refCapabilities != extCapabilities.surfaceCapabilities)
+ {
+ log << TestLog::Message
+ << "Device " << deviceNdx
+ << ": expected " << refCapabilities
+ << ", got " << extCapabilities.surfaceCapabilities
+ << TestLog::EndMessage;
+ results.fail("Mismatch between VK_KHR_surface and VK_KHR_surface2 query results");
+ }
+ }
+ }
+
+ return tcu::TestStatus(results.getResult(), results.getMessage());
+}
+
void validateSurfaceFormats (tcu::ResultCollector& results, Type wsiType, const vector<VkSurfaceFormatKHR>& formats)
{
const VkSurfaceFormatKHR* requiredFormats = DE_NULL;
if (!de::contains(formats.begin(), formats.end(), requiredFormat))
results.fail(de::toString(requiredFormat) + " not supported");
}
+
+ // Check that there are no duplicates
+ for (size_t ndx = 1; ndx < formats.size(); ++ndx)
+ {
+ if (de::contains(formats.begin(), formats.begin() + ndx, formats[ndx]))
+ results.fail("Found duplicate entry " + de::toString(formats[ndx]));
+ }
}
tcu::TestStatus querySurfaceFormatsTest (Context& context, Type wsiType)
return tcu::TestStatus(results.getResult(), results.getMessage());
}
+tcu::TestStatus querySurfaceFormats2Test (Context& context, Type wsiType)
+{
+ tcu::TestLog& log = context.getTestContext().getLog();
+ tcu::ResultCollector results (log);
+
+ const InstanceHelper instHelper (context, wsiType, vector<string>(1, string("VK_KHR_get_surface_capabilities2")));
+ const NativeObjects native (context, instHelper.supportedExtensions, wsiType);
+ const Unique<VkSurfaceKHR> surface (createSurface(instHelper.vki, *instHelper.instance, wsiType, *native.display, *native.window));
+ const vector<VkPhysicalDevice> physicalDevices = enumeratePhysicalDevices(instHelper.vki, *instHelper.instance);
+
+ for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
+ {
+ if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
+ {
+ const vector<VkSurfaceFormatKHR> refFormats = getPhysicalDeviceSurfaceFormats(instHelper.vki,
+ physicalDevices[deviceNdx],
+ *surface);
+ const VkPhysicalDeviceSurfaceInfo2KHR surfaceInfo =
+ {
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
+ DE_NULL,
+ *surface
+ };
+ deUint32 numFormats = 0;
+
+ VK_CHECK(instHelper.vki.getPhysicalDeviceSurfaceFormats2KHR(physicalDevices[deviceNdx], &surfaceInfo, &numFormats, DE_NULL));
+
+ if ((size_t)numFormats != refFormats.size())
+ results.fail("vkGetPhysicalDeviceSurfaceFormats2KHR() returned different number of formats");
+
+ if (numFormats > 0)
+ {
+ vector<VkSurfaceFormat2KHR> formats (numFormats);
+
+ for (size_t ndx = 0; ndx < formats.size(); ++ndx)
+ {
+ formats[ndx].sType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR;
+ formats[ndx].pNext = DE_NULL;
+ }
+
+ VK_CHECK(instHelper.vki.getPhysicalDeviceSurfaceFormats2KHR(physicalDevices[deviceNdx], &surfaceInfo, &numFormats, &formats[0]));
+
+ if ((size_t)numFormats != formats.size())
+ results.fail("Format count changed between calls");
+
+ {
+ vector<VkSurfaceFormatKHR> extFormats (formats.size());
+
+ for (size_t ndx = 0; ndx < formats.size(); ++ndx)
+ {
+ results.check(formats[ndx].sType == VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR &&
+ formats[ndx].pNext == DE_NULL,
+ "sType/pNext modified");
+ extFormats[ndx] = formats[ndx].surfaceFormat;
+ }
+
+ for (size_t ndx = 0; ndx < refFormats.size(); ++ndx)
+ {
+ if (!de::contains(extFormats.begin(), extFormats.end(), refFormats[ndx]))
+ results.fail(de::toString(refFormats[ndx]) + " missing from extended query");
+ }
+ }
+
+ // Check VK_INCOMPLETE
+ {
+ vector<VkSurfaceFormat2KHR> formatsClone (formats);
+ deUint32 numToSupply = numFormats/2;
+ VkResult queryResult;
+
+ ValidateQueryBits::fillBits(formatsClone.begin() + numToSupply, formatsClone.end());
+
+ queryResult = instHelper.vki.getPhysicalDeviceSurfaceFormats2KHR(physicalDevices[deviceNdx], &surfaceInfo, &numToSupply, &formatsClone[0]);
+
+ results.check(queryResult == VK_INCOMPLETE, "Expected VK_INCOMPLETE");
+ results.check(ValidateQueryBits::checkBits(formatsClone.begin() + numToSupply, formatsClone.end()),
+ "Driver wrote past last element");
+
+ for (size_t ndx = 0; ndx < (size_t)numToSupply; ++ndx)
+ {
+ results.check(formatsClone[ndx].sType == VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR &&
+ formatsClone[ndx].pNext == DE_NULL &&
+ formatsClone[ndx].surfaceFormat == formats[ndx].surfaceFormat,
+ "Returned element " + de::toString(ndx) + " is different");
+ }
+ }
+ }
+ }
+ // else skip query as surface is not supported by the device
+ }
+
+ return tcu::TestStatus(results.getResult(), results.getMessage());
+}
+
void validateSurfacePresentModes (tcu::ResultCollector& results, Type wsiType, const vector<VkPresentModeKHR>& modes)
{
results.check(de::contains(modes.begin(), modes.end(), VK_PRESENT_MODE_FIFO_KHR),
addFunctionCase(testGroup, "create_simulate_oom", "Create surface with simulating OOM", createSurfaceSimulateOOMTest, wsiType);
addFunctionCase(testGroup, "query_support", "Query surface support", querySurfaceSupportTest, wsiType);
addFunctionCase(testGroup, "query_capabilities", "Query surface capabilities", querySurfaceCapabilitiesTest, wsiType);
+ addFunctionCase(testGroup, "query_capabilities2", "Query extended surface capabilities", querySurfaceCapabilities2Test, wsiType);
addFunctionCase(testGroup, "query_formats", "Query surface formats", querySurfaceFormatsTest, wsiType);
+ addFunctionCase(testGroup, "query_formats2", "Query extended surface formats", querySurfaceFormats2Test, wsiType);
addFunctionCase(testGroup, "query_present_modes", "Query surface present modes", querySurfacePresentModesTest, wsiType);
addFunctionCase(testGroup, "destroy_null_handle", "Destroy VK_NULL_HANDLE surface", destroyNullHandleSurfaceTest, wsiType);
dEQP-VK.wsi.xlib.surface.create_simulate_oom
dEQP-VK.wsi.xlib.surface.query_support
dEQP-VK.wsi.xlib.surface.query_capabilities
+dEQP-VK.wsi.xlib.surface.query_capabilities2
dEQP-VK.wsi.xlib.surface.query_formats
+dEQP-VK.wsi.xlib.surface.query_formats2
dEQP-VK.wsi.xlib.surface.query_present_modes
dEQP-VK.wsi.xlib.surface.destroy_null_handle
dEQP-VK.wsi.xlib.surface.initial_size
dEQP-VK.wsi.xcb.surface.create_simulate_oom
dEQP-VK.wsi.xcb.surface.query_support
dEQP-VK.wsi.xcb.surface.query_capabilities
+dEQP-VK.wsi.xcb.surface.query_capabilities2
dEQP-VK.wsi.xcb.surface.query_formats
+dEQP-VK.wsi.xcb.surface.query_formats2
dEQP-VK.wsi.xcb.surface.query_present_modes
dEQP-VK.wsi.xcb.surface.destroy_null_handle
dEQP-VK.wsi.xcb.surface.initial_size
dEQP-VK.wsi.wayland.surface.create_simulate_oom
dEQP-VK.wsi.wayland.surface.query_support
dEQP-VK.wsi.wayland.surface.query_capabilities
+dEQP-VK.wsi.wayland.surface.query_capabilities2
dEQP-VK.wsi.wayland.surface.query_formats
+dEQP-VK.wsi.wayland.surface.query_formats2
dEQP-VK.wsi.wayland.surface.query_present_modes
dEQP-VK.wsi.wayland.surface.destroy_null_handle
dEQP-VK.wsi.wayland.swapchain.create.min_image_count
dEQP-VK.wsi.mir.surface.create_simulate_oom
dEQP-VK.wsi.mir.surface.query_support
dEQP-VK.wsi.mir.surface.query_capabilities
+dEQP-VK.wsi.mir.surface.query_capabilities2
dEQP-VK.wsi.mir.surface.query_formats
+dEQP-VK.wsi.mir.surface.query_formats2
dEQP-VK.wsi.mir.surface.query_present_modes
dEQP-VK.wsi.mir.surface.destroy_null_handle
dEQP-VK.wsi.mir.surface.initial_size
dEQP-VK.wsi.android.surface.create_simulate_oom
dEQP-VK.wsi.android.surface.query_support
dEQP-VK.wsi.android.surface.query_capabilities
+dEQP-VK.wsi.android.surface.query_capabilities2
dEQP-VK.wsi.android.surface.query_formats
+dEQP-VK.wsi.android.surface.query_formats2
dEQP-VK.wsi.android.surface.query_present_modes
dEQP-VK.wsi.android.surface.destroy_null_handle
dEQP-VK.wsi.android.surface.initial_size
dEQP-VK.wsi.win32.surface.create_simulate_oom
dEQP-VK.wsi.win32.surface.query_support
dEQP-VK.wsi.win32.surface.query_capabilities
+dEQP-VK.wsi.win32.surface.query_capabilities2
dEQP-VK.wsi.win32.surface.query_formats
+dEQP-VK.wsi.win32.surface.query_formats2
dEQP-VK.wsi.win32.surface.query_present_modes
dEQP-VK.wsi.win32.surface.destroy_null_handle
dEQP-VK.wsi.win32.surface.initial_size
"vkDebugReportMessageEXT",
# VK_NV_external_memory_capabilities
- "vkGetPhysicalDeviceExternalImageFormatPropertiesNV"
+ "vkGetPhysicalDeviceExternalImageFormatPropertiesNV",
+
+ # VK_KHR_get_surface_capabilities2
+ "vkGetPhysicalDeviceSurfaceCapabilities2KHR",
+ "vkGetPhysicalDeviceSurfaceFormats2KHR",
]
DEFINITIONS = [
VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004,
VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005,
VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
+ VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
+ VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
const VkPresentRegionKHR* pRegions;
} VkPresentRegionsKHR;
+#define VK_KHR_get_surface_capabilities2 1
+#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
+#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
+
+typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSurfaceKHR surface;
+} VkPhysicalDeviceSurfaceInfo2KHR;
+
+typedef struct VkSurfaceCapabilities2KHR {
+ VkStructureType sType;
+ void* pNext;
+ VkSurfaceCapabilitiesKHR surfaceCapabilities;
+} VkSurfaceCapabilities2KHR;
+
+typedef struct VkSurfaceFormat2KHR {
+ VkStructureType sType;
+ void* pNext;
+ VkSurfaceFormatKHR surfaceFormat;
+} VkSurfaceFormat2KHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormat2KHR* pSurfaceFormats);
+#endif
+
#define VK_EXT_debug_report 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)