diff options
Diffstat (limited to 'vulkan/libvulkan/driver.cpp')
| -rw-r--r-- | vulkan/libvulkan/driver.cpp | 536 |
1 files changed, 394 insertions, 142 deletions
diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 5d4717200d..d7fdab5586 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -81,6 +81,8 @@ class Hal { Hal(const Hal&) = delete; Hal& operator=(const Hal&) = delete; + bool ShouldUnloadBuiltinDriver(); + void UnloadBuiltinDriver(); bool InitDebugReportIndex(); static Hal hal_; @@ -92,15 +94,15 @@ class Hal { class CreateInfoWrapper { public: CreateInfoWrapper(const VkInstanceCreateInfo& create_info, + uint32_t icd_api_version, const VkAllocationCallbacks& allocator); CreateInfoWrapper(VkPhysicalDevice physical_dev, const VkDeviceCreateInfo& create_info, + uint32_t icd_api_version, const VkAllocationCallbacks& allocator); ~CreateInfoWrapper(); VkResult Validate(); - void DowngradeApiVersion(); - void UpgradeDeviceCoreApiVersion(uint32_t api_version); const std::bitset<ProcHook::EXTENSION_COUNT>& GetHookExtensions() const; const std::bitset<ProcHook::EXTENSION_COUNT>& GetHalExtensions() const; @@ -115,10 +117,12 @@ class CreateInfoWrapper { const char** names; uint32_t name_count; + ExtensionFilter() + : exts(nullptr), ext_count(0), names(nullptr), name_count(0) {} }; + VkResult SanitizeApiVersion(); VkResult SanitizePNext(); - VkResult SanitizeLayers(); VkResult SanitizeExtensions(); @@ -130,6 +134,8 @@ class CreateInfoWrapper { const bool is_instance_; const VkAllocationCallbacks& allocator_; + const uint32_t loader_api_version_; + const uint32_t icd_api_version_; VkPhysicalDevice physical_dev_; @@ -149,8 +155,8 @@ class CreateInfoWrapper { Hal Hal::hal_; const std::array<const char*, 2> HAL_SUBNAME_KEY_PROPERTIES = {{ - "ro.hardware." HWVULKAN_HARDWARE_MODULE_ID, - "ro.board.platform" + "ro.hardware.vulkan", + "ro.board.platform", }}; constexpr int LIB_DL_FLAGS = RTLD_LOCAL | RTLD_NOW; @@ -177,6 +183,8 @@ int LoadDriver(android_namespace_t* library_namespace, .library_namespace = library_namespace, }; so = android_dlopen_ext(lib_name.c_str(), LIB_DL_FLAGS, &dlextinfo); + ALOGE("Could not load %s from updatable gfx driver namespace: %s.", + lib_name.c_str(), dlerror()); } else { // load built-in driver so = android_load_sphal_library(lib_name.c_str(), LIB_DL_FLAGS); @@ -184,9 +192,8 @@ int LoadDriver(android_namespace_t* library_namespace, if (so) break; } - if (!so) { + if (!so) return -ENOENT; - } auto hmi = static_cast<hw_module_t*>(dlsym(so, HAL_MODULE_INFO_SYM_AS_STR)); if (!hmi) { @@ -231,9 +238,15 @@ int LoadUpdatedDriver(const hwvulkan_module_t** module) { bool Hal::Open() { ATRACE_CALL(); + const nsecs_t openTime = systemTime(); - ALOG_ASSERT(!hal_.dev_, "OpenHAL called more than once"); + if (hal_.ShouldUnloadBuiltinDriver()) { + hal_.UnloadBuiltinDriver(); + } + + if (hal_.dev_) + return true; // Use a stub device unless we successfully open a real HAL device. hal_.dev_ = &stubhal::kDevice; @@ -248,16 +261,16 @@ bool Hal::Open() { if (result != 0) { android::GraphicsEnv::getInstance().setDriverLoaded( android::GpuStatsInfo::Api::API_VK, false, systemTime() - openTime); + ALOGV("unable to load Vulkan HAL, using stub HAL (result=%d)", result); return true; } + hwvulkan_device_t* device; ATRACE_BEGIN("hwvulkan module open"); result = module->common.methods->open(&module->common, HWVULKAN_DEVICE_0, reinterpret_cast<hw_device_t**>(&device)); - - ATRACE_END(); if (result != 0) { android::GraphicsEnv::getInstance().setDriverLoaded( @@ -278,6 +291,38 @@ bool Hal::Open() { return true; } +bool Hal::ShouldUnloadBuiltinDriver() { + // Should not unload since the driver was not loaded + if (!hal_.dev_) + return false; + + // Should not unload if stubhal is used on the device + if (hal_.dev_ == &stubhal::kDevice) + return false; + + // Unload the driver if updated driver is chosen + if (android::GraphicsEnv::getInstance().getDriverNamespace()) + return true; + + return false; +} + +void Hal::UnloadBuiltinDriver() { + ATRACE_CALL(); + + ALOGD("Unload builtin Vulkan driver."); + + // Close the opened device + ALOG_ASSERT(!hal_.dev_->common.close(hal_.dev_->common), + "hw_device_t::close() failed."); + + // Close the opened shared library in the hw_module_t + android_unload_sphal_library(hal_.dev_->common.module->dso); + + hal_.dev_ = nullptr; + hal_.debug_report_index_ = -1; +} + bool Hal::InitDebugReportIndex() { ATRACE_CALL(); @@ -316,32 +361,27 @@ bool Hal::InitDebugReportIndex() { } CreateInfoWrapper::CreateInfoWrapper(const VkInstanceCreateInfo& create_info, + uint32_t icd_api_version, const VkAllocationCallbacks& allocator) : is_instance_(true), allocator_(allocator), + loader_api_version_(VK_API_VERSION_1_1), + icd_api_version_(icd_api_version), physical_dev_(VK_NULL_HANDLE), instance_info_(create_info), - extension_filter_() { - // instance core versions need to match the loader api version - for (uint32_t i = ProcHook::EXTENSION_CORE_1_0; - i != ProcHook::EXTENSION_COUNT; ++i) { - hook_extensions_.set(i); - hal_extensions_.set(i); - } -} + extension_filter_() {} CreateInfoWrapper::CreateInfoWrapper(VkPhysicalDevice physical_dev, const VkDeviceCreateInfo& create_info, + uint32_t icd_api_version, const VkAllocationCallbacks& allocator) : is_instance_(false), allocator_(allocator), + loader_api_version_(VK_API_VERSION_1_1), + icd_api_version_(icd_api_version), physical_dev_(physical_dev), dev_info_(create_info), - extension_filter_() { - // initialize with baseline core API version - hook_extensions_.set(ProcHook::EXTENSION_CORE_1_0); - hal_extensions_.set(ProcHook::EXTENSION_CORE_1_0); -} + extension_filter_() {} CreateInfoWrapper::~CreateInfoWrapper() { allocator_.pfnFree(allocator_.pUserData, extension_filter_.exts); @@ -349,7 +389,9 @@ CreateInfoWrapper::~CreateInfoWrapper() { } VkResult CreateInfoWrapper::Validate() { - VkResult result = SanitizePNext(); + VkResult result = SanitizeApiVersion(); + if (result == VK_SUCCESS) + result = SanitizePNext(); if (result == VK_SUCCESS) result = SanitizeLayers(); if (result == VK_SUCCESS) @@ -376,6 +418,22 @@ CreateInfoWrapper::operator const VkDeviceCreateInfo*() const { return &dev_info_; } +VkResult CreateInfoWrapper::SanitizeApiVersion() { + if (!is_instance_ || !instance_info_.pApplicationInfo) + return VK_SUCCESS; + + if (icd_api_version_ > VK_API_VERSION_1_0 || + instance_info_.pApplicationInfo->apiVersion < VK_API_VERSION_1_1) + return VK_SUCCESS; + + // override apiVersion to avoid error return from 1.0 icd + application_info_ = *instance_info_.pApplicationInfo; + application_info_.apiVersion = VK_API_VERSION_1_0; + instance_info_.pApplicationInfo = &application_info_; + + return VK_SUCCESS; +} + VkResult CreateInfoWrapper::SanitizePNext() { const struct StructHeader { VkStructureType type; @@ -423,15 +481,33 @@ VkResult CreateInfoWrapper::SanitizeExtensions() { : dev_info_.ppEnabledExtensionNames; auto& ext_count = (is_instance_) ? instance_info_.enabledExtensionCount : dev_info_.enabledExtensionCount; - if (!ext_count) - return VK_SUCCESS; VkResult result = InitExtensionFilter(); if (result != VK_SUCCESS) return result; - for (uint32_t i = 0; i < ext_count; i++) - FilterExtension(ext_names[i]); + if (is_instance_ && icd_api_version_ < loader_api_version_) { + for (uint32_t i = 0; i < ext_count; i++) { + // Upon api downgrade, skip the promoted instance extensions in the + // first pass to avoid duplicate extensions. + const std::optional<uint32_t> version = + GetInstanceExtensionPromotedVersion(ext_names[i]); + if (version && *version > icd_api_version_ && + *version <= loader_api_version_) + continue; + + FilterExtension(ext_names[i]); + } + + // Enable the required extensions to support core functionalities. + const auto promoted_extensions = GetPromotedInstanceExtensions( + icd_api_version_, loader_api_version_); + for (const auto& promoted_extension : promoted_extensions) + FilterExtension(promoted_extension); + } else { + for (uint32_t i = 0; i < ext_count; i++) + FilterExtension(ext_names[i]); + } // Enable device extensions that contain physical-device commands, so that // vkGetInstanceProcAddr will return those physical-device commands. @@ -439,6 +515,23 @@ VkResult CreateInfoWrapper::SanitizeExtensions() { hook_extensions_.set(ProcHook::KHR_swapchain); } + const uint32_t api_version = + is_instance_ ? loader_api_version_ + : std::min(icd_api_version_, loader_api_version_); + switch (api_version) { + case VK_API_VERSION_1_1: + hook_extensions_.set(ProcHook::EXTENSION_CORE_1_1); + hal_extensions_.set(ProcHook::EXTENSION_CORE_1_1); + [[clang::fallthrough]]; + case VK_API_VERSION_1_0: + hook_extensions_.set(ProcHook::EXTENSION_CORE_1_0); + hal_extensions_.set(ProcHook::EXTENSION_CORE_1_0); + break; + default: + ALOGE("Unknown API version[%u]", api_version); + break; + } + ext_names = extension_filter_.names; ext_count = extension_filter_.name_count; @@ -496,10 +589,24 @@ VkResult CreateInfoWrapper::InitExtensionFilter() { filter.ext_count = count; // allocate name array - uint32_t enabled_ext_count = (is_instance_) - ? instance_info_.enabledExtensionCount - : dev_info_.enabledExtensionCount; - count = std::min(filter.ext_count, enabled_ext_count); + if (is_instance_) { + uint32_t enabled_ext_count = instance_info_.enabledExtensionCount; + + // It requires enabling additional promoted extensions to downgrade api, + // so we reserve enough space here. + if (icd_api_version_ < loader_api_version_) { + enabled_ext_count += CountPromotedInstanceExtensions( + icd_api_version_, loader_api_version_); + } + + count = std::min(filter.ext_count, enabled_ext_count); + } else { + count = std::min(filter.ext_count, dev_info_.enabledExtensionCount); + } + + if (!count) + return VK_SUCCESS; + filter.names = reinterpret_cast<const char**>(allocator_.pfnAllocation( allocator_.pUserData, sizeof(const char*) * count, alignof(const char*), VK_SYSTEM_ALLOCATION_SCOPE_COMMAND)); @@ -527,6 +634,10 @@ void CreateInfoWrapper::FilterExtension(const char* name) { hook_extensions_.set(ext_bit); break; case ProcHook::KHR_get_physical_device_properties2: + case ProcHook::KHR_device_group_creation: + case ProcHook::KHR_external_memory_capabilities: + case ProcHook::KHR_external_semaphore_capabilities: + case ProcHook::KHR_external_fence_capabilities: case ProcHook::EXTENSION_UNKNOWN: // Extensions we don't need to do anything about at this level break; @@ -584,6 +695,10 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_android_surface: case ProcHook::KHR_get_physical_device_properties2: + case ProcHook::KHR_device_group_creation: + case ProcHook::KHR_external_memory_capabilities: + case ProcHook::KHR_external_semaphore_capabilities: + case ProcHook::KHR_external_fence_capabilities: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::KHR_surface: case ProcHook::EXT_debug_report: @@ -630,40 +745,6 @@ void CreateInfoWrapper::FilterExtension(const char* name) { } } -void CreateInfoWrapper::DowngradeApiVersion() { - // If pApplicationInfo is NULL, apiVersion is assumed to be 1.0: - if (instance_info_.pApplicationInfo) { - application_info_ = *instance_info_.pApplicationInfo; - instance_info_.pApplicationInfo = &application_info_; - application_info_.apiVersion = VK_API_VERSION_1_0; - } -} - -void CreateInfoWrapper::UpgradeDeviceCoreApiVersion(uint32_t api_version) { - ALOG_ASSERT(!is_instance_, "Device only API called by instance wrapper."); - -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wold-style-cast" - api_version ^= VK_VERSION_PATCH(api_version); -#pragma clang diagnostic pop - - // cap the API version to the loader supported highest version - if (api_version > VK_API_VERSION_1_1) - api_version = VK_API_VERSION_1_1; - - switch (api_version) { - case VK_API_VERSION_1_1: - hook_extensions_.set(ProcHook::EXTENSION_CORE_1_1); - hal_extensions_.set(ProcHook::EXTENSION_CORE_1_1); - [[clang::fallthrough]]; - case VK_API_VERSION_1_0: - break; - default: - ALOGD("Unknown upgrade API version[%u]", api_version); - break; - } -} - VKAPI_ATTR void* DefaultAllocate(void*, size_t size, size_t alignment, @@ -895,21 +976,14 @@ VkResult EnumerateInstanceExtensionProperties( return result; } -bool QueryPresentationProperties( +void QueryPresentationProperties( VkPhysicalDevice physicalDevice, - VkPhysicalDevicePresentationPropertiesANDROID *presentation_properties) { - const InstanceData& data = GetData(physicalDevice); - - // GPDP2 must be present and enabled on the instance. - if (!data.driver.GetPhysicalDeviceProperties2KHR && - !data.driver.GetPhysicalDeviceProperties2) - return false; - + VkPhysicalDevicePresentationPropertiesANDROID* presentation_properties) { // Request the android-specific presentation properties via GPDP2 - VkPhysicalDeviceProperties2KHR properties = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + VkPhysicalDeviceProperties2 properties = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, presentation_properties, - {} + {}, }; #pragma clang diagnostic push @@ -920,14 +994,7 @@ bool QueryPresentationProperties( presentation_properties->pNext = nullptr; presentation_properties->sharedImage = VK_FALSE; - if (data.driver.GetPhysicalDeviceProperties2KHR) { - data.driver.GetPhysicalDeviceProperties2KHR(physicalDevice, - &properties); - } else { - data.driver.GetPhysicalDeviceProperties2(physicalDevice, &properties); - } - - return true; + GetPhysicalDeviceProperties2(physicalDevice, &properties); } VkResult EnumerateDeviceExtensionProperties( @@ -949,8 +1016,8 @@ VkResult EnumerateDeviceExtensionProperties( } VkPhysicalDevicePresentationPropertiesANDROID presentation_properties; - if (QueryPresentationProperties(physicalDevice, &presentation_properties) && - presentation_properties.sharedImage) { + QueryPresentationProperties(physicalDevice, &presentation_properties); + if (presentation_properties.sharedImage) { loader_extensions.push_back({ VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION}); @@ -1019,49 +1086,32 @@ VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks& data_allocator = (pAllocator) ? *pAllocator : GetDefaultAllocator(); - CreateInfoWrapper wrapper(*pCreateInfo, data_allocator); - VkResult result = wrapper.Validate(); - if (result != VK_SUCCESS) - return result; - - ATRACE_BEGIN("AllocateInstanceData"); - InstanceData* data = AllocateInstanceData(data_allocator); - ATRACE_END(); - if (!data) - return VK_ERROR_OUT_OF_HOST_MEMORY; - - data->hook_extensions |= wrapper.GetHookExtensions(); - - ATRACE_BEGIN("autoDowngradeApiVersion"); -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wold-style-cast" - uint32_t api_version = ((pCreateInfo->pApplicationInfo) - ? pCreateInfo->pApplicationInfo->apiVersion - : VK_API_VERSION_1_0); - uint32_t api_major_version = VK_VERSION_MAJOR(api_version); - uint32_t api_minor_version = VK_VERSION_MINOR(api_version); - uint32_t icd_api_version; + VkResult result = VK_SUCCESS; + uint32_t icd_api_version = VK_API_VERSION_1_0; PFN_vkEnumerateInstanceVersion pfn_enumerate_instance_version = reinterpret_cast<PFN_vkEnumerateInstanceVersion>( Hal::Device().GetInstanceProcAddr(nullptr, "vkEnumerateInstanceVersion")); - if (!pfn_enumerate_instance_version) { - icd_api_version = VK_API_VERSION_1_0; - } else { + if (pfn_enumerate_instance_version) { ATRACE_BEGIN("pfn_enumerate_instance_version"); result = (*pfn_enumerate_instance_version)(&icd_api_version); ATRACE_END(); - } - uint32_t icd_api_major_version = VK_VERSION_MAJOR(icd_api_version); - uint32_t icd_api_minor_version = VK_VERSION_MINOR(icd_api_version); + if (result != VK_SUCCESS) + return result; - if ((icd_api_major_version == 1) && (icd_api_minor_version == 0) && - ((api_major_version > 1) || (api_minor_version > 0))) { - api_version = VK_API_VERSION_1_0; - wrapper.DowngradeApiVersion(); + icd_api_version ^= VK_VERSION_PATCH(icd_api_version); } -#pragma clang diagnostic pop - ATRACE_END(); + + CreateInfoWrapper wrapper(*pCreateInfo, icd_api_version, data_allocator); + result = wrapper.Validate(); + if (result != VK_SUCCESS) + return result; + + InstanceData* data = AllocateInstanceData(data_allocator); + if (!data) + return VK_ERROR_OUT_OF_HOST_MEMORY; + + data->hook_extensions |= wrapper.GetHookExtensions(); // call into the driver VkInstance instance; @@ -1125,7 +1175,16 @@ VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkAllocationCallbacks& data_allocator = (pAllocator) ? *pAllocator : instance_data.allocator; - CreateInfoWrapper wrapper(physicalDevice, *pCreateInfo, data_allocator); + VkPhysicalDeviceProperties properties; + ATRACE_BEGIN("driver.GetPhysicalDeviceProperties"); + instance_data.driver.GetPhysicalDeviceProperties(physicalDevice, + &properties); + ATRACE_END(); + + CreateInfoWrapper wrapper( + physicalDevice, *pCreateInfo, + properties.apiVersion ^ VK_VERSION_PATCH(properties.apiVersion), + data_allocator); VkResult result = wrapper.Validate(); if (result != VK_SUCCESS) return result; @@ -1137,13 +1196,6 @@ VkResult CreateDevice(VkPhysicalDevice physicalDevice, if (!data) return VK_ERROR_OUT_OF_HOST_MEMORY; - VkPhysicalDeviceProperties properties; - ATRACE_BEGIN("driver.GetPhysicalDeviceProperties"); - instance_data.driver.GetPhysicalDeviceProperties(physicalDevice, - &properties); - ATRACE_END(); - - wrapper.UpgradeDeviceCoreApiVersion(properties.apiVersion); data->hook_extensions |= wrapper.GetHookExtensions(); // call into the driver @@ -1240,7 +1292,8 @@ VkResult EnumeratePhysicalDeviceGroups( VkResult result = VK_SUCCESS; const auto& data = GetData(instance); - if (!data.driver.EnumeratePhysicalDeviceGroups) { + if (!data.driver.EnumeratePhysicalDeviceGroups && + !data.driver.EnumeratePhysicalDeviceGroupsKHR) { uint32_t device_count = 0; result = EnumeratePhysicalDevices(instance, &device_count, nullptr); if (result < 0) @@ -1272,9 +1325,15 @@ VkResult EnumeratePhysicalDeviceGroups( pPhysicalDeviceGroupProperties[i].subsetAllocation = 0; } } else { - result = data.driver.EnumeratePhysicalDeviceGroups( - instance, pPhysicalDeviceGroupCount, - pPhysicalDeviceGroupProperties); + if (data.driver.EnumeratePhysicalDeviceGroups) { + result = data.driver.EnumeratePhysicalDeviceGroups( + instance, pPhysicalDeviceGroupCount, + pPhysicalDeviceGroupProperties); + } else { + result = data.driver.EnumeratePhysicalDeviceGroupsKHR( + instance, pPhysicalDeviceGroupCount, + pPhysicalDeviceGroupProperties); + } if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && *pPhysicalDeviceGroupCount && pPhysicalDeviceGroupProperties) { for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++) { @@ -1315,10 +1374,10 @@ void GetDeviceQueue2(VkDevice device, if (*pQueue != VK_NULL_HANDLE) SetData(*pQueue, data); } -VKAPI_ATTR VkResult -AllocateCommandBuffers(VkDevice device, - const VkCommandBufferAllocateInfo* pAllocateInfo, - VkCommandBuffer* pCommandBuffers) { +VkResult AllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers) { ATRACE_CALL(); const auto& data = GetData(device); @@ -1333,10 +1392,10 @@ AllocateCommandBuffers(VkDevice device, return result; } -VKAPI_ATTR VkResult QueueSubmit(VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo* pSubmits, - VkFence fence) { +VkResult QueueSubmit(VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence) { ATRACE_CALL(); const auto& data = GetData(queue); @@ -1344,5 +1403,198 @@ VKAPI_ATTR VkResult QueueSubmit(VkQueue queue, return data.driver.QueueSubmit(queue, submitCount, pSubmits, fence); } +void GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceFeatures2) { + driver.GetPhysicalDeviceFeatures2(physicalDevice, pFeatures); + return; + } + + driver.GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); +} + +void GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceProperties2) { + driver.GetPhysicalDeviceProperties2(physicalDevice, pProperties); + return; + } + + driver.GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); +} + +void GetPhysicalDeviceFormatProperties2( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceFormatProperties2) { + driver.GetPhysicalDeviceFormatProperties2(physicalDevice, format, + pFormatProperties); + return; + } + + driver.GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, + pFormatProperties); +} + +VkResult GetPhysicalDeviceImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceImageFormatProperties2) { + return driver.GetPhysicalDeviceImageFormatProperties2( + physicalDevice, pImageFormatInfo, pImageFormatProperties); + } + + return driver.GetPhysicalDeviceImageFormatProperties2KHR( + physicalDevice, pImageFormatInfo, pImageFormatProperties); +} + +void GetPhysicalDeviceQueueFamilyProperties2( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceQueueFamilyProperties2) { + driver.GetPhysicalDeviceQueueFamilyProperties2( + physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + return; + } + + driver.GetPhysicalDeviceQueueFamilyProperties2KHR( + physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); +} + +void GetPhysicalDeviceMemoryProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceMemoryProperties2) { + driver.GetPhysicalDeviceMemoryProperties2(physicalDevice, + pMemoryProperties); + return; + } + + driver.GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, + pMemoryProperties); +} + +void GetPhysicalDeviceSparseImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceSparseImageFormatProperties2) { + driver.GetPhysicalDeviceSparseImageFormatProperties2( + physicalDevice, pFormatInfo, pPropertyCount, pProperties); + return; + } + + driver.GetPhysicalDeviceSparseImageFormatProperties2KHR( + physicalDevice, pFormatInfo, pPropertyCount, pProperties); +} + +void GetPhysicalDeviceExternalBufferProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceExternalBufferProperties) { + driver.GetPhysicalDeviceExternalBufferProperties( + physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + return; + } + + if (driver.GetPhysicalDeviceExternalBufferPropertiesKHR) { + driver.GetPhysicalDeviceExternalBufferPropertiesKHR( + physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + return; + } + + memset(&pExternalBufferProperties->externalMemoryProperties, 0, + sizeof(VkExternalMemoryProperties)); +} + +void GetPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceExternalSemaphoreProperties) { + driver.GetPhysicalDeviceExternalSemaphoreProperties( + physicalDevice, pExternalSemaphoreInfo, + pExternalSemaphoreProperties); + return; + } + + if (driver.GetPhysicalDeviceExternalSemaphorePropertiesKHR) { + driver.GetPhysicalDeviceExternalSemaphorePropertiesKHR( + physicalDevice, pExternalSemaphoreInfo, + pExternalSemaphoreProperties); + return; + } + + pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0; + pExternalSemaphoreProperties->compatibleHandleTypes = 0; + pExternalSemaphoreProperties->externalSemaphoreFeatures = 0; +} + +void GetPhysicalDeviceExternalFenceProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceExternalFenceProperties) { + driver.GetPhysicalDeviceExternalFenceProperties( + physicalDevice, pExternalFenceInfo, pExternalFenceProperties); + return; + } + + if (driver.GetPhysicalDeviceExternalFencePropertiesKHR) { + driver.GetPhysicalDeviceExternalFencePropertiesKHR( + physicalDevice, pExternalFenceInfo, pExternalFenceProperties); + return; + } + + pExternalFenceProperties->exportFromImportedHandleTypes = 0; + pExternalFenceProperties->compatibleHandleTypes = 0; + pExternalFenceProperties->externalFenceFeatures = 0; +} + } // namespace driver } // namespace vulkan |