fdo-mirrors/vulkan-wsi-layer
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/vulkan-wsi-layer.git synced 2026-01-06 07:10:14 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove duplication of create_aliased_image_handle implementations

Browse source 
Signed-off-by: Aron Virginas-Tar <aron.virginas-tar@arm.com>
Change-Id: I37043259e349874a9a7eb495a0e3b939c144798f
This commit is contained in:
Aron Virginas-Tar 2022-07-04 10:15:14 +01:00 • committed by Matteo Franchin
parent 36b640c468
commit e40628a135
7 changed files with 44 additions and 109 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
layer/swapchain_api.cpp
View file

@ -348,7 +348,7 @@ wsi_layer_vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, c
}
auto sc = reinterpret_cast<wsi::swapchain_base *>(image_sc_create_info->swapchain);
return sc->create_aliased_image_handle(pCreateInfo, pImage);
return sc->create_aliased_image_handle(pImage);
}
VWL_VKAPI_CALL(VkResult)

60
wsi/headless/swapchain.cpp
View file

@ -49,7 +49,9 @@ struct image_data
swapchain::swapchain(layer::device_private_data &dev_data, const VkAllocationCallbacks *pAllocator)
: wsi::swapchain_base(dev_data, pAllocator)
, m_image_create_info()
#if WSI_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN
, m_image_compression_control{}
#endif
{
}
@ -59,42 +61,6 @@ swapchain::~swapchain()
teardown();
}
#if WSI_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN
VkImageCompressionControlEXT swapchain::construct_image_compression_control()
{
VkImageCompressionControlEXT compression_control = {};
compression_control.sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
compression_control.compressionControlPlaneCount = m_image_compression_control.compression_control_plane_count;
compression_control.flags = m_image_compression_control.flags;
compression_control.pFixedRateFlags = m_image_compression_control.fixed_rate_flags.data();
return compression_control;
}
#endif
VkResult swapchain::create_aliased_image_handle(const VkImageCreateInfo *image_create_info, VkImage *image)
{
#if WSI_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN
VkImageCompressionControlEXT compression_control;
if (m_device_data.is_swapchain_compression_control_enabled())
{
compression_control = construct_image_compression_control();
compression_control.pNext = m_image_create_info.pNext;
m_image_create_info.pNext = &compression_control;
}
#endif
VkResult res = m_device_data.disp.CreateImage(m_device, &m_image_create_info, get_allocation_callbacks(), image);
#if WSI_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN
if (m_device_data.is_swapchain_compression_control_enabled())
{
/* Restore pNext pointer of m_image_create_info as compression_control will be garbage after this function exits */
m_image_create_info.pNext = compression_control.pNext;
}
#endif
return res;
}
VkResult swapchain::create_and_bind_swapchain_image(VkImageCreateInfo image_create, wsi::swapchain_image &image)
{
VkResult res = VK_SUCCESS;
@ -102,22 +68,20 @@ VkResult swapchain::create_and_bind_swapchain_image(VkImageCreateInfo image_crea
m_image_create_info = image_create;
#if WSI_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN
VkImageCompressionControlEXT compression_control;
if (m_device_data.is_swapchain_compression_control_enabled())
{
compression_control = construct_image_compression_control();
compression_control.pNext = m_image_create_info.pNext;
m_image_create_info.pNext = &compression_control;
/* Initialize compression control */
m_image_compression_control.sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
m_image_compression_control.compressionControlPlaneCount =
m_image_compression_control_params.compression_control_plane_count;
m_image_compression_control.flags = m_image_compression_control_params.flags;
m_image_compression_control.pFixedRateFlags = m_image_compression_control_params.fixed_rate_flags.data();
m_image_compression_control.pNext = m_image_create_info.pNext;
m_image_create_info.pNext = &m_image_compression_control;
}
#endif
res = m_device_data.disp.CreateImage(m_device, &m_image_create_info, get_allocation_callbacks(), &image.image);
#if WSI_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN
if (m_device_data.is_swapchain_compression_control_enabled())
{
/* Restore pNext pointer of m_image_create_info as compression_control will be garbage after this function exits */
m_image_create_info.pNext = compression_control.pNext;
}
#endif
if (res != VK_SUCCESS)
{
return res;

19
wsi/headless/swapchain.hpp
View file

@ -63,18 +63,6 @@ protected:
return VK_SUCCESS;
};
/**
* @brief Creates a VkImage handle.
*
* @param image_create_info Data to be used to create the image.
* @param[out] image Handle to the image.
*
* @return If image creation is successful returns VK_SUCCESS, otherwise
* will return VK_ERROR_OUT_OF_DEVICE_MEMORY or VK_ERROR_OUT_OF_HOST_MEMORY
* depending on the error that occured.
*/
VkResult create_aliased_image_handle(const VkImageCreateInfo *image_create_info, VkImage *image) override;
/**
* @brief Creates and binds a new swapchain image.
*
@ -123,13 +111,8 @@ protected:
private:
#if WSI_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN
VkImageCompressionControlEXT construct_image_compression_control();
VkImageCompressionControlEXT m_image_compression_control;
#endif
/**
* @brief Image creation info used for all swapchain images.
*/
VkImageCreateInfo m_image_create_info;
};
} /* namespace headless */

15
wsi/swapchain_base.cpp
View file

@ -186,8 +186,9 @@ swapchain_base::swapchain_base(layer::device_private_data &dev_data, const VkAll
, m_device(VK_NULL_HANDLE)
, m_queue(VK_NULL_HANDLE)
#if WSI_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN
, m_image_compression_control({VK_IMAGE_COMPRESSION_DEFAULT_EXT, 0})
, m_image_compression_control_params({VK_IMAGE_COMPRESSION_DEFAULT_EXT, 0})
#endif
, m_image_create_info()
, m_image_acquire_lock()
, m_error_state(VK_NOT_READY)
, m_started_presenting(false)
@ -210,11 +211,12 @@ VkResult swapchain_base::init(VkDevice device, const VkSwapchainCreateInfoKHR *s
VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, swapchain_create_info->pNext);
if (m_device_data.is_swapchain_compression_control_enabled() && image_compression_control != nullptr)
{
m_image_compression_control.compression_control_plane_count = image_compression_control->compressionControlPlaneCount;
m_image_compression_control.flags = image_compression_control->flags;
m_image_compression_control_params.compression_control_plane_count =
image_compression_control->compressionControlPlaneCount;
m_image_compression_control_params.flags = image_compression_control->flags;
for (uint32_t i = 0; i < image_compression_control->compressionControlPlaneCount; i++)
{
m_image_compression_control.fixed_rate_flags[i] = image_compression_control->pFixedRateFlags[i];
m_image_compression_control_params.fixed_rate_flags[i] = image_compression_control->pFixedRateFlags[i];
}
}
#endif
@ -537,6 +539,11 @@ VkResult swapchain_base::get_swapchain_images(uint32_t *swapchain_image_count, V
}
}
VkResult swapchain_base::create_aliased_image_handle(VkImage *image)
{
return m_device_data.disp.CreateImage(m_device, &m_image_create_info, get_allocation_callbacks(), image);
}
VkResult swapchain_base::notify_presentation_engine(uint32_t image_index)
{
const std::lock_guard<std::recursive_mutex> lock(m_image_status_mutex);

15
wsi/swapchain_base.hpp
View file

@ -67,7 +67,7 @@ struct swapchain_image
constexpr uint32_t MAX_PLANES = 4;
#if WSI_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN
struct image_compression_control
struct image_compression_control_params
{
VkImageCompressionFlagsEXT flags;
uint32_t compression_control_plane_count;
@ -165,16 +165,16 @@ public:
*
* It is used to bind images to memory from the swapchain. It is called if a
* VkImageSwapchainCreateInfoKHR struct has been provided in the vkCreateImage
* function.
* function. All images created by the swapchain will use the same VkImageCreateInfo,
* initialized in create_and_bind_swapchain_image().
*
* @param image_create_info Data to be used to create the image.
* @param[out] image Handle to the image.
*
* @return If image creation is successful returns VK_SUCCESS, otherwise
* will return VK_ERROR_OUT_OF_DEVICE_MEMORY or VK_ERROR_OUT_OF_HOST_MEMORY
* depending on the error that occured.
*/
virtual VkResult create_aliased_image_handle(const VkImageCreateInfo *image_create_info, VkImage *image) = 0;
VkResult create_aliased_image_handle(VkImage *image);
/**
* @brief Bind image to a swapchain
@ -312,9 +312,14 @@ protected:
* @brief Describes the image compression the swapchain will use
*
*/
image_compression_control m_image_compression_control;
image_compression_control_params m_image_compression_control_params;
#endif
/**
* @brief Image creation info used for all swapchain images.
*/
VkImageCreateInfo m_image_create_info;
/**
* @brief Return the VkAllocationCallbacks passed in this object constructor.
*/

20
wsi/wayland/swapchain.cpp
View file

@ -79,9 +79,9 @@ swapchain::swapchain(layer::device_private_data &dev_data, const VkAllocationCal
, m_wsi_surface(&wsi_surface)
, m_buffer_queue(nullptr)
, m_wsi_allocator(nullptr)
, m_image_creation_parameters({}, {}, m_allocator, {}, {})
, m_image_creation_parameters({}, m_allocator, {}, {})
{
m_image_creation_parameters.m_image_create_info.format = VK_FORMAT_UNDEFINED;
m_image_create_info.format = VK_FORMAT_UNDEFINED;
}
swapchain::~swapchain()
@ -294,9 +294,10 @@ VkResult swapchain::get_surface_compatible_formats(const VkImageCreateInfo &info
#if WSI_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN
VkImageCompressionControlEXT compression_control = {};
compression_control.sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
compression_control.flags = m_image_compression_control.flags;
compression_control.compressionControlPlaneCount = m_image_compression_control.compression_control_plane_count;
compression_control.pFixedRateFlags = m_image_compression_control.fixed_rate_flags.data();
compression_control.flags = m_image_compression_control_params.flags;
compression_control.compressionControlPlaneCount =
m_image_compression_control_params.compression_control_plane_count;
compression_control.pFixedRateFlags = m_image_compression_control_params.fixed_rate_flags.data();
if (m_device_data.is_swapchain_compression_control_enabled())
{
@ -352,12 +353,6 @@ VkResult swapchain::get_surface_compatible_formats(const VkImageCreateInfo &info
return VK_SUCCESS;
}
VkResult swapchain::create_aliased_image_handle(const VkImageCreateInfo *image_create_info, VkImage *image)
{
return m_device_data.disp.CreateImage(m_device, &m_image_creation_parameters.m_image_create_info,
get_allocation_callbacks(), image);
}
VkResult swapchain::allocate_wsialloc(VkImageCreateInfo &image_create_info, wayland_image_data &image_data,
util::vector<wsialloc_format> &importable_formats,
wsialloc_format *allocated_format)
@ -366,7 +361,7 @@ VkResult swapchain::allocate_wsialloc(VkImageCreateInfo &image_create_info, wayl
uint64_t allocation_flags = is_protected_memory ? WSIALLOC_ALLOCATE_PROTECTED : 0;
#if WSI_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN
if (m_image_compression_control.flags & VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT)
if (m_image_compression_control_params.flags & VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT)
{
allocation_flags |= WSIALLOC_ALLOCATE_HIGHEST_FIXED_RATE_COMPRESSION;
}
@ -402,7 +397,6 @@ VkResult swapchain::allocate_image(VkImageCreateInfo &image_create_info, wayland
bool is_disjoint = false;
util::vector<wsialloc_format> importable_formats(util::allocator(m_allocator, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND));
auto &m_image_create_info = m_image_creation_parameters.m_image_create_info;
auto &m_allocated_format = m_image_creation_parameters.m_allocated_format;
if (m_image_create_info.format != VK_FORMAT_UNDEFINED)
{

22
wsi/wayland/swapchain.hpp
View file

@ -45,17 +45,15 @@ namespace wayland
struct image_creation_parameters
{
VkImageCreateInfo m_image_create_info;
wsialloc_format m_allocated_format;
util::vector<VkSubresourceLayout> m_image_layout;
VkExternalMemoryImageCreateInfoKHR m_external_info;
VkImageDrmFormatModifierExplicitCreateInfoEXT m_drm_mod_info;
image_creation_parameters(VkImageCreateInfo image_create_info, wsialloc_format allocated_format,
image_creation_parameters(wsialloc_format allocated_format,
util::allocator allocator, VkExternalMemoryImageCreateInfoKHR external_info,
VkImageDrmFormatModifierExplicitCreateInfoEXT drm_mod_info)
: m_image_create_info(image_create_info)
, m_allocated_format(allocated_format)
: m_allocated_format(allocated_format)
, m_image_layout(allocator)
, m_external_info(external_info)
, m_drm_mod_info(drm_mod_info)
@ -81,22 +79,6 @@ protected:
VkResult init_platform(VkDevice device, const VkSwapchainCreateInfoKHR *swapchain_create_info,
bool &use_presentation_thread) override;
/**
* @brief Creates a VkImage handle.
*
* The image_create_info argument is ignored in favour of m_image_create_info. This is because in
* order to guarantee a VkImage can be bound to any swapchain index, all swapchain images must
* be created with the same creation parameters.
*
* @param image_create_info Data to be used to create the image.
* @param[out] image Handle to the image.
*
* @return If image creation is successful returns VK_SUCCESS, otherwise
* will return VK_ERROR_OUT_OF_DEVICE_MEMORY or VK_ERROR_OUT_OF_HOST_MEMORY
* depending on the error that occured.
*/
VkResult create_aliased_image_handle(const VkImageCreateInfo *image_create_info, VkImage *image) override;
/**
* @brief Creates and binds a new swapchain image.
*