fdo-mirrors/vulkan-wsi-layer
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/vulkan-wsi-layer.git synced 2025-12-19 23:50:07 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge 'Add -Wshadow -Wconversion' into 'main'

Browse source 
See merge request mesa/vulkan-wsi-layer!219
This commit is contained in:
Iason Paraskevopoulos 2025-12-17 09:55:55 +00:00
commit 1ede24b595
23 changed files with 116 additions and 110 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
CMakeLists.txt
View file

@ -35,13 +35,15 @@ endif()
string(APPEND CMAKE_CXX_FLAGS
" -Wall -Werror -Wextra"
" -Wshadow -Wconversion"
" -Wdouble-promotion -Wnon-virtual-dtor -Wdelete-non-virtual-dtor"
" -Wcast-qual -Werror=return-type -Wmissing-format-attribute"
" -Wcast-qual -Wmissing-format-attribute"
" -pthread -fPIC"
)
string(APPEND CMAKE_C_FLAGS
" -Wall -Werror -Wextra"
" -Wshadow -Wconversion"
" -Wstrict-prototypes"
" -fPIC"
)

4
layer/layer.cpp
View file

@ -158,7 +158,7 @@ VKAPI_ATTR VkResult create_instance(const VkInstanceCreateInfo *pCreateInfo, con
TRY_LOG_CALL(extensions.get_extension_strings(modified_enabled_extensions));
modified_info.ppEnabledExtensionNames = modified_enabled_extensions.data();
modified_info.enabledExtensionCount = modified_enabled_extensions.size();
modified_info.enabledExtensionCount = static_cast<uint32_t>(modified_enabled_extensions.size());
/* Advance the link info for the next element on the chain. */
layer_link_info->u.pLayerInfo = layer_link_info->u.pLayerInfo->pNext;
@ -291,7 +291,7 @@ VKAPI_ATTR VkResult create_device(VkPhysicalDevice physicalDevice, const VkDevic
TRY_LOG_CALL(enabled_extensions.get_extension_strings(modified_enabled_extensions));
modified_info.ppEnabledExtensionNames = modified_enabled_extensions.data();
modified_info.enabledExtensionCount = modified_enabled_extensions.size();
modified_info.enabledExtensionCount = static_cast<uint32_t>(modified_enabled_extensions.size());
}
bool should_layer_handle_frame_boundary_events = false;

16
layer/private_data.cpp
View file

@ -179,12 +179,12 @@ PFN_vkVoidFunction device_dispatch_table::get_user_enabled_entrypoint(VkDevice d
}
instance_private_data::instance_private_data(instance_dispatch_table table, PFN_vkSetInstanceLoaderData set_loader_data,
util::wsi_platform_set enabled_layer_platforms, const uint32_t api_version,
const util::allocator &alloc)
util::wsi_platform_set layer_platforms,
const uint32_t instance_api_version, const util::allocator &alloc)
: disp{ std::move(table) }
, api_version{ api_version }
, api_version{ instance_api_version }
, SetInstanceLoaderData{ set_loader_data }
, enabled_layer_platforms{ enabled_layer_platforms }
, enabled_layer_platforms{ layer_platforms }
, allocator{ alloc }
, surfaces{ alloc }
, enabled_extensions{ allocator }
@ -205,11 +205,11 @@ static inline void *get_key(dispatchable_type dispatchable_object)
VkResult instance_private_data::associate(VkInstance instance, instance_dispatch_table table,
PFN_vkSetInstanceLoaderData set_loader_data,
util::wsi_platform_set enabled_layer_platforms, const uint32_t api_version,
const util::allocator &allocator)
util::wsi_platform_set enabled_layer_platforms,
const uint32_t instance_api_version, const util::allocator &allocator)
{
auto instance_data = allocator.make_unique<instance_private_data>(std::move(table), set_loader_data,
enabled_layer_platforms, api_version, allocator);
auto instance_data = allocator.make_unique<instance_private_data>(
std::move(table), set_loader_data, enabled_layer_platforms, instance_api_version, allocator);
if (instance_data == nullptr)
{

2
layer/swapchain_api.cpp
View file

@ -423,7 +423,7 @@ wsi_layer_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
if (bind_sc_info == nullptr || bind_sc_info->swapchain == VK_NULL_HANDLE ||
!device_data.layer_owns_swapchain(bind_sc_info->swapchain))
{
result = device_data.disp.BindImageMemory2KHR(device, 1, &pBindInfos[i]);
result = device_data.disp.BindImageMemory2KHR(device, 1u, &pBindInfos[i]);
error_message = "Failed to bind image memory";
}
else

10
util/custom_allocator.hpp
View file

@ -201,11 +201,11 @@ T *allocator::create(size_t num_objects, arg_types &&...args) const noexcept
return nullptr;
}
custom_allocator<T> allocator(*this);
custom_allocator<T> object_allocator(*this);
T *ptr;
try
{
ptr = allocator.allocate(num_objects);
ptr = object_allocator.allocate(num_objects);
}
catch (...)
{
@ -232,7 +232,7 @@ T *allocator::create(size_t num_objects, arg_types &&...args) const noexcept
objects_constructed--;
ptr[objects_constructed].~T();
}
allocator.deallocate(ptr, num_objects);
object_allocator.deallocate(ptr, num_objects);
return nullptr;
}
return ptr;
@ -247,12 +247,12 @@ void allocator::destroy(size_t num_objects, T *objects) const noexcept
return;
}
custom_allocator<T> allocator(*this);
custom_allocator<T> object_allocator(*this);
for (size_t i = 0; i < num_objects; i++)
{
objects[i].~T();
}
allocator.deallocate(objects, num_objects);
object_allocator.deallocate(objects, num_objects);
}
/**

4
util/wsialloc/wsialloc_dma_buf_heaps.c
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2024 Arm Limited.
* Copyright (c) 2024-2025 Arm Limited.
*
* SPDX-License-Identifier: MIT
*
@ -85,7 +85,7 @@ static int allocate(int fd, uint64_t size)
return -errno;
}
assert(heap_data.fd > 0);
return heap_data.fd;
return (int)heap_data.fd;
}
static int dma_allocate(const wsialloc_allocator *allocator, const wsialloc_allocate_info *info, uint64_t size)

12
util/wsialloc/wsialloc_helpers.c
View file

@ -44,7 +44,7 @@ static uint64_t round_size_up_to_align(uint64_t size)
}
static wsialloc_error calculate_format_properties(const wsialloc_format_descriptor *descriptor,
const wsialloc_allocate_info *info, int *strides, int *offsets,
const wsialloc_allocate_info *info, int *strides, uint32_t *offsets,
uint64_t *total_size)
{
assert(descriptor != NULL);
@ -76,11 +76,11 @@ static wsialloc_error calculate_format_properties(const wsialloc_format_descript
assert(plane_bytes_per_pixel * 8 == bits_per_pixel[plane]);
/* With large enough width, this can overflow as strides are signed. In practice, this shouldn't happen */
strides[plane] = round_size_up_to_align(info->width * plane_bytes_per_pixel);
strides[plane] = (int)round_size_up_to_align((uint64_t)info->width * plane_bytes_per_pixel);
offsets[plane] = size;
offsets[plane] = (uint32_t)size;
size += strides[plane] * info->height;
size += (uint64_t)strides[plane] * info->height;
}
*total_size = size;
return WSIALLOC_ERROR_NONE;
@ -138,7 +138,7 @@ wsialloc_error wsiallocp_alloc(wsialloc_allocator *allocator, wsiallocp_alloc_ca
}
int local_strides[WSIALLOC_MAX_PLANES];
int local_offsets[WSIALLOC_MAX_PLANES];
uint32_t local_offsets[WSIALLOC_MAX_PLANES];
wsialloc_error err = WSIALLOC_ERROR_NONE;
wsialloc_format_descriptor selected_format_desc = {};
@ -195,4 +195,4 @@ wsialloc_error wsiallocp_alloc(wsialloc_allocator *allocator, wsiallocp_alloc_ca
result->is_disjoint = false;
return WSIALLOC_ERROR_NONE;
}
}

9
wsi/display/drm_display.cpp
View file

@ -98,7 +98,7 @@ static int find_compatible_crtc(int fd, drm_resources_owner &resources, drm_conn
/* Make the assumption that only one connector will be in use at a time so there is no
* need to check that any other connectors are being driven by this CRTC. */
return resources->crtcs[j];
return static_cast<int>(resources->crtcs[j]);
}
}
@ -183,7 +183,8 @@ static bool fill_supported_formats_with_modifiers(uint32_t primary_plane_index,
if (!strcmp(property->name, "IN_FORMATS"))
{
drmModeFormatModifierIterator iter{};
drm_property_blob_owner blob{ drmModeGetPropertyBlob(drm_fd.get(), object_properties->prop_values[i]) };
drm_property_blob_owner blob{ drmModeGetPropertyBlob(
drm_fd.get(), static_cast<uint32_t>(object_properties->prop_values[i])) };
if (blob == nullptr)
{
return false;
@ -403,8 +404,8 @@ const util::vector<util::drm::drm_format_pair> *drm_display::get_supported_forma
bool drm_display::is_format_supported(const util::drm::drm_format_pair &format) const
{
auto supported_format =
std::find_if(m_supported_formats->begin(), m_supported_formats->end(), [format](const auto &supported_format) {
return format.fourcc == supported_format.fourcc && format.modifier == supported_format.modifier;
std::find_if(m_supported_formats->begin(), m_supported_formats->end(), [format](const auto &candidate) {
return format.fourcc == candidate.fourcc && format.modifier == candidate.modifier;
});
return supported_format != m_supported_formats->end();

34
wsi/display/surface_properties.cpp
View file

@ -215,7 +215,7 @@ CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
assert(pCreateInfo->pNext == NULL);
assert(pCreateInfo->flags == 0);
drm_display *dpy = reinterpret_cast<drm_display *>(display);
auto *dpy = reinterpret_cast<drm_display *>(display);
const VkDisplayModeParametersKHR *params = &pCreateInfo->parameters;
@ -224,9 +224,10 @@ CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
return VK_ERROR_INITIALIZATION_FAILED;
}
auto *mode = std::find_if(dpy->get_display_modes_begin(), dpy->get_display_modes_end(), [params](auto &mode) {
return mode.get_width() == params->visibleRegion.width && mode.get_height() == params->visibleRegion.height &&
mode.get_refresh_rate() == params->refreshRate;
auto *mode = std::find_if(dpy->get_display_modes_begin(), dpy->get_display_modes_end(), [params](auto &candidate) {
return candidate.get_width() == params->visibleRegion.width &&
candidate.get_height() == params->visibleRegion.height &&
candidate.get_refresh_rate() == params->refreshRate;
});
if (mode != dpy->get_display_modes_end())
@ -246,7 +247,7 @@ CreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateIn
auto &instance_data = layer::instance_private_data::get(instance);
util::allocator allocator{ instance_data.get_allocator(), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT, pAllocator };
drm_display_mode *display_mode = reinterpret_cast<drm_display_mode *>(pCreateInfo->displayMode);
auto *display_mode = reinterpret_cast<drm_display_mode *>(pCreateInfo->displayMode);
VkResult res = instance_data.disp.CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
if (res == VK_SUCCESS)
@ -276,11 +277,11 @@ GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR displa
assert(display != VK_NULL_HANDLE);
assert(pPropertyCount != nullptr);
drm_display *dpy = reinterpret_cast<drm_display *>(display);
auto *dpy = reinterpret_cast<drm_display *>(display);
assert(dpy != nullptr);
drm_display_mode *modes{ dpy->get_display_modes_begin() };
size_t num_modes{ dpy->get_num_display_modes() };
auto num_modes = static_cast<uint32_t>(dpy->get_num_display_modes());
if (pProperties == nullptr)
{
@ -288,12 +289,12 @@ GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR displa
return VK_SUCCESS;
}
uint32_t nr_properties = std::min(*pPropertyCount, static_cast<uint32_t>(num_modes));
uint32_t nr_properties = std::min(*pPropertyCount, num_modes);
*pPropertyCount = 0;
std::for_each(modes, modes + nr_properties, [&pProperties, &pPropertyCount](auto &mode) {
VkDisplayModePropertiesKHR properties = {};
VkDisplayModeKHR display_mode = reinterpret_cast<VkDisplayModeKHR>(&mode);
auto display_mode = reinterpret_cast<VkDisplayModeKHR>(&mode);
properties.displayMode = display_mode;
VkDisplayModeParametersKHR parameters{};
@ -305,7 +306,7 @@ GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR displa
*pPropertyCount += 1;
});
if (*pPropertyCount < static_cast<uint32_t>(num_modes))
if (*pPropertyCount < num_modes)
{
return VK_INCOMPLETE;
}
@ -323,7 +324,7 @@ GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR
assert(mode != VK_NULL_HANDLE);
assert(pCapabilities != nullptr);
drm_display_mode *display_mode = reinterpret_cast<drm_display_mode *>(mode);
auto *display_mode = reinterpret_cast<drm_display_mode *>(mode);
assert(display_mode != nullptr);
auto &display = drm_display::get_display();
@ -337,11 +338,12 @@ GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR
* images. Therefore plane index must be 0. */
assert(planeIndex == 0);
auto valid_mode =
std::find_if(display->get_display_modes_begin(), display->get_display_modes_end(), [&display_mode](auto &mode) {
return (display_mode->get_width() == mode.get_width()) && (display_mode->get_height() == mode.get_height()) &&
(display_mode->get_refresh_rate() == mode.get_refresh_rate());
});
auto valid_mode = std::find_if(display->get_display_modes_begin(), display->get_display_modes_end(),
[&display_mode](auto &candidate) {
return (display_mode->get_width() == candidate.get_width()) &&
(display_mode->get_height() == candidate.get_height()) &&
(display_mode->get_refresh_rate() == candidate.get_refresh_rate());
});
assert(valid_mode != display->get_display_modes_end());
UNUSED(valid_mode);

16
wsi/display/swapchain.cpp
View file

@ -68,7 +68,7 @@ public:
}
private:
uint32_t m_drm_fd;
int m_drm_fd;
uint32_t m_fb_id;
};
@ -236,7 +236,7 @@ VkResult swapchain::create_framebuffer(image_backing_memory_external &image_exte
for (uint32_t plane = 0; plane < ext_memory.get_num_planes(); plane++)
{
assert(ext_memory.get_strides()[plane] > 0);
strides[plane] = ext_memory.get_strides()[plane];
strides[plane] = static_cast<uint32_t>(ext_memory.get_strides()[plane]);
modifiers[plane] = allocated_format.modifier;
if (drmPrimeFDToHandle(display->get_drm_fd(), buffer_fds[plane], &buffer_handles[plane]) != 0)
{
@ -332,8 +332,8 @@ void swapchain::present_image(const pending_present_request &pending_present)
drmModeModeInfo modeInfo = m_display_mode->get_drm_mode();
uint32_t connector_id = display->get_connector_id();
drm_res = drmModeSetCrtc(display->get_drm_fd(), display->get_crtc_id(), image_data->get_fb_id(), 0, 0,
&connector_id, 1, &modeInfo);
drm_res = drmModeSetCrtc(display->get_drm_fd(), static_cast<uint32_t>(display->get_crtc_id()),
image_data->get_fb_id(), 0, 0, &connector_id, 1, &modeInfo);
if (drm_res != 0)
{
@ -348,8 +348,8 @@ void swapchain::present_image(const pending_present_request &pending_present)
bool page_flip_complete = false;
drm_res = drmModePageFlip(display->get_drm_fd(), display->get_crtc_id(), image_data->get_fb_id(),
DRM_MODE_PAGE_FLIP_EVENT, (void *)&page_flip_complete);
drm_res = drmModePageFlip(display->get_drm_fd(), static_cast<uint32_t>(display->get_crtc_id()),
image_data->get_fb_id(), DRM_MODE_PAGE_FLIP_EVENT, (void *)&page_flip_complete);
if (drm_res != 0)
{
@ -398,7 +398,7 @@ void swapchain::present_image(const pending_present_request &pending_present)
}
/* Find currently presented image */
uint32_t presented_index = m_swapchain_images.size();
auto presented_index = static_cast<uint32_t>(m_swapchain_images.size());
if (!m_first_present)
{
for (uint32_t i = 0; i < m_swapchain_images.size(); ++i)
@ -426,8 +426,6 @@ void swapchain::present_image(const pending_present_request &pending_present)
{
unpresent_image(presented_index);
}
return;
}
std::variant<VkResult, util::unique_ptr<vulkan_image_handle_creator>> swapchain::create_image_creator(

5
wsi/extensions/present_timing.cpp
View file

@ -390,7 +390,8 @@ VkResult wsi_ext_present_timing::get_past_presentation_results(
for (uint64_t i = 0; (i - removed_entries) < m_queue.size(); ++i)
{
auto slot = m_queue.begin() + (i - removed_entries);
const auto slot_offset = static_cast<decltype(m_queue)::difference_type>(i - removed_entries);
auto slot = m_queue.begin() + slot_offset;
if (!slot->has_completed_stages(allow_partial))
{
@ -419,7 +420,7 @@ VkResult wsi_ext_present_timing::get_past_presentation_results(
incomplete = true;
}
}
past_present_timing_properties->presentationTimingCount = timing_count;
past_present_timing_properties->presentationTimingCount = static_cast<uint32_t>(timing_count);
return incomplete ? VK_INCOMPLETE : VK_SUCCESS;
}

6
wsi/extensions/present_timing.hpp
View file

@ -334,8 +334,8 @@ public:
{
if (m_command_pool != VK_NULL_HANDLE)
{
m_device.disp.FreeCommandBuffers(m_device.device, m_command_pool, m_command_buffer.size(),
m_command_buffer.data());
m_device.disp.FreeCommandBuffers(m_device.device, m_command_pool,
static_cast<uint32_t>(m_command_buffer.size()), m_command_buffer.data());
m_device.disp.DestroyCommandPool(m_device.device, m_command_pool, m_allocator.get_original_callbacks());
m_command_pool = VK_NULL_HANDLE;
@ -377,7 +377,7 @@ public:
TRY_LOG_CALL(
m_device.disp.AllocateCommandBuffers(m_device.device, &command_buffer_info, m_command_buffer.data()));
VkCommandBufferBeginInfo begin_info = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr, 0, nullptr };
for (size_t image_index = 0; image_index < num_images; image_index++)
for (uint32_t image_index = 0; image_index < num_images; image_index++)
{
TRY_LOG_CALL(m_device.disp.BeginCommandBuffer(m_command_buffer[image_index], &begin_info));
m_device.disp.CmdResetQueryPool(m_command_buffer[image_index], m_query_pool, image_index, 1);

3
wsi/external_memory.cpp
View file

@ -179,7 +179,8 @@ VkResult external_memory::bind_swapchain_image_memory(const VkImage &image)
bind_img_mem_infos[plane].memoryOffset = m_offsets[plane];
}
return device_data.disp.BindImageMemory2KHR(m_device, bind_img_mem_infos.size(), bind_img_mem_infos.data());
return device_data.disp.BindImageMemory2KHR(m_device, static_cast<uint32_t>(bind_img_mem_infos.size()),
bind_img_mem_infos.data());
}
return device_data.disp.BindImageMemory(m_device, image, m_memories[0], m_offsets[0]);

8
wsi/image_backing_memory_device.cpp
View file

@ -72,18 +72,18 @@ VkResult image_backing_memory_device::allocate_and_bind(VkImage image)
VkMemoryAllocateInfo mem_info = {};
mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
mem_info.allocationSize = memory_requirements.size;
mem_info.memoryTypeIndex = mem_type_idx;
mem_info.memoryTypeIndex = static_cast<uint32_t>(mem_type_idx);
TRY(disp_table.AllocateMemory(m_device_data.device, &mem_info, m_allocator.get_original_callbacks(),
&m_device_memory));
TRY(disp_table.BindImageMemory(m_device_data.device, image, m_device_memory, 0));
TRY(disp_table.BindImageMemory(m_device_data.device, image, m_device_memory, 0ull));
return VK_SUCCESS;
}
VkResult image_backing_memory_device::bind(const VkBindImageMemoryInfo *bind_image_mem_info)
{
return m_device_data.disp.BindImageMemory(m_device_data.device, bind_image_mem_info->image, m_device_memory, 0);
return m_device_data.disp.BindImageMemory(m_device_data.device, bind_image_mem_info->image, m_device_memory, 0ull);
}
uint64_t image_backing_memory_device::get_modifier() const
@ -92,4 +92,4 @@ uint64_t image_backing_memory_device::get_modifier() const
return 0;
}
}
}

13
wsi/surface_properties.hpp
View file

@ -206,7 +206,9 @@ VkResult surface_properties_formats_helper(It begin, It end, uint32_t *surface_f
{
assert(surface_formats_count != nullptr);
const uint32_t supported_formats_count = std::distance(begin, end);
const auto distance = std::distance(begin, end);
assert(distance >= 0);
const auto supported_formats_count = static_cast<uint32_t>(distance);
if (surface_formats == nullptr && extended_surface_formats == nullptr)
{
*surface_formats_count = supported_formats_count;
@ -307,17 +309,20 @@ VkResult get_surface_present_modes_common(uint32_t *present_mode_count, VkPresen
assert(present_mode_count != nullptr);
assert(modes.size() <= UINT32_MAX);
const auto modes_count = static_cast<uint32_t>(modes.size());
if (nullptr == present_modes)
{
*present_mode_count = modes.size();
*present_mode_count = modes_count;
return VK_SUCCESS;
}
if (modes.size() > *present_mode_count)
if (modes_count > *present_mode_count)
{
res = VK_INCOMPLETE;
}
*present_mode_count = std::min(*present_mode_count, static_cast<uint32_t>(modes.size()));
*present_mode_count = std::min(*present_mode_count, modes_count);
for (uint32_t i = 0; i < *present_mode_count; ++i)
{
present_modes[i] = modes[i];

33
wsi/swapchain_base.cpp
View file

@ -285,7 +285,8 @@ VkResult swapchain_base::init(VkDevice device, const VkSwapchainCreateInfoKHR *s
}
}
if (VkResult result = m_free_image_semaphore.init(m_swapchain_images.size()); result != VK_SUCCESS)
if (VkResult result = m_free_image_semaphore.init(static_cast<uint32_t>(m_swapchain_images.size()));
result != VK_SUCCESS)
{
assert(result == VK_ERROR_OUT_OF_HOST_MEMORY);
return result;
@ -299,7 +300,7 @@ VkResult swapchain_base::init(VkDevice device, const VkSwapchainCreateInfoKHR *s
* Vulkan spec, vkGetDeviceQueue2 should be used to get queues
* that were created with non zero flags parameters.
*/
m_device_data.disp.GetDeviceQueue(m_device, 0, 0, &m_queue);
m_device_data.disp.GetDeviceQueue(m_device, 0u, 0u, &m_queue);
TRY_LOG_CALL(m_device_data.SetDeviceLoaderData(m_device, m_queue));
}
@ -416,24 +417,24 @@ VkResult swapchain_base::acquire_next_image(uint64_t timeout, VkSemaphore semaph
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
size_t i;
for (i = 0; i < m_swapchain_images.size(); ++i)
size_t image_index_candidate = 0;
for (; image_index_candidate < m_swapchain_images.size(); ++image_index_candidate)
{
if (m_swapchain_images[i].get_status() == swapchain_image::UNALLOCATED)
if (m_swapchain_images[image_index_candidate].get_status() == swapchain_image::UNALLOCATED)
{
TRY_LOG_CALL(allocate_and_bind_swapchain_image(m_swapchain_images[i]));
m_swapchain_images[i].set_status(swapchain_image::FREE);
TRY_LOG_CALL(allocate_and_bind_swapchain_image(m_swapchain_images[image_index_candidate]));
m_swapchain_images[image_index_candidate].set_status(swapchain_image::FREE);
}
if (m_swapchain_images[i].get_status() == swapchain_image::FREE)
if (m_swapchain_images[image_index_candidate].get_status() == swapchain_image::FREE)
{
m_swapchain_images[i].set_status(swapchain_image::ACQUIRED);
*image_index = i;
m_swapchain_images[image_index_candidate].set_status(swapchain_image::ACQUIRED);
*image_index = static_cast<uint32_t>(image_index_candidate);
break;
}
}
assert(i < m_swapchain_images.size());
assert(image_index_candidate < m_swapchain_images.size());
image_status_lock.unlock();
@ -490,7 +491,7 @@ VkResult swapchain_base::get_swapchain_images(uint32_t *swapchain_image_count, V
if (swapchain_images == nullptr)
{
/* Return the number of swapchain images. */
*swapchain_image_count = m_swapchain_images.size();
*swapchain_image_count = static_cast<uint32_t>(m_swapchain_images.size());
return VK_SUCCESS;
}
@ -508,7 +509,7 @@ VkResult swapchain_base::get_swapchain_images(uint32_t *swapchain_image_count, V
current_image++;
if (current_image == m_swapchain_images.size())
if (current_image == static_cast<uint32_t>(m_swapchain_images.size()))
{
*swapchain_image_count = current_image;
@ -660,11 +661,11 @@ VkResult swapchain_base::queue_present(VkQueue queue, const VkPresentInfoKHR *pr
{
VkSemaphore present_fence_wait_sem =
m_swapchain_images[submit_info.pending_present.image_index].get_present_fence_wait_semaphore();
const queue_submit_semaphores wait_semaphores = { &present_fence_wait_sem, 1, nullptr, 0 };
const queue_submit_semaphores present_fence_semaphores = { &present_fence_wait_sem, 1, nullptr, 0 };
/*
* Here we chain wait_semaphores with present_fence through present_fence_wait.
* Here we chain present_fence_semaphores with present_fence through present_fence_wait.
*/
TRY(sync_queue_submit(m_device_data, queue, submit_info.present_fence, wait_semaphores));
TRY(sync_queue_submit(m_device_data, queue, submit_info.present_fence, present_fence_semaphores));
}
#if VULKAN_WSI_LAYER_EXPERIMENTAL

8
wsi/synchronization.cpp
View file

@ -101,7 +101,7 @@ VkResult fence_sync::wait_payload(uint64_t timeout)
VkResult res = VK_SUCCESS;
if (has_payload && !payload_finished)
{
res = dev->disp.WaitForFences(dev->device, 1, &fence, VK_TRUE, timeout);
res = dev->disp.WaitForFences(dev->device, 1u, &fence, VK_TRUE, timeout);
if (res == VK_SUCCESS)
{
payload_finished = true;
@ -112,7 +112,7 @@ VkResult fence_sync::wait_payload(uint64_t timeout)
VkResult fence_sync::set_payload(VkQueue queue, const queue_submit_semaphores &semaphores, const void *submission_pnext)
{
VkResult result = dev->disp.ResetFences(dev->device, 1, &fence);
VkResult result = dev->disp.ResetFences(dev->device, 1u, &fence);
if (result != VK_SUCCESS)
{
return result;
@ -233,7 +233,7 @@ VkResult sync_queue_submit(const layer::device_private_data &device, VkQueue que
semaphores.signal_semaphores_count,
semaphores.signal_semaphores };
TRY(device.disp.QueueSubmit(queue, 1, &submit_info, fence));
TRY(device.disp.QueueSubmit(queue, 1u, &submit_info, fence));
return VK_SUCCESS;
}
@ -257,7 +257,7 @@ VkResult sync_queue_submit(const layer::device_private_data &device, VkQueue que
pipeline_stage_flags_vector.data(), command_buffer_data.m_command_buffer_count,
command_buffer_data.m_command_buffers, semaphores.signal_semaphores_count,
semaphores.signal_semaphores };
TRY(device.disp.QueueSubmit(queue, 1, &submit_info, fence));
TRY(device.disp.QueueSubmit(queue, 1u, &submit_info, fence));
return VK_SUCCESS;
}
} /* namespace wsi */

2
wsi/wayland/present_id_wayland.cpp
View file

@ -62,7 +62,7 @@ uint64_t wsi_ext_present_id_wayland::get_present_id_from_image_index(uint32_t im
}
auto feedback = m_pending_presents.find(
[image_index](const presentation_feedback &feedback) { return feedback.get_image_index() == image_index; });
[image_index](const presentation_feedback &candidate) { return candidate.get_image_index() == image_index; });
return feedback != nullptr ? feedback->get_present_id() : 0;
}

9
wsi/wayland/present_wait_wayland.cpp
View file

@ -73,10 +73,11 @@ VkResult wsi_ext_present_wait_wayland::wait_for_update(uint64_t present_id, uint
int delay_in_ms = 0;
if (timeout_in_ns != UINT64_MAX)
{
uint64_t min_delay_in_ns = std::min(static_cast<uint64_t>(5000000ULL /* 5ms */), timeout_in_ns);
timeout_in_ns -= min_delay_in_ns;
const uint64_t min_delay_in_ns = std::min(static_cast<uint64_t>(5000000ULL /* 5ms */), timeout_in_ns);
const uint64_t min_delay_in_ms = min_delay_in_ns / 1000000ULL;
delay_in_ms = std::min(static_cast<unsigned long long>(INT_MAX), min_delay_in_ns / 1000ULL / 1000UL);
timeout_in_ns -= min_delay_in_ns;
delay_in_ms = static_cast<int>(std::min<uint64_t>(min_delay_in_ms, static_cast<uint64_t>(INT_MAX)));
}
else
{
@ -99,4 +100,4 @@ VkResult wsi_ext_present_wait_wayland::wait_for_update(uint64_t present_id, uint
}
} /* namespace wayland */
} /* namespace wsi */
} /* namespace wsi */

1
wsi/wayland/present_wait_wayland.hpp
View file

@ -77,7 +77,6 @@ private:
*/
VkResult wait_for_update(uint64_t present_id, uint64_t timeout_in_ns) override;
private:
/**
* @brief Wayland display object.
*/

17
wsi/wayland/swapchain.cpp
View file

@ -341,8 +341,9 @@ wayland_owner<wl_buffer> swapchain::create_wl_buffer(image_backing_memory_extern
/* create a wl_buffer using the dma_buf protocol */
zwp_linux_buffer_params_v1 *params = zwp_linux_dmabuf_v1_create_params(m_wsi_surface->get_dmabuf_interface());
uint32_t modifier_hi = image_external_memory.get_image_create_info().selected_format.modifier >> 32;
uint32_t modifier_low = image_external_memory.get_image_create_info().selected_format.modifier & 0xFFFFFFFF;
const uint64_t modifier = image_external_memory.get_image_create_info().selected_format.modifier;
const auto modifier_hi = static_cast<uint32_t>(modifier >> 32);
const auto modifier_low = static_cast<uint32_t>(modifier & 0xFFFFFFFF);
for (uint32_t plane = 0; plane < ext_memory.get_num_planes(); plane++)
{
zwp_linux_buffer_params_v1_add(params, ext_memory.get_buffer_fds()[plane], plane, ext_memory.get_offsets()[plane],
@ -516,15 +517,9 @@ bool swapchain::free_image_found()
VkResult swapchain::get_free_buffer(uint64_t *timeout)
{
int ms_timeout, res;
if (*timeout >= INT_MAX * 1000llu * 1000llu)
{
ms_timeout = INT_MAX;
}
else
{
ms_timeout = *timeout / 1000llu / 1000llu;
}
const uint64_t timeout_ns = *timeout;
const uint64_t timeout_ms = timeout_ns / 1000000ULL;
ms_timeout = timeout_ms > static_cast<uint64_t>(INT_MAX) ? INT_MAX : static_cast<int>(timeout_ms);
/* The current dispatch_queue implementation will return if any
* events are returned, even if no events are dispatched to the buffer

2
wsi/wayland/wl_object_owner.hpp
View file

@ -108,7 +108,7 @@ static std::unique_ptr<T, std::function<void(T *)>> make_proxy_with_queue(T *obj
wl_proxy_set_queue(reinterpret_cast<wl_proxy *>(proxy), queue);
}
auto delete_proxy = [](T *proxy) { wl_proxy_wrapper_destroy(reinterpret_cast<wl_proxy *>(proxy)); };
auto delete_proxy = [](T *wrapped_proxy) { wl_proxy_wrapper_destroy(reinterpret_cast<wl_proxy *>(wrapped_proxy)); };
return std::unique_ptr<T, std::function<void(T *)>>(proxy, delete_proxy);
}

8
wsi/wayland/wp_presentation_feedback.cpp
View file

@ -45,13 +45,13 @@ wp_presentation_feedback_presented(void *data, struct wp_presentation_feedback *
if (feedback_obj->ext_present_timing() != nullptr)
{
uint64_t timestamp_seconds = (static_cast<uint64_t>(tv_sec_hi) << 32) | tv_sec_lo;
double timestamp_limit = static_cast<double>(UINT64_MAX - tv_nsec) / 1e9;
if (static_cast<double>(timestamp_seconds) > timestamp_limit)
const uint64_t seconds_limit = (UINT64_MAX - static_cast<uint64_t>(tv_nsec)) / 1000000000ULL;
if (timestamp_seconds > seconds_limit)
{
WSI_LOG_ERROR("timestamp_seconds overflow, capping to safe maximum");
timestamp_seconds = static_cast<uint64_t>(std::floor(timestamp_limit));
timestamp_seconds = seconds_limit;
}
uint64_t timestamp_ns = static_cast<uint64_t>(timestamp_seconds * 1e9) + tv_nsec;
const uint64_t timestamp_ns = (timestamp_seconds * 1000000000ULL) + static_cast<uint64_t>(tv_nsec);
feedback_obj->ext_present_timing()->mark_delivered(feedback_obj->get_image_index(), timestamp_ns);
}
else if (feedback_obj->ext_present_id() != nullptr)