From 4c622a09ce70b43c665ffa8616ece766182c421e Mon Sep 17 00:00:00 2001 From: Trevor David Black Date: Mon, 28 Jun 2021 22:46:14 +0000 Subject: Vulkan: update the loader for vulkan-headers v1.2.183 Bug: 192288751 Test: build Change-Id: Icee2374114f14285c6e522c0ccfbf106390a8fa3 --- vulkan/libvulkan/api_gen.cpp | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/api_gen.cpp b/vulkan/libvulkan/api_gen.cpp index 26052fba63..33401d24d6 100644 --- a/vulkan/libvulkan/api_gen.cpp +++ b/vulkan/libvulkan/api_gen.cpp @@ -560,6 +560,7 @@ VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pNa } static const char* const known_non_device_names[] = { + "vkAcquireDrmDisplayEXT", "vkCreateAndroidSurfaceKHR", "vkCreateDebugReportCallbackEXT", "vkCreateDebugUtilsMessengerEXT", @@ -581,6 +582,7 @@ VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pNa "vkEnumeratePhysicalDevices", "vkGetDisplayModeProperties2KHR", "vkGetDisplayPlaneCapabilities2KHR", + "vkGetDrmDisplayEXT", "vkGetInstanceProcAddr", "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", "vkGetPhysicalDeviceDisplayPlaneProperties2KHR", @@ -624,6 +626,8 @@ VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pNa "vkGetPhysicalDeviceSurfacePresentModesKHR", "vkGetPhysicalDeviceSurfaceSupportKHR", "vkGetPhysicalDeviceToolPropertiesEXT", + "vkGetPhysicalDeviceVideoCapabilitiesKHR", + "vkGetPhysicalDeviceVideoFormatPropertiesKHR", "vkSubmitDebugUtilsMessageEXT", }; // clang-format on -- cgit v1.2.3-59-g8ed1b From e056c12782125c3ad5876f3ac7528d9889808675 Mon Sep 17 00:00:00 2001 From: Chris Forbes Date: Thu, 22 Jul 2021 13:54:04 -0700 Subject: Inline GetPhysicalDeviceProperties2 into QueryPresentationProperties In general, we implement the 1.1 instance / physical device API as preferring to call the native 1.1 function if available; otherwise falling back to calling the equivalent GPDP2 function. If the underlying driver supports *neither* then any caller of that function has already invoked UB by calling it and so falling over is acceptable. Unfortunately, the loader itself does call vkGetPhysicalDeviceProperties2 in one case, regardless of what the driver may support, in order to determine whether the platform's swapchain implementation should expose some features. On a 1.0 driver without the GPDP2 extension, this caused trouble. As a slight further wrinkle, vkGetPhysicalDeviceProperties2 "cannot fail", making propagating a failure back up through the loader annoying. As a workaround, inline the calls to GetPhysicalDeviceProperties2 and GetPhysicalDeviceProperties2KHR into QueryPresentationProperties, where we can handle our one special case of both function pointers being missing but behavior being defined. Bug: b/192130684 Change-Id: Iff2bae98b7931bed80fafd895cf57061becabd8d --- vulkan/libvulkan/driver.cpp | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index d7fdab5586..cf774fd9b8 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -979,6 +979,8 @@ VkResult EnumerateInstanceExtensionProperties( void QueryPresentationProperties( VkPhysicalDevice physicalDevice, VkPhysicalDevicePresentationPropertiesANDROID* presentation_properties) { + ATRACE_CALL(); + // Request the android-specific presentation properties via GPDP2 VkPhysicalDeviceProperties2 properties = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, @@ -994,7 +996,17 @@ void QueryPresentationProperties( presentation_properties->pNext = nullptr; presentation_properties->sharedImage = VK_FALSE; - GetPhysicalDeviceProperties2(physicalDevice, &properties); + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceProperties2) { + // >= 1.1 driver, supports core GPDP2 entrypoint. + driver.GetPhysicalDeviceProperties2(physicalDevice, &properties); + } else if (driver.GetPhysicalDeviceProperties2KHR) { + // Old driver, but may support presentation properties + // if we have the GPDP2 extension. Otherwise, no presentation + // properties supported. + driver.GetPhysicalDeviceProperties2KHR(physicalDevice, &properties); + } } VkResult EnumerateDeviceExtensionProperties( -- cgit v1.2.3-59-g8ed1b From 737b5b495f7b65787bd676187dd9cca178386498 Mon Sep 17 00:00:00 2001 From: Trevor David Black Date: Tue, 19 Oct 2021 16:05:13 +0000 Subject: Advertise support for BT709 in the WSI Bug: 203533233 Test: build Change-Id: Ie858995e7d5ef7be481f275450372bd319746e18 --- vulkan/libvulkan/swapchain.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 3ed3eba767..e89a49b04c 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -736,7 +736,8 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, // We must support R8G8B8A8 std::vector all_formats = { {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, - {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}}; + {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, + {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_BT709_LINEAR_EXT}}; if (wide_color_support) { all_formats.emplace_back(VkSurfaceFormatKHR{ -- cgit v1.2.3-59-g8ed1b From d8a36dea9fbba46d674530198e2b4925231f53c6 Mon Sep 17 00:00:00 2001 From: Chris Forbes Date: Tue, 16 Nov 2021 07:46:07 -0800 Subject: Use std::shared_mutex in debug_report Bug: b/143295577 Change-Id: Iee285c4a7ea42fc25b5463f79894d3cca58f17c1 --- vulkan/libvulkan/debug_report.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/debug_report.h b/vulkan/libvulkan/debug_report.h index e5b1587b4f..416c0bc2e1 100644 --- a/vulkan/libvulkan/debug_report.h +++ b/vulkan/libvulkan/debug_report.h @@ -78,8 +78,7 @@ class DebugReportCallbackList { VkDebugReportCallbackEXT driver_handle; }; - // TODO(b/143295577): use std::shared_mutex when available in libc++ - mutable std::shared_timed_mutex rwmutex_; + mutable std::shared_mutex rwmutex_; Node head_; }; -- cgit v1.2.3-59-g8ed1b From ea5745afb64f0f71ccbc36d617a73d0ce0db2e9f Mon Sep 17 00:00:00 2001 From: Trevor David Black Date: Tue, 23 Nov 2021 17:27:23 +0000 Subject: Make BT709 support conditional on swapchain ext enable Bug: 203533233 Test: build Change-Id: I5f36059a06a92216bc83e3e794f7992ea3ce8048 --- vulkan/libvulkan/swapchain.cpp | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index e89a49b04c..54b10b1127 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -720,10 +720,10 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, if (err) { return VK_ERROR_SURFACE_LOST_KHR; } - ALOGV("wide_color_support is: %d", wide_color_support); - wide_color_support = - wide_color_support && + bool swapchain_ext = instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace); + ALOGV("wide_color_support is: %d", wide_color_support); + wide_color_support = wide_color_support && swapchain_ext; AHardwareBuffer_Desc desc = {}; desc.width = 1; @@ -736,8 +736,12 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, // We must support R8G8B8A8 std::vector all_formats = { {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, - {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, - {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_BT709_LINEAR_EXT}}; + {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}}; + + if (swapchain_ext) { + all_formats.emplace_back(VkSurfaceFormatKHR{ + VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_BT709_LINEAR_EXT}); + } if (wide_color_support) { all_formats.emplace_back(VkSurfaceFormatKHR{ -- cgit v1.2.3-59-g8ed1b From 16c443c69768038bbc6af46dba59e6de4d16e0b3 Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Tue, 30 Nov 2021 17:10:32 -0700 Subject: swapchain: Fix MAILBOX and SHARED presentation modes This change undoes two previous changes and fixes the original performance problem reported with b/182887411. By default, Vulkan swapchains should use: - 3 images for FIFO (unless limited or increased from below) - 1 images for SHARED This reverts the following commits: - commit 148bad076ef46297e516b650007852937a506c8b. "swapchain: increase the minimal buffer count to 3" - commit ef14146f7de705c2facfc8c470ea100503dbdb57. "swapchain: always return a signle image for shared presentation mode" Test: Manual testing with additional logging Bug: 204105805 Bug: 182887411 Bug: 197790618 Change-Id: I9902d11aadf946a51c3f74e1462faf620a84a977 --- vulkan/libvulkan/swapchain.cpp | 62 ++++++++++++++---------------------------- 1 file changed, 21 insertions(+), 41 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 54b10b1127..b5a0bdfe6f 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -537,30 +537,6 @@ android_dataspace GetNativeDataspace(VkColorSpaceKHR colorspace) { } } -int get_min_buffer_count(ANativeWindow* window, - uint32_t* out_min_buffer_count) { - constexpr int kExtraBuffers = 2; - - int err; - int min_undequeued_buffers; - err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, - &min_undequeued_buffers); - if (err != android::OK || min_undequeued_buffers < 0) { - ALOGE( - "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) " - "value=%d", - strerror(-err), err, min_undequeued_buffers); - if (err == android::OK) { - err = android::UNKNOWN_ERROR; - } - return err; - } - - *out_min_buffer_count = - static_cast(min_undequeued_buffers + kExtraBuffers); - return android::OK; -} - } // anonymous namespace VKAPI_ATTR @@ -675,7 +651,7 @@ VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR( strerror(-err), err); return VK_ERROR_SURFACE_LOST_KHR; } - capabilities->minImageCount = max_buffer_count == 1 ? 1 : 2; + capabilities->minImageCount = std::min(max_buffer_count, 3); capabilities->maxImageCount = static_cast(max_buffer_count); capabilities->currentExtent = @@ -877,13 +853,18 @@ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev, int err; int query_value; - uint32_t min_buffer_count; ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); - err = get_min_buffer_count(window, &min_buffer_count); - if (err != android::OK) { + err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, + &query_value); + if (err != android::OK || query_value < 0) { + ALOGE( + "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) " + "value=%d", + strerror(-err), err, query_value); return VK_ERROR_SURFACE_LOST_KHR; } + uint32_t min_undequeued_buffers = static_cast(query_value); err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value); if (err != android::OK || query_value < 0) { @@ -894,7 +875,7 @@ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev, uint32_t max_buffer_count = static_cast(query_value); std::vector present_modes; - if (min_buffer_count < max_buffer_count) + if (min_undequeued_buffers + 1 < max_buffer_count) present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); @@ -1215,14 +1196,19 @@ VkResult CreateSwapchainKHR(VkDevice device, } } - uint32_t min_buffer_count; - err = get_min_buffer_count(window, &min_buffer_count); - if (err != android::OK) { + int query_value; + err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, + &query_value); + if (err != android::OK || query_value < 0) { + ALOGE("window->query failed: %s (%d) value=%d", strerror(-err), err, + query_value); return VK_ERROR_SURFACE_LOST_KHR; } - - uint32_t num_images = - std::max(min_buffer_count, create_info->minImageCount); + uint32_t min_undequeued_buffers = static_cast(query_value); + const auto mailbox_num_images = std::max(3u, create_info->minImageCount); + const auto requested_images = + swap_interval ? create_info->minImageCount : mailbox_num_images; + uint32_t num_images = requested_images - 1 + min_undequeued_buffers; // Lower layer insists that we have at least two buffers. This is wasteful // and we'd like to relax it in the shared case, but not all the pieces are @@ -1236,12 +1222,6 @@ VkResult CreateSwapchainKHR(VkDevice device, return VK_ERROR_SURFACE_LOST_KHR; } - // In shared mode the num_images must be one regardless of how many - // buffers were allocated for the buffer queue. - if (swapchain_image_usage & VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID) { - num_images = 1; - } - int32_t legacy_usage = 0; if (dispatch.GetSwapchainGrallocUsage2ANDROID) { uint64_t consumer_usage, producer_usage; -- cgit v1.2.3-59-g8ed1b From cb45fe73b996d4e35589e9fc163a30d7e0fc6234 Mon Sep 17 00:00:00 2001 From: Leon Scroggins III Date: Tue, 30 Nov 2021 16:17:15 -0500 Subject: Expose VK_FORMAT_R8_UNORM swapchain format if supported by underlying system Bug: 193170859 Test: TODO Change-Id: I62d2136c469480baf1c8704979ec59f7479519d5 --- vulkan/libvulkan/swapchain.cpp | 30 +++++++++++++++++++++--------- 1 file changed, 21 insertions(+), 9 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index b5a0bdfe6f..eb4befd5ec 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -23,6 +23,8 @@ #include #include #include +#include +#include #include #include #include @@ -462,21 +464,24 @@ void copy_ready_timings(Swapchain& swapchain, *count = num_copied; } -android_pixel_format GetNativePixelFormat(VkFormat format) { - android_pixel_format native_format = HAL_PIXEL_FORMAT_RGBA_8888; +android::PixelFormat GetNativePixelFormat(VkFormat format) { + android::PixelFormat native_format = android::PIXEL_FORMAT_RGBA_8888; switch (format) { case VK_FORMAT_R8G8B8A8_UNORM: case VK_FORMAT_R8G8B8A8_SRGB: - native_format = HAL_PIXEL_FORMAT_RGBA_8888; + native_format = android::PIXEL_FORMAT_RGBA_8888; break; case VK_FORMAT_R5G6B5_UNORM_PACK16: - native_format = HAL_PIXEL_FORMAT_RGB_565; + native_format = android::PIXEL_FORMAT_RGB_565; break; case VK_FORMAT_R16G16B16A16_SFLOAT: - native_format = HAL_PIXEL_FORMAT_RGBA_FP16; + native_format = android::PIXEL_FORMAT_RGBA_FP16; break; case VK_FORMAT_A2B10G10R10_UNORM_PACK32: - native_format = HAL_PIXEL_FORMAT_RGBA_1010102; + native_format = android::PIXEL_FORMAT_RGBA_1010102; + break; + case VK_FORMAT_R8_UNORM: + native_format = android::PIXEL_FORMAT_R_8; break; default: ALOGV("unsupported swapchain format %d", format); @@ -758,6 +763,13 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, } } + desc.format = AHARDWAREBUFFER_FORMAT_R8_UNORM; + if (AHardwareBuffer_isSupported(&desc)) { + all_formats.emplace_back( + VkSurfaceFormatKHR{VK_FORMAT_R8_UNORM, + VK_COLOR_SPACE_PASS_THROUGH_EXT}); + } + VkResult result = VK_SUCCESS; if (formats) { uint32_t transfer_count = all_formats.size(); @@ -1034,7 +1046,7 @@ VkResult CreateSwapchainKHR(VkDevice device, if (!allocator) allocator = &GetData(device).allocator; - android_pixel_format native_pixel_format = + android::PixelFormat native_pixel_format = GetNativePixelFormat(create_info->imageFormat); android_dataspace native_dataspace = GetNativeDataspace(create_info->imageColorSpace); @@ -1131,8 +1143,8 @@ VkResult CreateSwapchainKHR(VkDevice device, err = native_window_set_buffers_format(window, native_pixel_format); if (err != android::OK) { - ALOGE("native_window_set_buffers_format(%d) failed: %s (%d)", - native_pixel_format, strerror(-err), err); + ALOGE("native_window_set_buffers_format(%s) failed: %s (%d)", + decodePixelFormat(native_pixel_format).c_str(), strerror(-err), err); return VK_ERROR_SURFACE_LOST_KHR; } err = native_window_set_buffers_data_space(window, native_dataspace); -- cgit v1.2.3-59-g8ed1b From 12b7e2fcd52669b6ecd92ce6655409790426bf89 Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Tue, 21 Dec 2021 23:24:20 -0700 Subject: swapchain: Fix auto-merger defect: Fix SHARED presentation modes Part of aosp/1921342 did not end up in goog/master. This fixes that. Test: dEQP.EGL/functional_mutable_render_buffer_basic Bug: 209035115 Bug: 200378297 Change-Id: Id5bf9c5af8e60184f575517e3209482953535a20 --- vulkan/libvulkan/swapchain.cpp | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index e6717d7280..4a6b4f12a1 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -1236,6 +1236,12 @@ VkResult CreateSwapchainKHR(VkDevice device, return VK_ERROR_SURFACE_LOST_KHR; } + // In shared mode the num_images must be one regardless of how many + // buffers were allocated for the buffer queue. + if (swapchain_image_usage & VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID) { + num_images = 1; + } + int32_t legacy_usage = 0; if (dispatch.GetSwapchainGrallocUsage2ANDROID) { uint64_t consumer_usage, producer_usage; -- cgit v1.2.3-59-g8ed1b From fa7af492359030e28391e1a13d7b9749057d3603 Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Tue, 20 Jul 2021 17:40:24 -0600 Subject: Change Vulkan API to 1.2 The commit changes the platform code to support Vulkan 1.2. Bug: 191881132 Test: build Change-Id: I6e71a84b85874a71031734004b8e44ee0ea7446f --- vulkan/libvulkan/api.cpp | 2 +- vulkan/libvulkan/driver.cpp | 8 ++++++-- vulkan/nulldrv/null_driver.cpp | 2 +- 3 files changed, 8 insertions(+), 4 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/api.cpp b/vulkan/libvulkan/api.cpp index fa3b2601a4..9ecc5687cc 100644 --- a/vulkan/libvulkan/api.cpp +++ b/vulkan/libvulkan/api.cpp @@ -1473,7 +1473,7 @@ VkResult EnumerateInstanceVersion(uint32_t* pApiVersion) { if (!EnsureInitialized()) return VK_ERROR_OUT_OF_HOST_MEMORY; - *pApiVersion = VK_API_VERSION_1_1; + *pApiVersion = VK_API_VERSION_1_2; return VK_SUCCESS; } diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index cf774fd9b8..ffc7c94566 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -365,7 +365,7 @@ CreateInfoWrapper::CreateInfoWrapper(const VkInstanceCreateInfo& create_info, const VkAllocationCallbacks& allocator) : is_instance_(true), allocator_(allocator), - loader_api_version_(VK_API_VERSION_1_1), + loader_api_version_(VK_API_VERSION_1_2), icd_api_version_(icd_api_version), physical_dev_(VK_NULL_HANDLE), instance_info_(create_info), @@ -377,7 +377,7 @@ CreateInfoWrapper::CreateInfoWrapper(VkPhysicalDevice physical_dev, const VkAllocationCallbacks& allocator) : is_instance_(false), allocator_(allocator), - loader_api_version_(VK_API_VERSION_1_1), + loader_api_version_(VK_API_VERSION_1_2), icd_api_version_(icd_api_version), physical_dev_(physical_dev), dev_info_(create_info), @@ -519,6 +519,10 @@ VkResult CreateInfoWrapper::SanitizeExtensions() { is_instance_ ? loader_api_version_ : std::min(icd_api_version_, loader_api_version_); switch (api_version) { + case VK_API_VERSION_1_2: + hook_extensions_.set(ProcHook::EXTENSION_CORE_1_2); + hal_extensions_.set(ProcHook::EXTENSION_CORE_1_2); + [[clang::fallthrough]]; case VK_API_VERSION_1_1: hook_extensions_.set(ProcHook::EXTENSION_CORE_1_1); hal_extensions_.set(ProcHook::EXTENSION_CORE_1_1); diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp index b94233b24a..ddc5cbd77f 100644 --- a/vulkan/nulldrv/null_driver.cpp +++ b/vulkan/nulldrv/null_driver.cpp @@ -260,7 +260,7 @@ namespace null_driver { VKAPI_ATTR VkResult EnumerateInstanceVersion(uint32_t* pApiVersion) { - *pApiVersion = VK_API_VERSION_1_1; + *pApiVersion = VK_API_VERSION_1_2; return VK_SUCCESS; } -- cgit v1.2.3-59-g8ed1b From b68a2251024524f64447dc858aa3f017e07fdf78 Mon Sep 17 00:00:00 2001 From: Trevor David Black Date: Mon, 23 Aug 2021 16:37:18 +0000 Subject: Deprecate old VK_* defines Bug: 191881132 Test: build Change-Id: If7ff23e465b54258c9e2445981cbc11cbe14e174 --- vulkan/libvulkan/driver.cpp | 4 ++-- vulkan/nulldrv/null_driver.cpp | 4 ++-- vulkan/vkjson/vkjson.cc | 4 ++-- vulkan/vkjson/vkjson.h | 8 -------- 4 files changed, 6 insertions(+), 14 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index ffc7c94566..648353ee1d 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -1115,7 +1115,7 @@ VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo, if (result != VK_SUCCESS) return result; - icd_api_version ^= VK_VERSION_PATCH(icd_api_version); + icd_api_version ^= VK_API_VERSION_PATCH(icd_api_version); } CreateInfoWrapper wrapper(*pCreateInfo, icd_api_version, data_allocator); @@ -1199,7 +1199,7 @@ VkResult CreateDevice(VkPhysicalDevice physicalDevice, CreateInfoWrapper wrapper( physicalDevice, *pCreateInfo, - properties.apiVersion ^ VK_VERSION_PATCH(properties.apiVersion), + properties.apiVersion ^ VK_API_VERSION_PATCH(properties.apiVersion), data_allocator); VkResult result = wrapper.Validate(); if (result != VK_SUCCESS) diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp index ddc5cbd77f..a9f37e56cf 100644 --- a/vulkan/nulldrv/null_driver.cpp +++ b/vulkan/nulldrv/null_driver.cpp @@ -397,8 +397,8 @@ VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice /*gpu*/, void GetPhysicalDeviceProperties(VkPhysicalDevice, VkPhysicalDeviceProperties* properties) { - properties->apiVersion = VK_MAKE_VERSION(1, 0, VK_HEADER_VERSION); - properties->driverVersion = VK_MAKE_VERSION(0, 0, 1); + properties->apiVersion = VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION); + properties->driverVersion = VK_MAKE_API_VERSION(0, 0, 0, 1); properties->vendorID = 0; properties->deviceID = 0; properties->deviceType = VK_PHYSICAL_DEVICE_TYPE_OTHER; diff --git a/vulkan/vkjson/vkjson.cc b/vulkan/vkjson/vkjson.cc index 438e5dd10d..bdb76484d0 100644 --- a/vulkan/vkjson/vkjson.cc +++ b/vulkan/vkjson/vkjson.cc @@ -841,7 +841,7 @@ template inline bool Iterate(Visitor* visitor, VkJsonDevice* device) { bool ret = true; switch (device->properties.apiVersion ^ - VK_VERSION_PATCH(device->properties.apiVersion)) { + VK_API_VERSION_PATCH(device->properties.apiVersion)) { case VK_API_VERSION_1_2: FALLTHROUGH_INTENDED; case VK_API_VERSION_1_1: @@ -897,7 +897,7 @@ inline bool Iterate(Visitor* visitor, VkJsonDevice* device) { template inline bool Iterate(Visitor* visitor, VkJsonInstance* instance) { bool ret = true; - switch (instance->api_version ^ VK_VERSION_PATCH(instance->api_version)) { + switch (instance->api_version ^ VK_API_VERSION_PATCH(instance->api_version)) { case VK_API_VERSION_1_2: FALLTHROUGH_INTENDED; case VK_API_VERSION_1_1: diff --git a/vulkan/vkjson/vkjson.h b/vulkan/vkjson/vkjson.h index 52e7bee288..aca1d6085e 100644 --- a/vulkan/vkjson/vkjson.h +++ b/vulkan/vkjson/vkjson.h @@ -33,14 +33,6 @@ #undef max #endif -#ifndef VK_API_VERSION_1_0 -#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0) -#endif - -#ifndef VK_API_VERSION_1_1 -#define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0) -#endif - /* * Annotation to tell clang that we intend to fall through from one case to * another in a switch. Sourced from android-base/macros.h. -- cgit v1.2.3-59-g8ed1b From b700ae8ceeed33b876a6e4676ac0f05bbdf9be78 Mon Sep 17 00:00:00 2001 From: Trevor David Black Date: Mon, 27 Sep 2021 04:50:04 +0000 Subject: Vulkan: update the loader for vulkan-headers v1.3.197 Bug: 191881132 Test: build Change-Id: Ie9e13d64a438d895f92e826e693477d508200054 --- vulkan/libvulkan/api_gen.cpp | 444 +++++++++++++++++++++++++++++++++++++ vulkan/libvulkan/api_gen.h | 37 ++++ vulkan/libvulkan/driver.cpp | 2 + vulkan/libvulkan/driver_gen.h | 1 + vulkan/nulldrv/null_driver_gen.cpp | 37 ++++ vulkan/nulldrv/null_driver_gen.h | 37 ++++ 6 files changed, 558 insertions(+) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/api_gen.cpp b/vulkan/libvulkan/api_gen.cpp index 33401d24d6..eb9fc477e3 100644 --- a/vulkan/libvulkan/api_gen.cpp +++ b/vulkan/libvulkan/api_gen.cpp @@ -179,6 +179,7 @@ bool InitDispatchTable( INIT_PROC(false, instance, GetPhysicalDeviceExternalFenceProperties); INIT_PROC(false, instance, EnumeratePhysicalDeviceGroups); INIT_PROC_EXT(KHR_swapchain, false, instance, GetPhysicalDevicePresentRectanglesKHR); + INIT_PROC(false, instance, GetPhysicalDeviceToolProperties); // clang-format on return success; @@ -334,6 +335,9 @@ bool InitDispatchTable( INIT_PROC(false, dev, GetBufferMemoryRequirements2); INIT_PROC(false, dev, GetImageMemoryRequirements2); INIT_PROC(false, dev, GetImageSparseMemoryRequirements2); + INIT_PROC(false, dev, GetDeviceBufferMemoryRequirements); + INIT_PROC(false, dev, GetDeviceImageMemoryRequirements); + INIT_PROC(false, dev, GetDeviceImageSparseMemoryRequirements); INIT_PROC(false, dev, CreateSamplerYcbcrConversion); INIT_PROC(false, dev, DestroySamplerYcbcrConversion); INIT_PROC(false, dev, GetDeviceQueue2); @@ -352,6 +356,39 @@ bool InitDispatchTable( INIT_PROC(false, dev, GetBufferOpaqueCaptureAddress); INIT_PROC(false, dev, GetBufferDeviceAddress); INIT_PROC(false, dev, GetDeviceMemoryOpaqueCaptureAddress); + INIT_PROC(false, dev, CmdSetCullMode); + INIT_PROC(false, dev, CmdSetFrontFace); + INIT_PROC(false, dev, CmdSetPrimitiveTopology); + INIT_PROC(false, dev, CmdSetViewportWithCount); + INIT_PROC(false, dev, CmdSetScissorWithCount); + INIT_PROC(false, dev, CmdBindVertexBuffers2); + INIT_PROC(false, dev, CmdSetDepthTestEnable); + INIT_PROC(false, dev, CmdSetDepthWriteEnable); + INIT_PROC(false, dev, CmdSetDepthCompareOp); + INIT_PROC(false, dev, CmdSetDepthBoundsTestEnable); + INIT_PROC(false, dev, CmdSetStencilTestEnable); + INIT_PROC(false, dev, CmdSetStencilOp); + INIT_PROC(false, dev, CmdSetRasterizerDiscardEnable); + INIT_PROC(false, dev, CmdSetDepthBiasEnable); + INIT_PROC(false, dev, CmdSetPrimitiveRestartEnable); + INIT_PROC(false, dev, CreatePrivateDataSlot); + INIT_PROC(false, dev, DestroyPrivateDataSlot); + INIT_PROC(false, dev, SetPrivateData); + INIT_PROC(false, dev, GetPrivateData); + INIT_PROC(false, dev, CmdCopyBuffer2); + INIT_PROC(false, dev, CmdCopyImage2); + INIT_PROC(false, dev, CmdBlitImage2); + INIT_PROC(false, dev, CmdCopyBufferToImage2); + INIT_PROC(false, dev, CmdCopyImageToBuffer2); + INIT_PROC(false, dev, CmdResolveImage2); + INIT_PROC(false, dev, CmdSetEvent2); + INIT_PROC(false, dev, CmdResetEvent2); + INIT_PROC(false, dev, CmdWaitEvents2); + INIT_PROC(false, dev, CmdPipelineBarrier2); + INIT_PROC(false, dev, QueueSubmit2); + INIT_PROC(false, dev, CmdWriteTimestamp2); + INIT_PROC(false, dev, CmdBeginRendering); + INIT_PROC(false, dev, CmdEndRendering); // clang-format on return success; @@ -530,6 +567,9 @@ VKAPI_ATTR void UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet VKAPI_ATTR void GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); VKAPI_ATTR void GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); VKAPI_ATTR void GetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +VKAPI_ATTR void GetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void GetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void GetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); VKAPI_ATTR VkResult CreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); VKAPI_ATTR void DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); VKAPI_ATTR void GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); @@ -548,6 +588,40 @@ VKAPI_ATTR void CmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuf VKAPI_ATTR uint64_t GetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); VKAPI_ATTR VkDeviceAddress GetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); VKAPI_ATTR uint64_t GetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +VKAPI_ATTR VkResult GetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); +VKAPI_ATTR void CmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +VKAPI_ATTR void CmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +VKAPI_ATTR void CmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +VKAPI_ATTR void CmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +VKAPI_ATTR void CmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +VKAPI_ATTR void CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +VKAPI_ATTR void CmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +VKAPI_ATTR void CmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +VKAPI_ATTR void CmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +VKAPI_ATTR void CmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +VKAPI_ATTR void CmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +VKAPI_ATTR void CmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); +VKAPI_ATTR void CmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +VKAPI_ATTR void CmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +VKAPI_ATTR void CmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); +VKAPI_ATTR VkResult CreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); +VKAPI_ATTR void DestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR VkResult SetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +VKAPI_ATTR void GetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); +VKAPI_ATTR void CmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +VKAPI_ATTR void CmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +VKAPI_ATTR void CmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +VKAPI_ATTR void CmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +VKAPI_ATTR void CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +VKAPI_ATTR void CmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); +VKAPI_ATTR void CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +VKAPI_ATTR void CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +VKAPI_ATTR void CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +VKAPI_ATTR void CmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +VKAPI_ATTR VkResult QueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); +VKAPI_ATTR void CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +VKAPI_ATTR void CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo); +VKAPI_ATTR void CmdEndRendering(VkCommandBuffer commandBuffer); VKAPI_ATTR VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { return GetData(instance).dispatch.EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); @@ -625,6 +699,7 @@ VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pNa "vkGetPhysicalDeviceSurfaceFormatsKHR", "vkGetPhysicalDeviceSurfacePresentModesKHR", "vkGetPhysicalDeviceSurfaceSupportKHR", + "vkGetPhysicalDeviceToolProperties", "vkGetPhysicalDeviceToolPropertiesEXT", "vkGetPhysicalDeviceVideoCapabilitiesKHR", "vkGetPhysicalDeviceVideoFormatPropertiesKHR", @@ -680,18 +755,25 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkCmdBeginQuery", reinterpret_cast(CmdBeginQuery) }, { "vkCmdBeginRenderPass", reinterpret_cast(CmdBeginRenderPass) }, { "vkCmdBeginRenderPass2", reinterpret_cast(CmdBeginRenderPass2) }, + { "vkCmdBeginRendering", reinterpret_cast(CmdBeginRendering) }, { "vkCmdBindDescriptorSets", reinterpret_cast(CmdBindDescriptorSets) }, { "vkCmdBindIndexBuffer", reinterpret_cast(CmdBindIndexBuffer) }, { "vkCmdBindPipeline", reinterpret_cast(CmdBindPipeline) }, { "vkCmdBindVertexBuffers", reinterpret_cast(CmdBindVertexBuffers) }, + { "vkCmdBindVertexBuffers2", reinterpret_cast(CmdBindVertexBuffers2) }, { "vkCmdBlitImage", reinterpret_cast(CmdBlitImage) }, + { "vkCmdBlitImage2", reinterpret_cast(CmdBlitImage2) }, { "vkCmdClearAttachments", reinterpret_cast(CmdClearAttachments) }, { "vkCmdClearColorImage", reinterpret_cast(CmdClearColorImage) }, { "vkCmdClearDepthStencilImage", reinterpret_cast(CmdClearDepthStencilImage) }, { "vkCmdCopyBuffer", reinterpret_cast(CmdCopyBuffer) }, + { "vkCmdCopyBuffer2", reinterpret_cast(CmdCopyBuffer2) }, { "vkCmdCopyBufferToImage", reinterpret_cast(CmdCopyBufferToImage) }, + { "vkCmdCopyBufferToImage2", reinterpret_cast(CmdCopyBufferToImage2) }, { "vkCmdCopyImage", reinterpret_cast(CmdCopyImage) }, + { "vkCmdCopyImage2", reinterpret_cast(CmdCopyImage2) }, { "vkCmdCopyImageToBuffer", reinterpret_cast(CmdCopyImageToBuffer) }, + { "vkCmdCopyImageToBuffer2", reinterpret_cast(CmdCopyImageToBuffer2) }, { "vkCmdCopyQueryPoolResults", reinterpret_cast(CmdCopyQueryPoolResults) }, { "vkCmdDispatch", reinterpret_cast(CmdDispatch) }, { "vkCmdDispatchBase", reinterpret_cast(CmdDispatchBase) }, @@ -705,29 +787,50 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkCmdEndQuery", reinterpret_cast(CmdEndQuery) }, { "vkCmdEndRenderPass", reinterpret_cast(CmdEndRenderPass) }, { "vkCmdEndRenderPass2", reinterpret_cast(CmdEndRenderPass2) }, + { "vkCmdEndRendering", reinterpret_cast(CmdEndRendering) }, { "vkCmdExecuteCommands", reinterpret_cast(CmdExecuteCommands) }, { "vkCmdFillBuffer", reinterpret_cast(CmdFillBuffer) }, { "vkCmdNextSubpass", reinterpret_cast(CmdNextSubpass) }, { "vkCmdNextSubpass2", reinterpret_cast(CmdNextSubpass2) }, { "vkCmdPipelineBarrier", reinterpret_cast(CmdPipelineBarrier) }, + { "vkCmdPipelineBarrier2", reinterpret_cast(CmdPipelineBarrier2) }, { "vkCmdPushConstants", reinterpret_cast(CmdPushConstants) }, { "vkCmdResetEvent", reinterpret_cast(CmdResetEvent) }, + { "vkCmdResetEvent2", reinterpret_cast(CmdResetEvent2) }, { "vkCmdResetQueryPool", reinterpret_cast(CmdResetQueryPool) }, { "vkCmdResolveImage", reinterpret_cast(CmdResolveImage) }, + { "vkCmdResolveImage2", reinterpret_cast(CmdResolveImage2) }, { "vkCmdSetBlendConstants", reinterpret_cast(CmdSetBlendConstants) }, + { "vkCmdSetCullMode", reinterpret_cast(CmdSetCullMode) }, { "vkCmdSetDepthBias", reinterpret_cast(CmdSetDepthBias) }, + { "vkCmdSetDepthBiasEnable", reinterpret_cast(CmdSetDepthBiasEnable) }, { "vkCmdSetDepthBounds", reinterpret_cast(CmdSetDepthBounds) }, + { "vkCmdSetDepthBoundsTestEnable", reinterpret_cast(CmdSetDepthBoundsTestEnable) }, + { "vkCmdSetDepthCompareOp", reinterpret_cast(CmdSetDepthCompareOp) }, + { "vkCmdSetDepthTestEnable", reinterpret_cast(CmdSetDepthTestEnable) }, + { "vkCmdSetDepthWriteEnable", reinterpret_cast(CmdSetDepthWriteEnable) }, { "vkCmdSetDeviceMask", reinterpret_cast(CmdSetDeviceMask) }, { "vkCmdSetEvent", reinterpret_cast(CmdSetEvent) }, + { "vkCmdSetEvent2", reinterpret_cast(CmdSetEvent2) }, + { "vkCmdSetFrontFace", reinterpret_cast(CmdSetFrontFace) }, { "vkCmdSetLineWidth", reinterpret_cast(CmdSetLineWidth) }, + { "vkCmdSetPrimitiveRestartEnable", reinterpret_cast(CmdSetPrimitiveRestartEnable) }, + { "vkCmdSetPrimitiveTopology", reinterpret_cast(CmdSetPrimitiveTopology) }, + { "vkCmdSetRasterizerDiscardEnable", reinterpret_cast(CmdSetRasterizerDiscardEnable) }, { "vkCmdSetScissor", reinterpret_cast(CmdSetScissor) }, + { "vkCmdSetScissorWithCount", reinterpret_cast(CmdSetScissorWithCount) }, { "vkCmdSetStencilCompareMask", reinterpret_cast(CmdSetStencilCompareMask) }, + { "vkCmdSetStencilOp", reinterpret_cast(CmdSetStencilOp) }, { "vkCmdSetStencilReference", reinterpret_cast(CmdSetStencilReference) }, + { "vkCmdSetStencilTestEnable", reinterpret_cast(CmdSetStencilTestEnable) }, { "vkCmdSetStencilWriteMask", reinterpret_cast(CmdSetStencilWriteMask) }, { "vkCmdSetViewport", reinterpret_cast(CmdSetViewport) }, + { "vkCmdSetViewportWithCount", reinterpret_cast(CmdSetViewportWithCount) }, { "vkCmdUpdateBuffer", reinterpret_cast(CmdUpdateBuffer) }, { "vkCmdWaitEvents", reinterpret_cast(CmdWaitEvents) }, + { "vkCmdWaitEvents2", reinterpret_cast(CmdWaitEvents2) }, { "vkCmdWriteTimestamp", reinterpret_cast(CmdWriteTimestamp) }, + { "vkCmdWriteTimestamp2", reinterpret_cast(CmdWriteTimestamp2) }, { "vkCreateBuffer", reinterpret_cast(CreateBuffer) }, { "vkCreateBufferView", reinterpret_cast(CreateBufferView) }, { "vkCreateCommandPool", reinterpret_cast(CreateCommandPool) }, @@ -745,6 +848,7 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkCreateInstance", nullptr }, { "vkCreatePipelineCache", reinterpret_cast(CreatePipelineCache) }, { "vkCreatePipelineLayout", reinterpret_cast(CreatePipelineLayout) }, + { "vkCreatePrivateDataSlot", reinterpret_cast(CreatePrivateDataSlot) }, { "vkCreateQueryPool", reinterpret_cast(CreateQueryPool) }, { "vkCreateRenderPass", reinterpret_cast(CreateRenderPass) }, { "vkCreateRenderPass2", reinterpret_cast(CreateRenderPass2) }, @@ -769,6 +873,7 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkDestroyPipeline", reinterpret_cast(DestroyPipeline) }, { "vkDestroyPipelineCache", reinterpret_cast(DestroyPipelineCache) }, { "vkDestroyPipelineLayout", reinterpret_cast(DestroyPipelineLayout) }, + { "vkDestroyPrivateDataSlot", reinterpret_cast(DestroyPrivateDataSlot) }, { "vkDestroyQueryPool", reinterpret_cast(DestroyQueryPool) }, { "vkDestroyRenderPass", reinterpret_cast(DestroyRenderPass) }, { "vkDestroySampler", reinterpret_cast(DestroySampler) }, @@ -793,9 +898,12 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkGetBufferMemoryRequirements2", reinterpret_cast(GetBufferMemoryRequirements2) }, { "vkGetBufferOpaqueCaptureAddress", reinterpret_cast(GetBufferOpaqueCaptureAddress) }, { "vkGetDescriptorSetLayoutSupport", reinterpret_cast(GetDescriptorSetLayoutSupport) }, + { "vkGetDeviceBufferMemoryRequirements", reinterpret_cast(GetDeviceBufferMemoryRequirements) }, { "vkGetDeviceGroupPeerMemoryFeatures", reinterpret_cast(GetDeviceGroupPeerMemoryFeatures) }, { "vkGetDeviceGroupPresentCapabilitiesKHR", reinterpret_cast(GetDeviceGroupPresentCapabilitiesKHR) }, { "vkGetDeviceGroupSurfacePresentModesKHR", reinterpret_cast(GetDeviceGroupSurfacePresentModesKHR) }, + { "vkGetDeviceImageMemoryRequirements", reinterpret_cast(GetDeviceImageMemoryRequirements) }, + { "vkGetDeviceImageSparseMemoryRequirements", reinterpret_cast(GetDeviceImageSparseMemoryRequirements) }, { "vkGetDeviceMemoryCommitment", reinterpret_cast(GetDeviceMemoryCommitment) }, { "vkGetDeviceMemoryOpaqueCaptureAddress", reinterpret_cast(GetDeviceMemoryOpaqueCaptureAddress) }, { "vkGetDeviceProcAddr", reinterpret_cast(GetDeviceProcAddr) }, @@ -811,6 +919,7 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkGetInstanceProcAddr", reinterpret_cast(GetInstanceProcAddr) }, { "vkGetMemoryAndroidHardwareBufferANDROID", reinterpret_cast(GetMemoryAndroidHardwareBufferANDROID) }, { "vkGetPipelineCacheData", reinterpret_cast(GetPipelineCacheData) }, + { "vkGetPrivateData", reinterpret_cast(GetPrivateData) }, { "vkGetQueryPoolResults", reinterpret_cast(GetQueryPoolResults) }, { "vkGetRenderAreaGranularity", reinterpret_cast(GetRenderAreaGranularity) }, { "vkGetSemaphoreCounterValue", reinterpret_cast(GetSemaphoreCounterValue) }, @@ -821,6 +930,7 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkQueueBindSparse", reinterpret_cast(QueueBindSparse) }, { "vkQueuePresentKHR", reinterpret_cast(QueuePresentKHR) }, { "vkQueueSubmit", reinterpret_cast(QueueSubmit) }, + { "vkQueueSubmit2", reinterpret_cast(QueueSubmit2) }, { "vkQueueWaitIdle", reinterpret_cast(QueueWaitIdle) }, { "vkResetCommandBuffer", reinterpret_cast(ResetCommandBuffer) }, { "vkResetCommandPool", reinterpret_cast(ResetCommandPool) }, @@ -829,6 +939,7 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkResetFences", reinterpret_cast(ResetFences) }, { "vkResetQueryPool", reinterpret_cast(ResetQueryPool) }, { "vkSetEvent", reinterpret_cast(SetEvent) }, + { "vkSetPrivateData", reinterpret_cast(SetPrivateData) }, { "vkSignalSemaphore", reinterpret_cast(SignalSemaphore) }, { "vkTrimCommandPool", reinterpret_cast(TrimCommandPool) }, { "vkUnmapMemory", reinterpret_cast(UnmapMemory) }, @@ -1515,6 +1626,18 @@ VKAPI_ATTR void GetImageSparseMemoryRequirements2(VkDevice device, const VkImage GetData(device).dispatch.GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } +VKAPI_ATTR void GetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + GetData(device).dispatch.GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); +} + +VKAPI_ATTR void GetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + GetData(device).dispatch.GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); +} + +VKAPI_ATTR void GetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + GetData(device).dispatch.GetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} + VKAPI_ATTR VkResult CreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { return GetData(device).dispatch.CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); } @@ -1587,6 +1710,142 @@ VKAPI_ATTR uint64_t GetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const V return GetData(device).dispatch.GetDeviceMemoryOpaqueCaptureAddress(device, pInfo); } +VKAPI_ATTR VkResult GetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) { + return GetData(physicalDevice).dispatch.GetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties); +} + +VKAPI_ATTR void CmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { + GetData(commandBuffer).dispatch.CmdSetCullMode(commandBuffer, cullMode); +} + +VKAPI_ATTR void CmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) { + GetData(commandBuffer).dispatch.CmdSetFrontFace(commandBuffer, frontFace); +} + +VKAPI_ATTR void CmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { + GetData(commandBuffer).dispatch.CmdSetPrimitiveTopology(commandBuffer, primitiveTopology); +} + +VKAPI_ATTR void CmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) { + GetData(commandBuffer).dispatch.CmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); +} + +VKAPI_ATTR void CmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) { + GetData(commandBuffer).dispatch.CmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); +} + +VKAPI_ATTR void CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { + GetData(commandBuffer).dispatch.CmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); +} + +VKAPI_ATTR void CmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { + GetData(commandBuffer).dispatch.CmdSetDepthTestEnable(commandBuffer, depthTestEnable); +} + +VKAPI_ATTR void CmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { + GetData(commandBuffer).dispatch.CmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); +} + +VKAPI_ATTR void CmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { + GetData(commandBuffer).dispatch.CmdSetDepthCompareOp(commandBuffer, depthCompareOp); +} + +VKAPI_ATTR void CmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { + GetData(commandBuffer).dispatch.CmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); +} + +VKAPI_ATTR void CmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { + GetData(commandBuffer).dispatch.CmdSetStencilTestEnable(commandBuffer, stencilTestEnable); +} + +VKAPI_ATTR void CmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { + GetData(commandBuffer).dispatch.CmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); +} + +VKAPI_ATTR void CmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) { + GetData(commandBuffer).dispatch.CmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); +} + +VKAPI_ATTR void CmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { + GetData(commandBuffer).dispatch.CmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); +} + +VKAPI_ATTR void CmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { + GetData(commandBuffer).dispatch.CmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); +} + +VKAPI_ATTR VkResult CreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) { + return GetData(device).dispatch.CreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot); +} + +VKAPI_ATTR void DestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) { + GetData(device).dispatch.DestroyPrivateDataSlot(device, privateDataSlot, pAllocator); +} + +VKAPI_ATTR VkResult SetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { + return GetData(device).dispatch.SetPrivateData(device, objectType, objectHandle, privateDataSlot, data); +} + +VKAPI_ATTR void GetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) { + GetData(device).dispatch.GetPrivateData(device, objectType, objectHandle, privateDataSlot, pData); +} + +VKAPI_ATTR void CmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { + GetData(commandBuffer).dispatch.CmdCopyBuffer2(commandBuffer, pCopyBufferInfo); +} + +VKAPI_ATTR void CmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { + GetData(commandBuffer).dispatch.CmdCopyImage2(commandBuffer, pCopyImageInfo); +} + +VKAPI_ATTR void CmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { + GetData(commandBuffer).dispatch.CmdBlitImage2(commandBuffer, pBlitImageInfo); +} + +VKAPI_ATTR void CmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { + GetData(commandBuffer).dispatch.CmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); +} + +VKAPI_ATTR void CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { + GetData(commandBuffer).dispatch.CmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); +} + +VKAPI_ATTR void CmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) { + GetData(commandBuffer).dispatch.CmdResolveImage2(commandBuffer, pResolveImageInfo); +} + +VKAPI_ATTR void CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) { + GetData(commandBuffer).dispatch.CmdSetEvent2(commandBuffer, event, pDependencyInfo); +} + +VKAPI_ATTR void CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) { + GetData(commandBuffer).dispatch.CmdResetEvent2(commandBuffer, event, stageMask); +} + +VKAPI_ATTR void CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) { + GetData(commandBuffer).dispatch.CmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); +} + +VKAPI_ATTR void CmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) { + GetData(commandBuffer).dispatch.CmdPipelineBarrier2(commandBuffer, pDependencyInfo); +} + +VKAPI_ATTR VkResult QueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) { + return GetData(queue).dispatch.QueueSubmit2(queue, submitCount, pSubmits, fence); +} + +VKAPI_ATTR void CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) { + GetData(commandBuffer).dispatch.CmdWriteTimestamp2(commandBuffer, stage, queryPool, query); +} + +VKAPI_ATTR void CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo) { + GetData(commandBuffer).dispatch.CmdBeginRendering(commandBuffer, pRenderingInfo); +} + +VKAPI_ATTR void CmdEndRendering(VkCommandBuffer commandBuffer) { + GetData(commandBuffer).dispatch.CmdEndRendering(commandBuffer); +} + } // anonymous namespace @@ -2482,6 +2741,21 @@ VKAPI_ATTR void vkGetImageSparseMemoryRequirements2(VkDevice device, const VkIma vulkan::api::GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } +__attribute__((visibility("default"))) +VKAPI_ATTR void vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + vulkan::api::GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + vulkan::api::GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + vulkan::api::GetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} + __attribute__((visibility("default"))) VKAPI_ATTR VkResult vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { return vulkan::api::CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); @@ -2572,4 +2846,174 @@ VKAPI_ATTR uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const return vulkan::api::GetDeviceMemoryOpaqueCaptureAddress(device, pInfo); } +__attribute__((visibility("default"))) +VKAPI_ATTR VkResult vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) { + return vulkan::api::GetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { + vulkan::api::CmdSetCullMode(commandBuffer, cullMode); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) { + vulkan::api::CmdSetFrontFace(commandBuffer, frontFace); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { + vulkan::api::CmdSetPrimitiveTopology(commandBuffer, primitiveTopology); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) { + vulkan::api::CmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) { + vulkan::api::CmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { + vulkan::api::CmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { + vulkan::api::CmdSetDepthTestEnable(commandBuffer, depthTestEnable); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { + vulkan::api::CmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { + vulkan::api::CmdSetDepthCompareOp(commandBuffer, depthCompareOp); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { + vulkan::api::CmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { + vulkan::api::CmdSetStencilTestEnable(commandBuffer, stencilTestEnable); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { + vulkan::api::CmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) { + vulkan::api::CmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { + vulkan::api::CmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { + vulkan::api::CmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR VkResult vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) { + return vulkan::api::CreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) { + vulkan::api::DestroyPrivateDataSlot(device, privateDataSlot, pAllocator); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR VkResult vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { + return vulkan::api::SetPrivateData(device, objectType, objectHandle, privateDataSlot, data); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) { + vulkan::api::GetPrivateData(device, objectType, objectHandle, privateDataSlot, pData); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { + vulkan::api::CmdCopyBuffer2(commandBuffer, pCopyBufferInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { + vulkan::api::CmdCopyImage2(commandBuffer, pCopyImageInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { + vulkan::api::CmdBlitImage2(commandBuffer, pBlitImageInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { + vulkan::api::CmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { + vulkan::api::CmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) { + vulkan::api::CmdResolveImage2(commandBuffer, pResolveImageInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) { + vulkan::api::CmdSetEvent2(commandBuffer, event, pDependencyInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) { + vulkan::api::CmdResetEvent2(commandBuffer, event, stageMask); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) { + vulkan::api::CmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) { + vulkan::api::CmdPipelineBarrier2(commandBuffer, pDependencyInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR VkResult vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) { + return vulkan::api::QueueSubmit2(queue, submitCount, pSubmits, fence); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) { + vulkan::api::CmdWriteTimestamp2(commandBuffer, stage, queryPool, query); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo) { + vulkan::api::CmdBeginRendering(commandBuffer, pRenderingInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdEndRendering(VkCommandBuffer commandBuffer) { + vulkan::api::CmdEndRendering(commandBuffer); +} + // clang-format on diff --git a/vulkan/libvulkan/api_gen.h b/vulkan/libvulkan/api_gen.h index ad5cc34799..4998018882 100644 --- a/vulkan/libvulkan/api_gen.h +++ b/vulkan/libvulkan/api_gen.h @@ -60,6 +60,7 @@ struct InstanceDispatchTable { PFN_vkGetPhysicalDeviceExternalFenceProperties GetPhysicalDeviceExternalFenceProperties; PFN_vkEnumeratePhysicalDeviceGroups EnumeratePhysicalDeviceGroups; PFN_vkGetPhysicalDevicePresentRectanglesKHR GetPhysicalDevicePresentRectanglesKHR; + PFN_vkGetPhysicalDeviceToolProperties GetPhysicalDeviceToolProperties; // clang-format on }; @@ -207,6 +208,9 @@ struct DeviceDispatchTable { PFN_vkGetBufferMemoryRequirements2 GetBufferMemoryRequirements2; PFN_vkGetImageMemoryRequirements2 GetImageMemoryRequirements2; PFN_vkGetImageSparseMemoryRequirements2 GetImageSparseMemoryRequirements2; + PFN_vkGetDeviceBufferMemoryRequirements GetDeviceBufferMemoryRequirements; + PFN_vkGetDeviceImageMemoryRequirements GetDeviceImageMemoryRequirements; + PFN_vkGetDeviceImageSparseMemoryRequirements GetDeviceImageSparseMemoryRequirements; PFN_vkCreateSamplerYcbcrConversion CreateSamplerYcbcrConversion; PFN_vkDestroySamplerYcbcrConversion DestroySamplerYcbcrConversion; PFN_vkGetDeviceQueue2 GetDeviceQueue2; @@ -225,6 +229,39 @@ struct DeviceDispatchTable { PFN_vkGetBufferOpaqueCaptureAddress GetBufferOpaqueCaptureAddress; PFN_vkGetBufferDeviceAddress GetBufferDeviceAddress; PFN_vkGetDeviceMemoryOpaqueCaptureAddress GetDeviceMemoryOpaqueCaptureAddress; + PFN_vkCmdSetCullMode CmdSetCullMode; + PFN_vkCmdSetFrontFace CmdSetFrontFace; + PFN_vkCmdSetPrimitiveTopology CmdSetPrimitiveTopology; + PFN_vkCmdSetViewportWithCount CmdSetViewportWithCount; + PFN_vkCmdSetScissorWithCount CmdSetScissorWithCount; + PFN_vkCmdBindVertexBuffers2 CmdBindVertexBuffers2; + PFN_vkCmdSetDepthTestEnable CmdSetDepthTestEnable; + PFN_vkCmdSetDepthWriteEnable CmdSetDepthWriteEnable; + PFN_vkCmdSetDepthCompareOp CmdSetDepthCompareOp; + PFN_vkCmdSetDepthBoundsTestEnable CmdSetDepthBoundsTestEnable; + PFN_vkCmdSetStencilTestEnable CmdSetStencilTestEnable; + PFN_vkCmdSetStencilOp CmdSetStencilOp; + PFN_vkCmdSetRasterizerDiscardEnable CmdSetRasterizerDiscardEnable; + PFN_vkCmdSetDepthBiasEnable CmdSetDepthBiasEnable; + PFN_vkCmdSetPrimitiveRestartEnable CmdSetPrimitiveRestartEnable; + PFN_vkCreatePrivateDataSlot CreatePrivateDataSlot; + PFN_vkDestroyPrivateDataSlot DestroyPrivateDataSlot; + PFN_vkSetPrivateData SetPrivateData; + PFN_vkGetPrivateData GetPrivateData; + PFN_vkCmdCopyBuffer2 CmdCopyBuffer2; + PFN_vkCmdCopyImage2 CmdCopyImage2; + PFN_vkCmdBlitImage2 CmdBlitImage2; + PFN_vkCmdCopyBufferToImage2 CmdCopyBufferToImage2; + PFN_vkCmdCopyImageToBuffer2 CmdCopyImageToBuffer2; + PFN_vkCmdResolveImage2 CmdResolveImage2; + PFN_vkCmdSetEvent2 CmdSetEvent2; + PFN_vkCmdResetEvent2 CmdResetEvent2; + PFN_vkCmdWaitEvents2 CmdWaitEvents2; + PFN_vkCmdPipelineBarrier2 CmdPipelineBarrier2; + PFN_vkQueueSubmit2 QueueSubmit2; + PFN_vkCmdWriteTimestamp2 CmdWriteTimestamp2; + PFN_vkCmdBeginRendering CmdBeginRendering; + PFN_vkCmdEndRendering CmdEndRendering; // clang-format on }; diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 648353ee1d..238429f957 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -657,6 +657,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::EXTENSION_CORE_1_0: case ProcHook::EXTENSION_CORE_1_1: case ProcHook::EXTENSION_CORE_1_2: + case ProcHook::EXTENSION_CORE_1_3: case ProcHook::EXTENSION_COUNT: // Device and meta extensions. If we ever get here it's a bug in // our code. But enumerating them lets us avoid having a default @@ -711,6 +712,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::EXTENSION_CORE_1_0: case ProcHook::EXTENSION_CORE_1_1: case ProcHook::EXTENSION_CORE_1_2: + case ProcHook::EXTENSION_CORE_1_3: case ProcHook::EXTENSION_COUNT: // Instance and meta extensions. If we ever get here it's a bug // in our code. But enumerating them lets us avoid having a diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 047e774004..819f6b211c 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -58,6 +58,7 @@ struct ProcHook { EXTENSION_CORE_1_0, EXTENSION_CORE_1_1, EXTENSION_CORE_1_2, + EXTENSION_CORE_1_3, EXTENSION_COUNT, EXTENSION_UNKNOWN, }; diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp index edda12c6f9..f6dcf0900c 100644 --- a/vulkan/nulldrv/null_driver_gen.cpp +++ b/vulkan/nulldrv/null_driver_gen.cpp @@ -68,18 +68,25 @@ const NameProc kInstanceProcs[] = { {"vkCmdBeginQuery", reinterpret_cast(static_cast(CmdBeginQuery))}, {"vkCmdBeginRenderPass", reinterpret_cast(static_cast(CmdBeginRenderPass))}, {"vkCmdBeginRenderPass2", reinterpret_cast(static_cast(CmdBeginRenderPass2))}, + {"vkCmdBeginRendering", reinterpret_cast(static_cast(CmdBeginRendering))}, {"vkCmdBindDescriptorSets", reinterpret_cast(static_cast(CmdBindDescriptorSets))}, {"vkCmdBindIndexBuffer", reinterpret_cast(static_cast(CmdBindIndexBuffer))}, {"vkCmdBindPipeline", reinterpret_cast(static_cast(CmdBindPipeline))}, {"vkCmdBindVertexBuffers", reinterpret_cast(static_cast(CmdBindVertexBuffers))}, + {"vkCmdBindVertexBuffers2", reinterpret_cast(static_cast(CmdBindVertexBuffers2))}, {"vkCmdBlitImage", reinterpret_cast(static_cast(CmdBlitImage))}, + {"vkCmdBlitImage2", reinterpret_cast(static_cast(CmdBlitImage2))}, {"vkCmdClearAttachments", reinterpret_cast(static_cast(CmdClearAttachments))}, {"vkCmdClearColorImage", reinterpret_cast(static_cast(CmdClearColorImage))}, {"vkCmdClearDepthStencilImage", reinterpret_cast(static_cast(CmdClearDepthStencilImage))}, {"vkCmdCopyBuffer", reinterpret_cast(static_cast(CmdCopyBuffer))}, + {"vkCmdCopyBuffer2", reinterpret_cast(static_cast(CmdCopyBuffer2))}, {"vkCmdCopyBufferToImage", reinterpret_cast(static_cast(CmdCopyBufferToImage))}, + {"vkCmdCopyBufferToImage2", reinterpret_cast(static_cast(CmdCopyBufferToImage2))}, {"vkCmdCopyImage", reinterpret_cast(static_cast(CmdCopyImage))}, + {"vkCmdCopyImage2", reinterpret_cast(static_cast(CmdCopyImage2))}, {"vkCmdCopyImageToBuffer", reinterpret_cast(static_cast(CmdCopyImageToBuffer))}, + {"vkCmdCopyImageToBuffer2", reinterpret_cast(static_cast(CmdCopyImageToBuffer2))}, {"vkCmdCopyQueryPoolResults", reinterpret_cast(static_cast(CmdCopyQueryPoolResults))}, {"vkCmdDispatch", reinterpret_cast(static_cast(CmdDispatch))}, {"vkCmdDispatchBase", reinterpret_cast(static_cast(CmdDispatchBase))}, @@ -93,29 +100,50 @@ const NameProc kInstanceProcs[] = { {"vkCmdEndQuery", reinterpret_cast(static_cast(CmdEndQuery))}, {"vkCmdEndRenderPass", reinterpret_cast(static_cast(CmdEndRenderPass))}, {"vkCmdEndRenderPass2", reinterpret_cast(static_cast(CmdEndRenderPass2))}, + {"vkCmdEndRendering", reinterpret_cast(static_cast(CmdEndRendering))}, {"vkCmdExecuteCommands", reinterpret_cast(static_cast(CmdExecuteCommands))}, {"vkCmdFillBuffer", reinterpret_cast(static_cast(CmdFillBuffer))}, {"vkCmdNextSubpass", reinterpret_cast(static_cast(CmdNextSubpass))}, {"vkCmdNextSubpass2", reinterpret_cast(static_cast(CmdNextSubpass2))}, {"vkCmdPipelineBarrier", reinterpret_cast(static_cast(CmdPipelineBarrier))}, + {"vkCmdPipelineBarrier2", reinterpret_cast(static_cast(CmdPipelineBarrier2))}, {"vkCmdPushConstants", reinterpret_cast(static_cast(CmdPushConstants))}, {"vkCmdResetEvent", reinterpret_cast(static_cast(CmdResetEvent))}, + {"vkCmdResetEvent2", reinterpret_cast(static_cast(CmdResetEvent2))}, {"vkCmdResetQueryPool", reinterpret_cast(static_cast(CmdResetQueryPool))}, {"vkCmdResolveImage", reinterpret_cast(static_cast(CmdResolveImage))}, + {"vkCmdResolveImage2", reinterpret_cast(static_cast(CmdResolveImage2))}, {"vkCmdSetBlendConstants", reinterpret_cast(static_cast(CmdSetBlendConstants))}, + {"vkCmdSetCullMode", reinterpret_cast(static_cast(CmdSetCullMode))}, {"vkCmdSetDepthBias", reinterpret_cast(static_cast(CmdSetDepthBias))}, + {"vkCmdSetDepthBiasEnable", reinterpret_cast(static_cast(CmdSetDepthBiasEnable))}, {"vkCmdSetDepthBounds", reinterpret_cast(static_cast(CmdSetDepthBounds))}, + {"vkCmdSetDepthBoundsTestEnable", reinterpret_cast(static_cast(CmdSetDepthBoundsTestEnable))}, + {"vkCmdSetDepthCompareOp", reinterpret_cast(static_cast(CmdSetDepthCompareOp))}, + {"vkCmdSetDepthTestEnable", reinterpret_cast(static_cast(CmdSetDepthTestEnable))}, + {"vkCmdSetDepthWriteEnable", reinterpret_cast(static_cast(CmdSetDepthWriteEnable))}, {"vkCmdSetDeviceMask", reinterpret_cast(static_cast(CmdSetDeviceMask))}, {"vkCmdSetEvent", reinterpret_cast(static_cast(CmdSetEvent))}, + {"vkCmdSetEvent2", reinterpret_cast(static_cast(CmdSetEvent2))}, + {"vkCmdSetFrontFace", reinterpret_cast(static_cast(CmdSetFrontFace))}, {"vkCmdSetLineWidth", reinterpret_cast(static_cast(CmdSetLineWidth))}, + {"vkCmdSetPrimitiveRestartEnable", reinterpret_cast(static_cast(CmdSetPrimitiveRestartEnable))}, + {"vkCmdSetPrimitiveTopology", reinterpret_cast(static_cast(CmdSetPrimitiveTopology))}, + {"vkCmdSetRasterizerDiscardEnable", reinterpret_cast(static_cast(CmdSetRasterizerDiscardEnable))}, {"vkCmdSetScissor", reinterpret_cast(static_cast(CmdSetScissor))}, + {"vkCmdSetScissorWithCount", reinterpret_cast(static_cast(CmdSetScissorWithCount))}, {"vkCmdSetStencilCompareMask", reinterpret_cast(static_cast(CmdSetStencilCompareMask))}, + {"vkCmdSetStencilOp", reinterpret_cast(static_cast(CmdSetStencilOp))}, {"vkCmdSetStencilReference", reinterpret_cast(static_cast(CmdSetStencilReference))}, + {"vkCmdSetStencilTestEnable", reinterpret_cast(static_cast(CmdSetStencilTestEnable))}, {"vkCmdSetStencilWriteMask", reinterpret_cast(static_cast(CmdSetStencilWriteMask))}, {"vkCmdSetViewport", reinterpret_cast(static_cast(CmdSetViewport))}, + {"vkCmdSetViewportWithCount", reinterpret_cast(static_cast(CmdSetViewportWithCount))}, {"vkCmdUpdateBuffer", reinterpret_cast(static_cast(CmdUpdateBuffer))}, {"vkCmdWaitEvents", reinterpret_cast(static_cast(CmdWaitEvents))}, + {"vkCmdWaitEvents2", reinterpret_cast(static_cast(CmdWaitEvents2))}, {"vkCmdWriteTimestamp", reinterpret_cast(static_cast(CmdWriteTimestamp))}, + {"vkCmdWriteTimestamp2", reinterpret_cast(static_cast(CmdWriteTimestamp2))}, {"vkCreateBuffer", reinterpret_cast(static_cast(CreateBuffer))}, {"vkCreateBufferView", reinterpret_cast(static_cast(CreateBufferView))}, {"vkCreateCommandPool", reinterpret_cast(static_cast(CreateCommandPool))}, @@ -134,6 +162,7 @@ const NameProc kInstanceProcs[] = { {"vkCreateInstance", reinterpret_cast(static_cast(CreateInstance))}, {"vkCreatePipelineCache", reinterpret_cast(static_cast(CreatePipelineCache))}, {"vkCreatePipelineLayout", reinterpret_cast(static_cast(CreatePipelineLayout))}, + {"vkCreatePrivateDataSlot", reinterpret_cast(static_cast(CreatePrivateDataSlot))}, {"vkCreateQueryPool", reinterpret_cast(static_cast(CreateQueryPool))}, {"vkCreateRenderPass", reinterpret_cast(static_cast(CreateRenderPass))}, {"vkCreateRenderPass2", reinterpret_cast(static_cast(CreateRenderPass2))}, @@ -159,6 +188,7 @@ const NameProc kInstanceProcs[] = { {"vkDestroyPipeline", reinterpret_cast(static_cast(DestroyPipeline))}, {"vkDestroyPipelineCache", reinterpret_cast(static_cast(DestroyPipelineCache))}, {"vkDestroyPipelineLayout", reinterpret_cast(static_cast(DestroyPipelineLayout))}, + {"vkDestroyPrivateDataSlot", reinterpret_cast(static_cast(DestroyPrivateDataSlot))}, {"vkDestroyQueryPool", reinterpret_cast(static_cast(DestroyQueryPool))}, {"vkDestroyRenderPass", reinterpret_cast(static_cast(DestroyRenderPass))}, {"vkDestroySampler", reinterpret_cast(static_cast(DestroySampler))}, @@ -183,7 +213,10 @@ const NameProc kInstanceProcs[] = { {"vkGetBufferMemoryRequirements2", reinterpret_cast(static_cast(GetBufferMemoryRequirements2))}, {"vkGetBufferOpaqueCaptureAddress", reinterpret_cast(static_cast(GetBufferOpaqueCaptureAddress))}, {"vkGetDescriptorSetLayoutSupport", reinterpret_cast(static_cast(GetDescriptorSetLayoutSupport))}, + {"vkGetDeviceBufferMemoryRequirements", reinterpret_cast(static_cast(GetDeviceBufferMemoryRequirements))}, {"vkGetDeviceGroupPeerMemoryFeatures", reinterpret_cast(static_cast(GetDeviceGroupPeerMemoryFeatures))}, + {"vkGetDeviceImageMemoryRequirements", reinterpret_cast(static_cast(GetDeviceImageMemoryRequirements))}, + {"vkGetDeviceImageSparseMemoryRequirements", reinterpret_cast(static_cast(GetDeviceImageSparseMemoryRequirements))}, {"vkGetDeviceMemoryCommitment", reinterpret_cast(static_cast(GetDeviceMemoryCommitment))}, {"vkGetDeviceMemoryOpaqueCaptureAddress", reinterpret_cast(static_cast(GetDeviceMemoryOpaqueCaptureAddress))}, {"vkGetDeviceProcAddr", reinterpret_cast(static_cast(GetDeviceProcAddr))}, @@ -221,7 +254,9 @@ const NameProc kInstanceProcs[] = { {"vkGetPhysicalDeviceSparseImageFormatProperties", reinterpret_cast(static_cast(GetPhysicalDeviceSparseImageFormatProperties))}, {"vkGetPhysicalDeviceSparseImageFormatProperties2", reinterpret_cast(static_cast(GetPhysicalDeviceSparseImageFormatProperties2))}, {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", reinterpret_cast(static_cast(GetPhysicalDeviceSparseImageFormatProperties2KHR))}, + {"vkGetPhysicalDeviceToolProperties", reinterpret_cast(static_cast(GetPhysicalDeviceToolProperties))}, {"vkGetPipelineCacheData", reinterpret_cast(static_cast(GetPipelineCacheData))}, + {"vkGetPrivateData", reinterpret_cast(static_cast(GetPrivateData))}, {"vkGetQueryPoolResults", reinterpret_cast(static_cast(GetQueryPoolResults))}, {"vkGetRenderAreaGranularity", reinterpret_cast(static_cast(GetRenderAreaGranularity))}, {"vkGetSemaphoreCounterValue", reinterpret_cast(static_cast(GetSemaphoreCounterValue))}, @@ -233,6 +268,7 @@ const NameProc kInstanceProcs[] = { {"vkQueueBindSparse", reinterpret_cast(static_cast(QueueBindSparse))}, {"vkQueueSignalReleaseImageANDROID", reinterpret_cast(static_cast(QueueSignalReleaseImageANDROID))}, {"vkQueueSubmit", reinterpret_cast(static_cast(QueueSubmit))}, + {"vkQueueSubmit2", reinterpret_cast(static_cast(QueueSubmit2))}, {"vkQueueWaitIdle", reinterpret_cast(static_cast(QueueWaitIdle))}, {"vkResetCommandBuffer", reinterpret_cast(static_cast(ResetCommandBuffer))}, {"vkResetCommandPool", reinterpret_cast(static_cast(ResetCommandPool))}, @@ -241,6 +277,7 @@ const NameProc kInstanceProcs[] = { {"vkResetFences", reinterpret_cast(static_cast(ResetFences))}, {"vkResetQueryPool", reinterpret_cast(static_cast(ResetQueryPool))}, {"vkSetEvent", reinterpret_cast(static_cast(SetEvent))}, + {"vkSetPrivateData", reinterpret_cast(static_cast(SetPrivateData))}, {"vkSignalSemaphore", reinterpret_cast(static_cast(SignalSemaphore))}, {"vkTrimCommandPool", reinterpret_cast(static_cast(TrimCommandPool))}, {"vkUnmapMemory", reinterpret_cast(static_cast(UnmapMemory))}, diff --git a/vulkan/nulldrv/null_driver_gen.h b/vulkan/nulldrv/null_driver_gen.h index e59cae925f..315f1dcb08 100644 --- a/vulkan/nulldrv/null_driver_gen.h +++ b/vulkan/nulldrv/null_driver_gen.h @@ -200,6 +200,9 @@ VKAPI_ATTR void UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet VKAPI_ATTR void GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); VKAPI_ATTR void GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); VKAPI_ATTR void GetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +VKAPI_ATTR void GetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void GetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void GetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); VKAPI_ATTR VkResult CreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); VKAPI_ATTR void DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); VKAPI_ATTR void GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); @@ -220,6 +223,40 @@ VKAPI_ATTR void CmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuf VKAPI_ATTR uint64_t GetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); VKAPI_ATTR VkDeviceAddress GetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); VKAPI_ATTR uint64_t GetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +VKAPI_ATTR VkResult GetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); +VKAPI_ATTR void CmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +VKAPI_ATTR void CmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +VKAPI_ATTR void CmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +VKAPI_ATTR void CmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +VKAPI_ATTR void CmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +VKAPI_ATTR void CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +VKAPI_ATTR void CmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +VKAPI_ATTR void CmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +VKAPI_ATTR void CmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +VKAPI_ATTR void CmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +VKAPI_ATTR void CmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +VKAPI_ATTR void CmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); +VKAPI_ATTR void CmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +VKAPI_ATTR void CmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +VKAPI_ATTR void CmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); +VKAPI_ATTR VkResult CreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); +VKAPI_ATTR void DestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR VkResult SetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +VKAPI_ATTR void GetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); +VKAPI_ATTR void CmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +VKAPI_ATTR void CmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +VKAPI_ATTR void CmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +VKAPI_ATTR void CmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +VKAPI_ATTR void CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +VKAPI_ATTR void CmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); +VKAPI_ATTR void CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +VKAPI_ATTR void CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +VKAPI_ATTR void CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +VKAPI_ATTR void CmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +VKAPI_ATTR VkResult QueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); +VKAPI_ATTR void CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +VKAPI_ATTR void CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo); +VKAPI_ATTR void CmdEndRendering(VkCommandBuffer commandBuffer); // clang-format on } // namespace null_driver -- cgit v1.2.3-59-g8ed1b From 628c41ac1d788cac4310bd62e52323de98b392c9 Mon Sep 17 00:00:00 2001 From: Trevor David Black Date: Mon, 27 Sep 2021 05:07:22 +0000 Subject: Change Vulkan API to 1.3 The commit changes the platform code to support Vulkan 1.3. Bug: 191881132 Test: build Change-Id: I75ed8a0737ef20ff95e4a27ce39cc855d8a1deeb --- vulkan/libvulkan/api.cpp | 2 +- vulkan/libvulkan/driver.cpp | 8 ++++++-- vulkan/nulldrv/null_driver.cpp | 2 +- vulkan/vkjson/vkjson.cc | 4 ++++ 4 files changed, 12 insertions(+), 4 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/api.cpp b/vulkan/libvulkan/api.cpp index 9ecc5687cc..c335e2a952 100644 --- a/vulkan/libvulkan/api.cpp +++ b/vulkan/libvulkan/api.cpp @@ -1473,7 +1473,7 @@ VkResult EnumerateInstanceVersion(uint32_t* pApiVersion) { if (!EnsureInitialized()) return VK_ERROR_OUT_OF_HOST_MEMORY; - *pApiVersion = VK_API_VERSION_1_2; + *pApiVersion = VK_API_VERSION_1_3; return VK_SUCCESS; } diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 238429f957..92250621ed 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -365,7 +365,7 @@ CreateInfoWrapper::CreateInfoWrapper(const VkInstanceCreateInfo& create_info, const VkAllocationCallbacks& allocator) : is_instance_(true), allocator_(allocator), - loader_api_version_(VK_API_VERSION_1_2), + loader_api_version_(VK_API_VERSION_1_3), icd_api_version_(icd_api_version), physical_dev_(VK_NULL_HANDLE), instance_info_(create_info), @@ -377,7 +377,7 @@ CreateInfoWrapper::CreateInfoWrapper(VkPhysicalDevice physical_dev, const VkAllocationCallbacks& allocator) : is_instance_(false), allocator_(allocator), - loader_api_version_(VK_API_VERSION_1_2), + loader_api_version_(VK_API_VERSION_1_3), icd_api_version_(icd_api_version), physical_dev_(physical_dev), dev_info_(create_info), @@ -519,6 +519,10 @@ VkResult CreateInfoWrapper::SanitizeExtensions() { is_instance_ ? loader_api_version_ : std::min(icd_api_version_, loader_api_version_); switch (api_version) { + case VK_API_VERSION_1_3: + hook_extensions_.set(ProcHook::EXTENSION_CORE_1_3); + hal_extensions_.set(ProcHook::EXTENSION_CORE_1_3); + [[clang::fallthrough]]; case VK_API_VERSION_1_2: hook_extensions_.set(ProcHook::EXTENSION_CORE_1_2); hal_extensions_.set(ProcHook::EXTENSION_CORE_1_2); diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp index a9f37e56cf..eea0ec92e7 100644 --- a/vulkan/nulldrv/null_driver.cpp +++ b/vulkan/nulldrv/null_driver.cpp @@ -260,7 +260,7 @@ namespace null_driver { VKAPI_ATTR VkResult EnumerateInstanceVersion(uint32_t* pApiVersion) { - *pApiVersion = VK_API_VERSION_1_2; + *pApiVersion = VK_API_VERSION_1_3; return VK_SUCCESS; } diff --git a/vulkan/vkjson/vkjson.cc b/vulkan/vkjson/vkjson.cc index 90cf42c7f7..798fd4a5ab 100644 --- a/vulkan/vkjson/vkjson.cc +++ b/vulkan/vkjson/vkjson.cc @@ -973,6 +973,8 @@ inline bool Iterate(Visitor* visitor, VkJsonDevice* device) { bool ret = true; switch (device->properties.apiVersion ^ VK_API_VERSION_PATCH(device->properties.apiVersion)) { + case VK_API_VERSION_1_3: + FALLTHROUGH_INTENDED; case VK_API_VERSION_1_2: ret &= visitor->Visit("core12", &device->core12); FALLTHROUGH_INTENDED; @@ -1030,6 +1032,8 @@ template inline bool Iterate(Visitor* visitor, VkJsonInstance* instance) { bool ret = true; switch (instance->api_version ^ VK_API_VERSION_PATCH(instance->api_version)) { + case VK_API_VERSION_1_3: + FALLTHROUGH_INTENDED; case VK_API_VERSION_1_2: ret &= visitor->Visit("apiVersion", &instance->api_version); FALLTHROUGH_INTENDED; -- cgit v1.2.3-59-g8ed1b From bce3b4ed5fd07f676de0909b58b228e8e93835df Mon Sep 17 00:00:00 2001 From: Trevor David Black Date: Mon, 8 Nov 2021 23:57:54 +0000 Subject: Updated the llndk symbol map for Vulkan 1.3 Bug: 191881132 Test: build Change-Id: I1fc789abebdd1948b35fea32a4b81af304078aec --- vulkan/libvulkan/libvulkan.map.txt | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/libvulkan.map.txt b/vulkan/libvulkan/libvulkan.map.txt index df97d7fa78..f49e8f3e8d 100644 --- a/vulkan/libvulkan/libvulkan.map.txt +++ b/vulkan/libvulkan/libvulkan.map.txt @@ -11,20 +11,27 @@ LIBVULKAN { vkBindImageMemory; vkBindImageMemory2; # introduced=28 vkCmdBeginQuery; + vkCmdBeginRendering; # introduced=33 vkCmdBeginRenderPass; vkCmdBeginRenderPass2; # introduced=31 vkCmdBindDescriptorSets; vkCmdBindIndexBuffer; vkCmdBindPipeline; vkCmdBindVertexBuffers; + vkCmdBindVertexBuffers2; #introduced=33 vkCmdBlitImage; + vkCmdBlitImage2; #introduced=33 vkCmdClearAttachments; vkCmdClearColorImage; vkCmdClearDepthStencilImage; vkCmdCopyBuffer; + vkCmdCopyBuffer2; #introduced=33 vkCmdCopyBufferToImage; + vkCmdCopyBufferToImage2; #introduced=33 vkCmdCopyImage; + vkCmdCopyImage2; #introduced=33 vkCmdCopyImageToBuffer; + vkCmdCopyImageToBuffer2; #introduced=33 vkCmdCopyQueryPoolResults; vkCmdDispatch; vkCmdDispatchBase; # introduced=28 @@ -36,6 +43,7 @@ LIBVULKAN { vkCmdDrawIndirect; vkCmdDrawIndirectCount; # introduced=31 vkCmdEndQuery; + vkCmdEndRendering; #introduced=33 vkCmdEndRenderPass; vkCmdEndRenderPass2; # introduced=31 vkCmdExecuteCommands; @@ -43,24 +51,44 @@ LIBVULKAN { vkCmdNextSubpass; vkCmdNextSubpass2; # introduced=31 vkCmdPipelineBarrier; + vkCmdPipelineBarrier2; #introduced=33 vkCmdPushConstants; vkCmdResetEvent; + vkCmdResetEvent2; #introduced=33 vkCmdResetQueryPool; vkCmdResolveImage; + vkCmdResolveImage2; #introduced=33 vkCmdSetBlendConstants; + vkCmdSetCullMode; #introduced=33 vkCmdSetDepthBias; + vkCmdSetDepthBiasEnable; #introduced=33 vkCmdSetDepthBounds; + vkCmdSetDepthBoundsTestEnable; #introduced=33 + vkCmdSetDepthCompareOp; #introduced=33 + vkCmdSetDepthTestEnable; #introduced=33 + vkCmdSetDepthWriteEnable; #introduced=33 vkCmdSetDeviceMask; # introduced=28 vkCmdSetEvent; + vkCmdSetEvent2; #introduced=33 + vkCmdSetFrontFace; #introduced=33 vkCmdSetLineWidth; + vkCmdSetPrimitiveRestartEnable; #introduced=33 + vkCmdSetPrimitiveTopology; #introduced=33 + vkCmdSetRasterizerDiscardEnable; #introduced=33 vkCmdSetScissor; + vkCmdSetScissorWithCount; #introduced=33 vkCmdSetStencilCompareMask; + vkCmdSetStencilOp; #introduced=33 vkCmdSetStencilReference; + vkCmdSetStencilTestEnable; #introduced=33 vkCmdSetStencilWriteMask; vkCmdSetViewport; + vkCmdSetViewportWithCount; #introduced=33 vkCmdUpdateBuffer; vkCmdWaitEvents; + vkCmdWaitEvents2; #introduced=33 vkCmdWriteTimestamp; + vkCmdWriteTimestamp2; #introduced=33 vkCreateAndroidSurfaceKHR; vkCreateBuffer; vkCreateBufferView; @@ -79,6 +107,7 @@ LIBVULKAN { vkCreateInstance; vkCreatePipelineCache; vkCreatePipelineLayout; + vkCreatePrivateDataSlot; #introduced=33 vkCreateQueryPool; vkCreateRenderPass; vkCreateRenderPass2; # introduced=31 @@ -103,6 +132,7 @@ LIBVULKAN { vkDestroyPipeline; vkDestroyPipelineCache; vkDestroyPipelineLayout; + vkDestroyPrivateDataSlot; #introduced=33 vkDestroyQueryPool; vkDestroyRenderPass; vkDestroySampler; @@ -130,9 +160,12 @@ LIBVULKAN { vkGetBufferMemoryRequirements2; # introduced=28 vkGetBufferOpaqueCaptureAddress; # introduced=31 vkGetDescriptorSetLayoutSupport; # introduced=28 + vkGetDeviceBufferMemoryRequirements; #introduced=33 vkGetDeviceGroupPeerMemoryFeatures; # introduced=28 vkGetDeviceGroupPresentCapabilitiesKHR; # introduced=28 vkGetDeviceGroupSurfacePresentModesKHR; # introduced=28 + vkGetDeviceImageMemoryRequirements; #introduced=33 + vkGetDeviceImageSparseMemoryRequirements; #introduced=33 vkGetDeviceMemoryCommitment; vkGetDeviceMemoryOpaqueCaptureAddress; # introduced=31 vkGetDeviceProcAddr; @@ -169,7 +202,9 @@ LIBVULKAN { vkGetPhysicalDeviceSurfaceFormatsKHR; vkGetPhysicalDeviceSurfacePresentModesKHR; vkGetPhysicalDeviceSurfaceSupportKHR; + vkGetPhysicalDeviceToolProperties; #introduced=33 vkGetPipelineCacheData; + vkGetPrivateData; #introduced=33 vkGetQueryPoolResults; vkGetRenderAreaGranularity; vkGetSemaphoreCounterValue; # introduced=31 @@ -180,6 +215,7 @@ LIBVULKAN { vkQueueBindSparse; vkQueuePresentKHR; vkQueueSubmit; + vkQueueSubmit2; #introduced=33 vkQueueWaitIdle; vkResetCommandBuffer; vkResetCommandPool; @@ -188,6 +224,7 @@ LIBVULKAN { vkResetFences; vkResetQueryPool; # introduced=31 vkSetEvent; + vkSetPrivateData; # introduced=33 vkSignalSemaphore; # introduced=31 vkTrimCommandPool; # introduced=28 vkUnmapMemory; -- cgit v1.2.3-59-g8ed1b From 53604ad15a17893593d525bd3b6b6a3ce0cf7de4 Mon Sep 17 00:00:00 2001 From: Trevor David Black Date: Thu, 20 Jan 2022 02:58:30 +0000 Subject: Vulkan: update the loader for vulkan-headers v1.3.203 Bug: 191881132 Test: build Change-Id: I1c9ca806c810cda1dca8d2f7a39d888c4ebdd976 --- vulkan/libvulkan/api_gen.cpp | 6 +++--- vulkan/nulldrv/null_driver_gen.h | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/api_gen.cpp b/vulkan/libvulkan/api_gen.cpp index eb9fc477e3..df70bf4419 100644 --- a/vulkan/libvulkan/api_gen.cpp +++ b/vulkan/libvulkan/api_gen.cpp @@ -620,7 +620,7 @@ VKAPI_ATTR void CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCoun VKAPI_ATTR void CmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); VKAPI_ATTR VkResult QueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); VKAPI_ATTR void CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); -VKAPI_ATTR void CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo); +VKAPI_ATTR void CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); VKAPI_ATTR void CmdEndRendering(VkCommandBuffer commandBuffer); VKAPI_ATTR VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { @@ -1838,7 +1838,7 @@ VKAPI_ATTR void CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStag GetData(commandBuffer).dispatch.CmdWriteTimestamp2(commandBuffer, stage, queryPool, query); } -VKAPI_ATTR void CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo) { +VKAPI_ATTR void CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) { GetData(commandBuffer).dispatch.CmdBeginRendering(commandBuffer, pRenderingInfo); } @@ -3007,7 +3007,7 @@ VKAPI_ATTR void vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineSt } __attribute__((visibility("default"))) -VKAPI_ATTR void vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo) { +VKAPI_ATTR void vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) { vulkan::api::CmdBeginRendering(commandBuffer, pRenderingInfo); } diff --git a/vulkan/nulldrv/null_driver_gen.h b/vulkan/nulldrv/null_driver_gen.h index 315f1dcb08..3e003e3189 100644 --- a/vulkan/nulldrv/null_driver_gen.h +++ b/vulkan/nulldrv/null_driver_gen.h @@ -255,7 +255,7 @@ VKAPI_ATTR void CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCoun VKAPI_ATTR void CmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); VKAPI_ATTR VkResult QueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); VKAPI_ATTR void CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); -VKAPI_ATTR void CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo); +VKAPI_ATTR void CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); VKAPI_ATTR void CmdEndRendering(VkCommandBuffer commandBuffer); // clang-format on -- cgit v1.2.3-59-g8ed1b From 6ba85d939187ca6ad201ab7b098391733317c259 Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Fri, 18 Feb 2022 16:44:58 -0700 Subject: swapchain: Implement VK_GOOGLE_surfaceless_query This extension allows ANGLE to call Vulkan WSI queries before it has a VkSurfaceKHR. Bug: 203826952 Test: Test with ANGLE EGLConfig-generation code Change-Id: I7e53a8a28157023658baac0778033159bdd2285e --- vulkan/libvulkan/driver.cpp | 4 + vulkan/libvulkan/driver_gen.cpp | 1 + vulkan/libvulkan/driver_gen.h | 1 + vulkan/libvulkan/swapchain.cpp | 189 +++++++++++++++++++++++++------------ vulkan/scripts/driver_generator.py | 1 + 5 files changed, 137 insertions(+), 59 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 92250621ed..6a075613df 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -634,6 +634,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_surface: case ProcHook::EXT_swapchain_colorspace: case ProcHook::KHR_get_surface_capabilities2: + case ProcHook::GOOGLE_surfaceless_query: hook_extensions_.set(ext_bit); // return now as these extensions do not require HAL support return; @@ -712,6 +713,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_surface: case ProcHook::EXT_debug_report: case ProcHook::EXT_swapchain_colorspace: + case ProcHook::GOOGLE_surfaceless_query: case ProcHook::ANDROID_native_buffer: case ProcHook::EXTENSION_CORE_1_0: case ProcHook::EXTENSION_CORE_1_1: @@ -932,6 +934,8 @@ VkResult EnumerateInstanceExtensionProperties( loader_extensions.push_back({ VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION}); + loader_extensions.push_back({VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME, + VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION}); static const VkExtensionProperties loader_debug_report_extension = { VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION, diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index 5f37a50a03..f84fc8814c 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -565,6 +565,7 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_EXT_hdr_metadata") == 0) return ProcHook::EXT_hdr_metadata; if (strcmp(name, "VK_EXT_swapchain_colorspace") == 0) return ProcHook::EXT_swapchain_colorspace; if (strcmp(name, "VK_GOOGLE_display_timing") == 0) return ProcHook::GOOGLE_display_timing; + if (strcmp(name, "VK_GOOGLE_surfaceless_query") == 0) return ProcHook::GOOGLE_surfaceless_query; if (strcmp(name, "VK_KHR_android_surface") == 0) return ProcHook::KHR_android_surface; if (strcmp(name, "VK_KHR_get_surface_capabilities2") == 0) return ProcHook::KHR_get_surface_capabilities2; if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 819f6b211c..6a6c5b3d3c 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -41,6 +41,7 @@ struct ProcHook { EXT_hdr_metadata, EXT_swapchain_colorspace, GOOGLE_display_timing, + GOOGLE_surfaceless_query, KHR_android_surface, KHR_get_surface_capabilities2, KHR_incremental_present, diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 4a6b4f12a1..20a0aad712 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -619,42 +619,65 @@ VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/, VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice /*pdev*/, + VkPhysicalDevice pdev, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* capabilities) { ATRACE_CALL(); int err; - ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); - int width, height; - err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } - err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } - int transform_hint; - err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } - int max_buffer_count; - err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &max_buffer_count); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; + if (surface == VK_NULL_HANDLE) { + const InstanceData& instance_data = GetData(pdev); + ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; + bool surfaceless_enabled = + instance_data.hook_extensions.test(surfaceless); + if (!surfaceless_enabled) { + // It is an error to pass a surface==VK_NULL_HANDLE unless the + // VK_GOOGLE_surfaceless_query extension is enabled + return VK_ERROR_SURFACE_LOST_KHR; + } + // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this + // extension for this function is for + // VkSurfaceProtectedCapabilitiesKHR::supportsProtected. The following + // four values cannot be known without a surface. Default values will + // be supplied anyway, but cannot be relied upon. + width = 1000; + height = 1000; + transform_hint = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; + max_buffer_count = 10; + } else { + ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); + + err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } + err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } + + err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, + &transform_hint); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } + + err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, + &max_buffer_count); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } } capabilities->minImageCount = std::min(max_buffer_count, 3); capabilities->maxImageCount = static_cast(max_buffer_count); @@ -695,23 +718,43 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, const InstanceData& instance_data = GetData(pdev); bool wide_color_support = false; - Surface& surface = *SurfaceFromHandle(surface_handle); - int err = native_window_get_wide_color_support(surface.window.get(), - &wide_color_support); - if (err) { - return VK_ERROR_SURFACE_LOST_KHR; - } + uint64_t consumer_usage = 0; bool swapchain_ext = instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace); - ALOGV("wide_color_support is: %d", wide_color_support); + if (surface_handle == VK_NULL_HANDLE) { + ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; + bool surfaceless_enabled = + instance_data.hook_extensions.test(surfaceless); + if (!surfaceless_enabled) { + return VK_ERROR_SURFACE_LOST_KHR; + } + // Support for VK_GOOGLE_surfaceless_query. The EGL loader + // unconditionally supports wide color formats, even if they will cause + // a SurfaceFlinger fallback. Based on that, wide_color_support will be + // set to true in this case. + wide_color_support = true; + + // TODO(b/203826952): research proper value; temporarily use the + // values seen on Pixel + consumer_usage = AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY; + } else { + Surface& surface = *SurfaceFromHandle(surface_handle); + int err = native_window_get_wide_color_support(surface.window.get(), + &wide_color_support); + if (err) { + return VK_ERROR_SURFACE_LOST_KHR; + } + ALOGV("wide_color_support is: %d", wide_color_support); + + consumer_usage = surface.consumer_usage; + } wide_color_support = wide_color_support && swapchain_ext; AHardwareBuffer_Desc desc = {}; desc.width = 1; desc.height = 1; desc.layers = 1; - desc.usage = surface.consumer_usage | - AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | + desc.usage = consumer_usage | AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER; // We must support R8G8B8A8 @@ -731,6 +774,10 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT}); } + // NOTE: Any new formats that are added must be coordinated across different + // Android users. This includes the ANGLE team (a layered implementation of + // OpenGL-ES). + desc.format = AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM; if (AHardwareBuffer_isSupported(&desc)) { all_formats.emplace_back(VkSurfaceFormatKHR{ @@ -770,6 +817,10 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, VK_COLOR_SPACE_PASS_THROUGH_EXT}); } + // NOTE: Any new formats that are added must be coordinated across different + // Android users. This includes the ANGLE team (a layered implementation of + // OpenGL-ES). + VkResult result = VK_SUCCESS; if (formats) { uint32_t transfer_count = all_formats.size(); @@ -865,31 +916,51 @@ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev, int err; int query_value; - ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); + std::vector present_modes; + if (surface == VK_NULL_HANDLE) { + const InstanceData& instance_data = GetData(pdev); + ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; + bool surfaceless_enabled = + instance_data.hook_extensions.test(surfaceless); + if (!surfaceless_enabled) { + return VK_ERROR_SURFACE_LOST_KHR; + } + // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this + // extension for this function is for + // VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR and + // VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR. We technically cannot + // know if VK_PRESENT_MODE_SHARED_MAILBOX_KHR is supported without a + // surface, and that cannot be relied upon. + present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); + present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); + } else { + ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); - err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, - &query_value); - if (err != android::OK || query_value < 0) { - ALOGE( - "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) " - "value=%d", - strerror(-err), err, query_value); - return VK_ERROR_SURFACE_LOST_KHR; - } - uint32_t min_undequeued_buffers = static_cast(query_value); + err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, + &query_value); + if (err != android::OK || query_value < 0) { + ALOGE( + "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) " + "value=%d", + strerror(-err), err, query_value); + return VK_ERROR_SURFACE_LOST_KHR; + } + uint32_t min_undequeued_buffers = static_cast(query_value); + + err = + window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value); + if (err != android::OK || query_value < 0) { + ALOGE( + "NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d", + strerror(-err), err, query_value); + return VK_ERROR_SURFACE_LOST_KHR; + } + uint32_t max_buffer_count = static_cast(query_value); - err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value); - if (err != android::OK || query_value < 0) { - ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d", - strerror(-err), err, query_value); - return VK_ERROR_SURFACE_LOST_KHR; + if (min_undequeued_buffers + 1 < max_buffer_count) + present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); + present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); } - uint32_t max_buffer_count = static_cast(query_value); - - std::vector present_modes; - if (min_undequeued_buffers + 1 < max_buffer_count) - present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); - present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); VkPhysicalDevicePresentationPropertiesANDROID present_properties; QueryPresentationProperties(pdev, &present_properties); diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index 6a73023193..cd25dd817c 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -27,6 +27,7 @@ _INTERCEPTED_EXTENSIONS = [ 'VK_EXT_hdr_metadata', 'VK_EXT_swapchain_colorspace', 'VK_GOOGLE_display_timing', + 'VK_GOOGLE_surfaceless_query', 'VK_KHR_android_surface', 'VK_KHR_get_surface_capabilities2', 'VK_KHR_incremental_present', -- cgit v1.2.3-59-g8ed1b From c7c4aa3297f87f06ac63c2f1f259aecb59fc41f7 Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Mon, 28 Feb 2022 16:47:43 -0700 Subject: swapchain: Implement VK_KHR_surface_protected_capabilities Bug: 221490496 Test: Test with ANGLE EGLConfig-generation code Change-Id: Id01e677175a2cf98f4d893e21f3c654375772153 --- vulkan/libvulkan/driver.cpp | 5 +++++ vulkan/libvulkan/driver_gen.cpp | 1 + vulkan/libvulkan/driver_gen.h | 1 + vulkan/libvulkan/swapchain.cpp | 6 ++++++ vulkan/scripts/driver_generator.py | 1 + 5 files changed, 14 insertions(+) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 6a075613df..60c0cb5c3e 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -632,6 +632,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { switch (ext_bit) { case ProcHook::KHR_android_surface: case ProcHook::KHR_surface: + case ProcHook::KHR_surface_protected_capabilities: case ProcHook::EXT_swapchain_colorspace: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::GOOGLE_surfaceless_query: @@ -711,6 +712,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_external_fence_capabilities: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::KHR_surface: + case ProcHook::KHR_surface_protected_capabilities: case ProcHook::EXT_debug_report: case ProcHook::EXT_swapchain_colorspace: case ProcHook::GOOGLE_surfaceless_query: @@ -925,6 +927,9 @@ VkResult EnumerateInstanceExtensionProperties( loader_extensions.push_back({ VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_SPEC_VERSION}); + loader_extensions.push_back( + {VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME, + VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION}); loader_extensions.push_back({ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, VK_KHR_ANDROID_SURFACE_SPEC_VERSION}); diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index f84fc8814c..b436db1de7 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -571,6 +571,7 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present; if (strcmp(name, "VK_KHR_shared_presentable_image") == 0) return ProcHook::KHR_shared_presentable_image; if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface; + if (strcmp(name, "VK_KHR_surface_protected_capabilities") == 0) return ProcHook::KHR_surface_protected_capabilities; if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain; if (strcmp(name, "VK_ANDROID_external_memory_android_hardware_buffer") == 0) return ProcHook::ANDROID_external_memory_android_hardware_buffer; if (strcmp(name, "VK_KHR_bind_memory2") == 0) return ProcHook::KHR_bind_memory2; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 6a6c5b3d3c..079f9cca39 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -47,6 +47,7 @@ struct ProcHook { KHR_incremental_present, KHR_shared_presentable_image, KHR_surface, + KHR_surface_protected_capabilities, KHR_swapchain, ANDROID_external_memory_android_hardware_buffer, KHR_bind_memory2, diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 20a0aad712..0be4403731 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -865,6 +865,12 @@ VkResult GetPhysicalDeviceSurfaceCapabilities2KHR( .supportedUsageFlags; } break; + case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: { + VkSurfaceProtectedCapabilitiesKHR* protected_caps = + reinterpret_cast(caps); + protected_caps->supportsProtected = VK_TRUE; + } break; + default: // Ignore all other extension structs break; diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index cd25dd817c..af56764a21 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -33,6 +33,7 @@ _INTERCEPTED_EXTENSIONS = [ 'VK_KHR_incremental_present', 'VK_KHR_shared_presentable_image', 'VK_KHR_surface', + 'VK_KHR_surface_protected_capabilities', 'VK_KHR_swapchain', ] -- cgit v1.2.3-59-g8ed1b From 4d1ad47aca661452dbe99d277167dc4cc21dd61c Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Mon, 14 Mar 2022 17:27:47 -0600 Subject: Revert "swapchain: Implement VK_KHR_surface_protected_capabilities" In order to help the automerger get this everywhere, am reverting it here, and then will land it in AOSP master (which will automerge here again). This reverts commit a9e06fd447e8ebf22b2dd025d6ee1aa3f93b2bc1. Test: Manual Inspection Bug: 221490496 Change-Id: I21dcc2ab87d34b2366d32d06b910c88400c5f70d --- vulkan/libvulkan/driver.cpp | 8 +------- vulkan/libvulkan/driver_gen.cpp | 1 - vulkan/libvulkan/driver_gen.h | 1 - vulkan/libvulkan/swapchain.cpp | 6 ------ vulkan/scripts/driver_generator.py | 1 - 5 files changed, 1 insertion(+), 16 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 60c0cb5c3e..8cb1b21160 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -632,7 +632,6 @@ void CreateInfoWrapper::FilterExtension(const char* name) { switch (ext_bit) { case ProcHook::KHR_android_surface: case ProcHook::KHR_surface: - case ProcHook::KHR_surface_protected_capabilities: case ProcHook::EXT_swapchain_colorspace: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::GOOGLE_surfaceless_query: @@ -712,7 +711,6 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_external_fence_capabilities: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::KHR_surface: - case ProcHook::KHR_surface_protected_capabilities: case ProcHook::EXT_debug_report: case ProcHook::EXT_swapchain_colorspace: case ProcHook::GOOGLE_surfaceless_query: @@ -924,12 +922,8 @@ VkResult EnumerateInstanceExtensionProperties( uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { std::vector loader_extensions; - loader_extensions.push_back({ - VK_KHR_SURFACE_EXTENSION_NAME, - VK_KHR_SURFACE_SPEC_VERSION}); loader_extensions.push_back( - {VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME, - VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION}); + {VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_SPEC_VERSION}); loader_extensions.push_back({ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, VK_KHR_ANDROID_SURFACE_SPEC_VERSION}); diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index b436db1de7..f84fc8814c 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -571,7 +571,6 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present; if (strcmp(name, "VK_KHR_shared_presentable_image") == 0) return ProcHook::KHR_shared_presentable_image; if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface; - if (strcmp(name, "VK_KHR_surface_protected_capabilities") == 0) return ProcHook::KHR_surface_protected_capabilities; if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain; if (strcmp(name, "VK_ANDROID_external_memory_android_hardware_buffer") == 0) return ProcHook::ANDROID_external_memory_android_hardware_buffer; if (strcmp(name, "VK_KHR_bind_memory2") == 0) return ProcHook::KHR_bind_memory2; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 079f9cca39..6a6c5b3d3c 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -47,7 +47,6 @@ struct ProcHook { KHR_incremental_present, KHR_shared_presentable_image, KHR_surface, - KHR_surface_protected_capabilities, KHR_swapchain, ANDROID_external_memory_android_hardware_buffer, KHR_bind_memory2, diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 0be4403731..20a0aad712 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -865,12 +865,6 @@ VkResult GetPhysicalDeviceSurfaceCapabilities2KHR( .supportedUsageFlags; } break; - case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: { - VkSurfaceProtectedCapabilitiesKHR* protected_caps = - reinterpret_cast(caps); - protected_caps->supportsProtected = VK_TRUE; - } break; - default: // Ignore all other extension structs break; diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index af56764a21..cd25dd817c 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -33,7 +33,6 @@ _INTERCEPTED_EXTENSIONS = [ 'VK_KHR_incremental_present', 'VK_KHR_shared_presentable_image', 'VK_KHR_surface', - 'VK_KHR_surface_protected_capabilities', 'VK_KHR_swapchain', ] -- cgit v1.2.3-59-g8ed1b From e91bd149d3e1a3fa8bcaf06ecafac362c723a815 Mon Sep 17 00:00:00 2001 From: Trevor Black Date: Wed, 9 Mar 2022 22:06:55 +0000 Subject: Revert "Make BT709 support conditional on swapchain ext enable" This reverts commit ea5745afb64f0f71ccbc36d617a73d0ce0db2e9f. Reason for revert: Need to land in aosp Change-Id: Iaec5f22329ac99593d080e7c3e01022e85420ada Merged-In: Id056873193a711de140acb2f1dfd4a734ecaec4b --- vulkan/libvulkan/swapchain.cpp | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 20a0aad712..5fdee217ab 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -719,8 +719,6 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, bool wide_color_support = false; uint64_t consumer_usage = 0; - bool swapchain_ext = - instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace); if (surface_handle == VK_NULL_HANDLE) { ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; bool surfaceless_enabled = @@ -748,7 +746,9 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, consumer_usage = surface.consumer_usage; } - wide_color_support = wide_color_support && swapchain_ext; + wide_color_support = + wide_color_support && + instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace); AHardwareBuffer_Desc desc = {}; desc.width = 1; @@ -760,12 +760,8 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, // We must support R8G8B8A8 std::vector all_formats = { {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, - {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}}; - - if (swapchain_ext) { - all_formats.emplace_back(VkSurfaceFormatKHR{ - VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_BT709_LINEAR_EXT}); - } + {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, + {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_BT709_LINEAR_EXT}}; if (wide_color_support) { all_formats.emplace_back(VkSurfaceFormatKHR{ -- cgit v1.2.3-59-g8ed1b From 320ef3aea1c28c20ea83395b38acc904af97fbee Mon Sep 17 00:00:00 2001 From: Trevor David Black Date: Wed, 9 Mar 2022 22:50:09 +0000 Subject: Revert "Advertise support for BT709 in the WSI" This reverts commit 737b5b495f7b65787bd676187dd9cca178386498. Reason for revert: needs to land in aosp Change-Id: I65d740d29096ff6724ed0eff5d9fb83112be6de5 Merged-In: I9ad64d7d8b21cd68c071dc90f7d032671096b0da --- vulkan/libvulkan/swapchain.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 5fdee217ab..f42c4f026b 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -760,8 +760,7 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, // We must support R8G8B8A8 std::vector all_formats = { {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, - {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, - {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_BT709_LINEAR_EXT}}; + {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}}; if (wide_color_support) { all_formats.emplace_back(VkSurfaceFormatKHR{ -- cgit v1.2.3-59-g8ed1b From e7f036c24c2814bd18cb2ff892428c21bf45ec18 Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Tue, 15 Mar 2022 16:49:21 -0600 Subject: Revert "swapchain: Implement VK_GOOGLE_surfaceless_query" In order to help the automerger get this everywhere, am reverting it here, and then will land it in AOSP master (which will automerge here again). This reverts commit 8e0f12163f90a1a511625ba1f290de95777beb86. Test: Manual inspection Bug: 203826952 Change-Id: I227993c87b1601b8dc0d1cf4bb008d5af9abc930 --- vulkan/libvulkan/driver.cpp | 10 +- vulkan/libvulkan/driver_gen.cpp | 1 - vulkan/libvulkan/driver_gen.h | 1 - vulkan/libvulkan/swapchain.cpp | 184 ++++++++++++------------------------- vulkan/scripts/driver_generator.py | 1 - 5 files changed, 62 insertions(+), 135 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 8cb1b21160..6e54d6c0de 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -634,7 +634,6 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_surface: case ProcHook::EXT_swapchain_colorspace: case ProcHook::KHR_get_surface_capabilities2: - case ProcHook::GOOGLE_surfaceless_query: hook_extensions_.set(ext_bit); // return now as these extensions do not require HAL support return; @@ -713,7 +712,6 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_surface: case ProcHook::EXT_debug_report: case ProcHook::EXT_swapchain_colorspace: - case ProcHook::GOOGLE_surfaceless_query: case ProcHook::ANDROID_native_buffer: case ProcHook::EXTENSION_CORE_1_0: case ProcHook::EXTENSION_CORE_1_1: @@ -930,11 +928,9 @@ VkResult EnumerateInstanceExtensionProperties( loader_extensions.push_back({ VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION}); - loader_extensions.push_back({ - VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, - VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION}); - loader_extensions.push_back({VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME, - VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION}); + loader_extensions.push_back( + {VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, + VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION}); static const VkExtensionProperties loader_debug_report_extension = { VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION, diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index f84fc8814c..5f37a50a03 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -565,7 +565,6 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_EXT_hdr_metadata") == 0) return ProcHook::EXT_hdr_metadata; if (strcmp(name, "VK_EXT_swapchain_colorspace") == 0) return ProcHook::EXT_swapchain_colorspace; if (strcmp(name, "VK_GOOGLE_display_timing") == 0) return ProcHook::GOOGLE_display_timing; - if (strcmp(name, "VK_GOOGLE_surfaceless_query") == 0) return ProcHook::GOOGLE_surfaceless_query; if (strcmp(name, "VK_KHR_android_surface") == 0) return ProcHook::KHR_android_surface; if (strcmp(name, "VK_KHR_get_surface_capabilities2") == 0) return ProcHook::KHR_get_surface_capabilities2; if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 6a6c5b3d3c..819f6b211c 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -41,7 +41,6 @@ struct ProcHook { EXT_hdr_metadata, EXT_swapchain_colorspace, GOOGLE_display_timing, - GOOGLE_surfaceless_query, KHR_android_surface, KHR_get_surface_capabilities2, KHR_incremental_present, diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 5fdee217ab..9decd84a2e 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -619,65 +619,43 @@ VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/, VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice pdev, + VkPhysicalDevice /*pdev*/, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* capabilities) { ATRACE_CALL(); int err; - int width, height; - int transform_hint; - int max_buffer_count; - if (surface == VK_NULL_HANDLE) { - const InstanceData& instance_data = GetData(pdev); - ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; - bool surfaceless_enabled = - instance_data.hook_extensions.test(surfaceless); - if (!surfaceless_enabled) { - // It is an error to pass a surface==VK_NULL_HANDLE unless the - // VK_GOOGLE_surfaceless_query extension is enabled - return VK_ERROR_SURFACE_LOST_KHR; - } - // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this - // extension for this function is for - // VkSurfaceProtectedCapabilitiesKHR::supportsProtected. The following - // four values cannot be known without a surface. Default values will - // be supplied anyway, but cannot be relied upon. - width = 1000; - height = 1000; - transform_hint = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; - max_buffer_count = 10; - } else { - ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); + ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); - err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } - err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } + int width, height; + err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } + err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } - err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, - &transform_hint); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } + int transform_hint; + err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } - err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, - &max_buffer_count); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } + int max_buffer_count; + err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, + &max_buffer_count); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; } capabilities->minImageCount = std::min(max_buffer_count, 3); capabilities->maxImageCount = static_cast(max_buffer_count); @@ -718,34 +696,13 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, const InstanceData& instance_data = GetData(pdev); bool wide_color_support = false; - uint64_t consumer_usage = 0; - if (surface_handle == VK_NULL_HANDLE) { - ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; - bool surfaceless_enabled = - instance_data.hook_extensions.test(surfaceless); - if (!surfaceless_enabled) { - return VK_ERROR_SURFACE_LOST_KHR; - } - // Support for VK_GOOGLE_surfaceless_query. The EGL loader - // unconditionally supports wide color formats, even if they will cause - // a SurfaceFlinger fallback. Based on that, wide_color_support will be - // set to true in this case. - wide_color_support = true; - - // TODO(b/203826952): research proper value; temporarily use the - // values seen on Pixel - consumer_usage = AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY; - } else { - Surface& surface = *SurfaceFromHandle(surface_handle); - int err = native_window_get_wide_color_support(surface.window.get(), - &wide_color_support); - if (err) { - return VK_ERROR_SURFACE_LOST_KHR; - } - ALOGV("wide_color_support is: %d", wide_color_support); - - consumer_usage = surface.consumer_usage; + Surface& surface = *SurfaceFromHandle(surface_handle); + int err = native_window_get_wide_color_support(surface.window.get(), + &wide_color_support); + if (err) { + return VK_ERROR_SURFACE_LOST_KHR; } + ALOGV("wide_color_support is: %d", wide_color_support); wide_color_support = wide_color_support && instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace); @@ -754,7 +711,8 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, desc.width = 1; desc.height = 1; desc.layers = 1; - desc.usage = consumer_usage | AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | + desc.usage = surface.consumer_usage | + AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER; // We must support R8G8B8A8 @@ -770,10 +728,6 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT}); } - // NOTE: Any new formats that are added must be coordinated across different - // Android users. This includes the ANGLE team (a layered implementation of - // OpenGL-ES). - desc.format = AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM; if (AHardwareBuffer_isSupported(&desc)) { all_formats.emplace_back(VkSurfaceFormatKHR{ @@ -912,51 +866,31 @@ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev, int err; int query_value; - std::vector present_modes; - if (surface == VK_NULL_HANDLE) { - const InstanceData& instance_data = GetData(pdev); - ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; - bool surfaceless_enabled = - instance_data.hook_extensions.test(surfaceless); - if (!surfaceless_enabled) { - return VK_ERROR_SURFACE_LOST_KHR; - } - // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this - // extension for this function is for - // VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR and - // VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR. We technically cannot - // know if VK_PRESENT_MODE_SHARED_MAILBOX_KHR is supported without a - // surface, and that cannot be relied upon. - present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); - present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); - } else { - ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); + ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); - err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, - &query_value); - if (err != android::OK || query_value < 0) { - ALOGE( - "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) " - "value=%d", - strerror(-err), err, query_value); - return VK_ERROR_SURFACE_LOST_KHR; - } - uint32_t min_undequeued_buffers = static_cast(query_value); - - err = - window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value); - if (err != android::OK || query_value < 0) { - ALOGE( - "NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d", - strerror(-err), err, query_value); - return VK_ERROR_SURFACE_LOST_KHR; - } - uint32_t max_buffer_count = static_cast(query_value); + err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, + &query_value); + if (err != android::OK || query_value < 0) { + ALOGE( + "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) " + "value=%d", + strerror(-err), err, query_value); + return VK_ERROR_SURFACE_LOST_KHR; + } + uint32_t min_undequeued_buffers = static_cast(query_value); - if (min_undequeued_buffers + 1 < max_buffer_count) - present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); - present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); + err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value); + if (err != android::OK || query_value < 0) { + ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d", + strerror(-err), err, query_value); + return VK_ERROR_SURFACE_LOST_KHR; } + uint32_t max_buffer_count = static_cast(query_value); + + std::vector present_modes; + if (min_undequeued_buffers + 1 < max_buffer_count) + present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); + present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); VkPhysicalDevicePresentationPropertiesANDROID present_properties; QueryPresentationProperties(pdev, &present_properties); diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index cd25dd817c..6a73023193 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -27,7 +27,6 @@ _INTERCEPTED_EXTENSIONS = [ 'VK_EXT_hdr_metadata', 'VK_EXT_swapchain_colorspace', 'VK_GOOGLE_display_timing', - 'VK_GOOGLE_surfaceless_query', 'VK_KHR_android_surface', 'VK_KHR_get_surface_capabilities2', 'VK_KHR_incremental_present', -- cgit v1.2.3-59-g8ed1b From 1ce053f1c755040cb6b80a0b09534d9e311ecbfe Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Wed, 16 Mar 2022 09:49:53 -0600 Subject: swapchain: Implement VK_GOOGLE_surfaceless_query This extension allows ANGLE to call Vulkan WSI queries before it has a VkSurfaceKHR. This version tries to address some subtle differences between upstream and downstream branches. Bug: 203826952 Test: Test with ANGLE EGLConfig-generation code Change-Id: I7eb013efbaa5dd19ebed045583616238cea57023 --- vulkan/libvulkan/driver.cpp | 4 + vulkan/libvulkan/driver_gen.cpp | 1 + vulkan/libvulkan/driver_gen.h | 1 + vulkan/libvulkan/swapchain.cpp | 184 +++++++++++++++++++++++++------------ vulkan/scripts/driver_generator.py | 1 + 5 files changed, 132 insertions(+), 59 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 6e54d6c0de..aee90cd661 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -634,6 +634,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_surface: case ProcHook::EXT_swapchain_colorspace: case ProcHook::KHR_get_surface_capabilities2: + case ProcHook::GOOGLE_surfaceless_query: hook_extensions_.set(ext_bit); // return now as these extensions do not require HAL support return; @@ -712,6 +713,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_surface: case ProcHook::EXT_debug_report: case ProcHook::EXT_swapchain_colorspace: + case ProcHook::GOOGLE_surfaceless_query: case ProcHook::ANDROID_native_buffer: case ProcHook::EXTENSION_CORE_1_0: case ProcHook::EXTENSION_CORE_1_1: @@ -931,6 +933,8 @@ VkResult EnumerateInstanceExtensionProperties( loader_extensions.push_back( {VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION}); + loader_extensions.push_back({VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME, + VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION}); static const VkExtensionProperties loader_debug_report_extension = { VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION, diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index 5f37a50a03..f84fc8814c 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -565,6 +565,7 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_EXT_hdr_metadata") == 0) return ProcHook::EXT_hdr_metadata; if (strcmp(name, "VK_EXT_swapchain_colorspace") == 0) return ProcHook::EXT_swapchain_colorspace; if (strcmp(name, "VK_GOOGLE_display_timing") == 0) return ProcHook::GOOGLE_display_timing; + if (strcmp(name, "VK_GOOGLE_surfaceless_query") == 0) return ProcHook::GOOGLE_surfaceless_query; if (strcmp(name, "VK_KHR_android_surface") == 0) return ProcHook::KHR_android_surface; if (strcmp(name, "VK_KHR_get_surface_capabilities2") == 0) return ProcHook::KHR_get_surface_capabilities2; if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 819f6b211c..6a6c5b3d3c 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -41,6 +41,7 @@ struct ProcHook { EXT_hdr_metadata, EXT_swapchain_colorspace, GOOGLE_display_timing, + GOOGLE_surfaceless_query, KHR_android_surface, KHR_get_surface_capabilities2, KHR_incremental_present, diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 6dce394839..f42c4f026b 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -619,43 +619,65 @@ VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/, VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice /*pdev*/, + VkPhysicalDevice pdev, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* capabilities) { ATRACE_CALL(); int err; - ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); - int width, height; - err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } - err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } - int transform_hint; - err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } - int max_buffer_count; - err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, - &max_buffer_count); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; + if (surface == VK_NULL_HANDLE) { + const InstanceData& instance_data = GetData(pdev); + ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; + bool surfaceless_enabled = + instance_data.hook_extensions.test(surfaceless); + if (!surfaceless_enabled) { + // It is an error to pass a surface==VK_NULL_HANDLE unless the + // VK_GOOGLE_surfaceless_query extension is enabled + return VK_ERROR_SURFACE_LOST_KHR; + } + // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this + // extension for this function is for + // VkSurfaceProtectedCapabilitiesKHR::supportsProtected. The following + // four values cannot be known without a surface. Default values will + // be supplied anyway, but cannot be relied upon. + width = 1000; + height = 1000; + transform_hint = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; + max_buffer_count = 10; + } else { + ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); + + err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } + err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } + + err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, + &transform_hint); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } + + err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, + &max_buffer_count); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } } capabilities->minImageCount = std::min(max_buffer_count, 3); capabilities->maxImageCount = static_cast(max_buffer_count); @@ -696,13 +718,34 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, const InstanceData& instance_data = GetData(pdev); bool wide_color_support = false; - Surface& surface = *SurfaceFromHandle(surface_handle); - int err = native_window_get_wide_color_support(surface.window.get(), - &wide_color_support); - if (err) { - return VK_ERROR_SURFACE_LOST_KHR; + uint64_t consumer_usage = 0; + if (surface_handle == VK_NULL_HANDLE) { + ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; + bool surfaceless_enabled = + instance_data.hook_extensions.test(surfaceless); + if (!surfaceless_enabled) { + return VK_ERROR_SURFACE_LOST_KHR; + } + // Support for VK_GOOGLE_surfaceless_query. The EGL loader + // unconditionally supports wide color formats, even if they will cause + // a SurfaceFlinger fallback. Based on that, wide_color_support will be + // set to true in this case. + wide_color_support = true; + + // TODO(b/203826952): research proper value; temporarily use the + // values seen on Pixel + consumer_usage = AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY; + } else { + Surface& surface = *SurfaceFromHandle(surface_handle); + int err = native_window_get_wide_color_support(surface.window.get(), + &wide_color_support); + if (err) { + return VK_ERROR_SURFACE_LOST_KHR; + } + ALOGV("wide_color_support is: %d", wide_color_support); + + consumer_usage = surface.consumer_usage; } - ALOGV("wide_color_support is: %d", wide_color_support); wide_color_support = wide_color_support && instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace); @@ -711,8 +754,7 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, desc.width = 1; desc.height = 1; desc.layers = 1; - desc.usage = surface.consumer_usage | - AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | + desc.usage = consumer_usage | AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER; // We must support R8G8B8A8 @@ -727,6 +769,10 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT}); } + // NOTE: Any new formats that are added must be coordinated across different + // Android users. This includes the ANGLE team (a layered implementation of + // OpenGL-ES). + desc.format = AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM; if (AHardwareBuffer_isSupported(&desc)) { all_formats.emplace_back(VkSurfaceFormatKHR{ @@ -865,31 +911,51 @@ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev, int err; int query_value; - ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); + std::vector present_modes; + if (surface == VK_NULL_HANDLE) { + const InstanceData& instance_data = GetData(pdev); + ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; + bool surfaceless_enabled = + instance_data.hook_extensions.test(surfaceless); + if (!surfaceless_enabled) { + return VK_ERROR_SURFACE_LOST_KHR; + } + // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this + // extension for this function is for + // VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR and + // VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR. We technically cannot + // know if VK_PRESENT_MODE_SHARED_MAILBOX_KHR is supported without a + // surface, and that cannot be relied upon. + present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); + present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); + } else { + ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); - err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, - &query_value); - if (err != android::OK || query_value < 0) { - ALOGE( - "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) " - "value=%d", - strerror(-err), err, query_value); - return VK_ERROR_SURFACE_LOST_KHR; - } - uint32_t min_undequeued_buffers = static_cast(query_value); + err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, + &query_value); + if (err != android::OK || query_value < 0) { + ALOGE( + "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) " + "value=%d", + strerror(-err), err, query_value); + return VK_ERROR_SURFACE_LOST_KHR; + } + uint32_t min_undequeued_buffers = static_cast(query_value); + + err = + window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value); + if (err != android::OK || query_value < 0) { + ALOGE( + "NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d", + strerror(-err), err, query_value); + return VK_ERROR_SURFACE_LOST_KHR; + } + uint32_t max_buffer_count = static_cast(query_value); - err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value); - if (err != android::OK || query_value < 0) { - ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d", - strerror(-err), err, query_value); - return VK_ERROR_SURFACE_LOST_KHR; + if (min_undequeued_buffers + 1 < max_buffer_count) + present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); + present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); } - uint32_t max_buffer_count = static_cast(query_value); - - std::vector present_modes; - if (min_undequeued_buffers + 1 < max_buffer_count) - present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); - present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); VkPhysicalDevicePresentationPropertiesANDROID present_properties; QueryPresentationProperties(pdev, &present_properties); diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index 6a73023193..cd25dd817c 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -27,6 +27,7 @@ _INTERCEPTED_EXTENSIONS = [ 'VK_EXT_hdr_metadata', 'VK_EXT_swapchain_colorspace', 'VK_GOOGLE_display_timing', + 'VK_GOOGLE_surfaceless_query', 'VK_KHR_android_surface', 'VK_KHR_get_surface_capabilities2', 'VK_KHR_incremental_present', -- cgit v1.2.3-59-g8ed1b From bb67b24454fbb78e45e289816fa5fc731fa6411d Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Wed, 16 Mar 2022 09:52:28 -0600 Subject: swapchain: Implement VK_KHR_surface_protected_capabilities This version tries to address some subtle differences between upstream and downstream branches. Bug: 221490496 Test: Test with ANGLE EGLConfig-generation code Change-Id: I750f052e3560e76b2035ed3c92a3ec38745b9ef4 --- vulkan/libvulkan/driver.cpp | 5 +++++ vulkan/libvulkan/driver_gen.cpp | 1 + vulkan/libvulkan/driver_gen.h | 1 + vulkan/libvulkan/swapchain.cpp | 6 ++++++ vulkan/scripts/driver_generator.py | 1 + 5 files changed, 14 insertions(+) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index aee90cd661..766451824a 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -632,6 +632,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { switch (ext_bit) { case ProcHook::KHR_android_surface: case ProcHook::KHR_surface: + case ProcHook::KHR_surface_protected_capabilities: case ProcHook::EXT_swapchain_colorspace: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::GOOGLE_surfaceless_query: @@ -711,6 +712,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_external_fence_capabilities: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::KHR_surface: + case ProcHook::KHR_surface_protected_capabilities: case ProcHook::EXT_debug_report: case ProcHook::EXT_swapchain_colorspace: case ProcHook::GOOGLE_surfaceless_query: @@ -924,6 +926,9 @@ VkResult EnumerateInstanceExtensionProperties( std::vector loader_extensions; loader_extensions.push_back( {VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_SPEC_VERSION}); + loader_extensions.push_back( + {VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME, + VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION}); loader_extensions.push_back({ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, VK_KHR_ANDROID_SURFACE_SPEC_VERSION}); diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index f84fc8814c..b436db1de7 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -571,6 +571,7 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present; if (strcmp(name, "VK_KHR_shared_presentable_image") == 0) return ProcHook::KHR_shared_presentable_image; if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface; + if (strcmp(name, "VK_KHR_surface_protected_capabilities") == 0) return ProcHook::KHR_surface_protected_capabilities; if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain; if (strcmp(name, "VK_ANDROID_external_memory_android_hardware_buffer") == 0) return ProcHook::ANDROID_external_memory_android_hardware_buffer; if (strcmp(name, "VK_KHR_bind_memory2") == 0) return ProcHook::KHR_bind_memory2; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 6a6c5b3d3c..079f9cca39 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -47,6 +47,7 @@ struct ProcHook { KHR_incremental_present, KHR_shared_presentable_image, KHR_surface, + KHR_surface_protected_capabilities, KHR_swapchain, ANDROID_external_memory_android_hardware_buffer, KHR_bind_memory2, diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index f42c4f026b..72696adcc8 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -860,6 +860,12 @@ VkResult GetPhysicalDeviceSurfaceCapabilities2KHR( .supportedUsageFlags; } break; + case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: { + VkSurfaceProtectedCapabilitiesKHR* protected_caps = + reinterpret_cast(caps); + protected_caps->supportsProtected = VK_TRUE; + } break; + default: // Ignore all other extension structs break; diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index cd25dd817c..af56764a21 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -33,6 +33,7 @@ _INTERCEPTED_EXTENSIONS = [ 'VK_KHR_incremental_present', 'VK_KHR_shared_presentable_image', 'VK_KHR_surface', + 'VK_KHR_surface_protected_capabilities', 'VK_KHR_swapchain', ] -- cgit v1.2.3-59-g8ed1b From f6df08ebe6bf3380bdf2b3495eadd9793643172a Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Wed, 16 Mar 2022 21:27:49 -0600 Subject: swapchain: Eliminate silly difference with AOSP Bug: 203826952 Test: Manual inspection Change-Id: Ica37bbb2280e98a50db3359cc97291b5ca449cc1 --- vulkan/libvulkan/swapchain.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 72696adcc8..96da1b0657 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -719,6 +719,8 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, bool wide_color_support = false; uint64_t consumer_usage = 0; + bool swapchain_ext = + instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace); if (surface_handle == VK_NULL_HANDLE) { ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; bool surfaceless_enabled = @@ -746,9 +748,7 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, consumer_usage = surface.consumer_usage; } - wide_color_support = - wide_color_support && - instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace); + wide_color_support = wide_color_support && swapchain_ext; AHardwareBuffer_Desc desc = {}; desc.width = 1; -- cgit v1.2.3-59-g8ed1b From ac1f09816e42765b01b085676595b3f71c16cacf Mon Sep 17 00:00:00 2001 From: Yiwei Zhang Date: Sat, 9 Apr 2022 07:10:10 +0000 Subject: Vulkan: avoid calling cancelBuffer on a shared buffer to silence the err log "cannot cancel a buffer in shared buffer mode" Bug: 204681201 Test: dEQP-VK.wsi.android.shared_presentable_image.* Change-Id: I3ffa0df28b10c5576a2196f5de0a9cf63bc6a1fa --- vulkan/libvulkan/swapchain.cpp | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) (limited to 'vulkan/libvulkan') diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 45bc4c95d9..c4b1487267 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -299,6 +299,7 @@ static bool IsFencePending(int fd) { } void ReleaseSwapchainImage(VkDevice device, + bool shared_present, ANativeWindow* window, int release_fence, Swapchain::Image& image, @@ -330,7 +331,8 @@ void ReleaseSwapchainImage(VkDevice device, } image.dequeue_fence = -1; - if (window) { + // It's invalid to call cancelBuffer on a shared buffer + if (window && !shared_present) { window->cancelBuffer(window, image.buffer.get(), release_fence); } else { if (release_fence >= 0) { @@ -364,9 +366,10 @@ void OrphanSwapchain(VkDevice device, Swapchain* swapchain) { if (swapchain->surface.swapchain_handle != HandleFromSwapchain(swapchain)) return; for (uint32_t i = 0; i < swapchain->num_images; i++) { - if (!swapchain->images[i].dequeued) - ReleaseSwapchainImage(device, nullptr, -1, swapchain->images[i], - true); + if (!swapchain->images[i].dequeued) { + ReleaseSwapchainImage(device, swapchain->shared, nullptr, -1, + swapchain->images[i], true); + } } swapchain->surface.swapchain_handle = VK_NULL_HANDLE; swapchain->timing.clear(); @@ -1084,7 +1087,8 @@ static void DestroySwapchainInternal(VkDevice device, } for (uint32_t i = 0; i < swapchain->num_images; i++) { - ReleaseSwapchainImage(device, window, -1, swapchain->images[i], false); + ReleaseSwapchainImage(device, swapchain->shared, window, -1, + swapchain->images[i], false); } if (active) { @@ -1854,7 +1858,8 @@ VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* present_info) { WorstPresentResult(swapchain_result, VK_SUBOPTIMAL_KHR); } } else { - ReleaseSwapchainImage(device, nullptr, fence, img, true); + ReleaseSwapchainImage(device, swapchain.shared, nullptr, fence, + img, true); swapchain_result = VK_ERROR_OUT_OF_DATE_KHR; } -- cgit v1.2.3-59-g8ed1b