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

VK_KHR_display surface_properties implementation

Browse source 
Implementation of the surface_properties interface for VK_KHR_display.

Signed-off-by: Dennis Wildmark <dennis.wildmark@arm.com>
Change-Id: Idd3b53bec0d0a829478d51b4263db767c872d0e5
This commit is contained in:
Dennis Wildmark 2024-01-31 12:48:32 +01:00
parent 2837bab5c4
commit 19cd4376d1
10 changed files with 1228 additions and 13 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
CMakeLists.txt
View file

@ -1,4 +1,4 @@
# Copyright (c) 2019-2022 Arm Limited.
# Copyright (c) 2019-2024 Arm Limited.
#
# SPDX-License-Identifier: MIT
#
@ -56,6 +56,7 @@ endif()
# Build Configuration options
option(BUILD_WSI_HEADLESS "Build with support for VK_EXT_headless_surface" ON)
option(BUILD_WSI_WAYLAND "Build with support for VK_KHR_wayland_surface" OFF)
option(BUILD_WSI_DISPLAY "Build with support for VK_KHR_display" OFF)
option(BUILD_WSI_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN "Build with support for VK_EXT_image_compression_control_swapchain" OFF)
set(SELECT_EXTERNAL_ALLOCATOR "none" CACHE STRING "Select an external system allocator (none, ion)")
set(EXTERNAL_WSIALLOC_LIBRARY "" CACHE STRING "External implementation of the wsialloc interface to use")
@ -67,6 +68,10 @@ if(BUILD_WSI_WAYLAND)
endif()
endif()
if(BUILD_WSI_DISPLAY)
set(BUILD_DRM_UTILS true)
endif()
if(BUILD_DRM_UTILS)
add_library(drm_utils STATIC util/drm/drm_utils.cpp)
@ -182,6 +187,32 @@ else()
list(APPEND JSON_COMMANDS COMMAND sed -i '/VK_EXT_headless_surface/d' ${CMAKE_CURRENT_BINARY_DIR}/VkLayer_window_system_integration.json)
endif()
# Display
if (BUILD_WSI_DISPLAY)
add_library(wsi_display STATIC
wsi/display/drm_display.cpp
wsi/display/surface_properties.cpp)
pkg_check_modules(LIBDRM REQUIRED libdrm)
message(STATUS "Using libdrm include directories: ${LIBDRM_INCLUDE_DIRS}")
message(STATUS "Using libdrm ldflags: ${LIBDRM_LDFLAGS}")
target_include_directories(wsi_display PRIVATE
${PROJECT_SOURCE_DIR}
${VULKAN_CXX_INCLUDE}
${CMAKE_CURRENT_BINARY_DIR})
target_include_directories(wsi_display PUBLIC
${LIBDRM_INCLUDE_DIRS})
target_compile_options(wsi_display INTERFACE "-DBUILD_WSI_DISPLAY=1")
target_link_libraries(wsi_display ${LIBDRM_LDFLAGS} drm)
target_link_libraries(wsi_display drm_utils)
list(APPEND LINK_WSI_LIBS wsi_display)
else()
list(APPEND JSON_COMMANDS COMMAND sed -i '/VK_KHR_display/d' ${CMAKE_CURRENT_BINARY_DIR}/VkLayer_window_system_integration.json)
endif()
# Layer
add_library(${PROJECT_NAME} SHARED
layer/layer.cpp

1
layer/VkLayer_window_system_integration.json
View file

@ -14,6 +14,7 @@
{"name" : "VK_EXT_headless_surface", "spec_version" : "1"},
{"name" : "VK_KHR_wayland_surface", "spec_version" : "6"},
{"name" : "VK_KHR_surface", "spec_version" : "25"},
{"name" : "VK_KHR_display", "spec_version" : "23"},
{"name" : "VK_KHR_get_surface_capabilities2", "spec_version" : "1"}
],
"device_extensions": [

11
util/file_descriptor.hpp
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2021 Arm Limited.
* Copyright (c) 2021, 2024 Arm Limited.
*
* SPDX-License-Identifier: MIT
*
@ -44,10 +44,9 @@ namespace util
class fd_owner : private noncopyable
{
public:
fd_owner() = default;
fd_owner(int fd)
: fd_handle{ fd }
: fd_handle{ fd }
{
}
@ -70,14 +69,14 @@ public:
}
}
int get()
int get() const
{
return fd_handle;
}
bool is_valid()
bool is_valid() const
{
return fd_handle >= 0;
return fd_handle >= 0;
}
private:

7
util/macros.hpp
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2021, 2023 Arm Limited.
* Copyright (c) 2021, 2023-2024 Arm Limited.
*
* SPDX-License-Identifier: MIT
*
@ -51,4 +51,7 @@
#define VWL_VKAPI_EXPORT __attribute__((visibility("default")))
#else
#define VWL_VKAPI_EXPORT
#endif
#endif
/* Unused parameter macro */
#define UNUSED(x) ((void)(x))

300
wsi/display/drm_display.cpp Normal file
View file

@ -0,0 +1,300 @@
/*
* Copyright (c) 2024 Arm Limited.
*
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include "drm_display.hpp"
#include "util/custom_allocator.hpp"
#include <cstdlib>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <assert.h>
namespace wsi
{
namespace display
{
drm_display::drm_display(util::fd_owner drm_fd, int crtc_id, drm_connector_owner drm_connector,
util::unique_ptr<drm_display_mode> display_modes, size_t num_display_modes, uint32_t max_width,
uint32_t max_height)
: m_drm_fd(std::move(drm_fd))
, m_crtc_id(crtc_id)
, m_drm_connector(std::move(drm_connector))
, m_display_modes(std::move(display_modes))
, m_num_display_modes(num_display_modes)
, m_max_width(max_width)
, m_max_height(max_height)
{
for (size_t i = 0; i < num_display_modes; i++)
{
m_display_modes.get()[i].set_display(this);
}
}
drm_display::~drm_display()
{
if (m_drm_fd.is_valid())
{
/* Finish using the DRM device. */
drmDropMaster(m_drm_fd.get());
}
}
/**
* @brief Utility function to find a compatible CRTC to drive this display's connector.
*
* @return An integer < 0 on failure, otherwise a valid CRTC id.
*/
static int find_compatible_crtc(int fd, drm_resources_owner &resources, drm_connector_owner &connector)
{
assert(resources);
assert(connector);
for (int i = 0; i < connector->count_encoders; i++)
{
drm_encoder_owner encoder{ drmModeGetEncoder(fd, connector->encoders[i]) };
if (!encoder)
{
/* Cannot find an encoder, ignore this one. */
continue;
}
/* Iterate over all global CRTCs. */
for (int j = 0; j < resources->count_crtcs; j++)
{
/* Is this encoder compatible with the CRTC? */
if (!(encoder->possible_crtcs & (1 << j)))
{
/* Encoder not compatible, so skip this CRTC. */
continue;
}
/* 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];
}
}
WSI_LOG_WARNING("Failed to find compatible CRTC.");
return -ENODEV;
}
std::optional<util::unique_ptr<drm_display>> drm_display::make_display(const util::allocator &allocator,
const char *drm_device)
{
util::fd_owner drm_fd{ open(drm_device, O_RDWR | O_CLOEXEC, 0) };
if (!drm_fd.is_valid())
{
WSI_LOG_ERROR("Failed to open DRM device %s.", drm_device);
return std::nullopt;
}
/* Get the DRM master permission so that mode can be set on the drm device later. */
if (!drmIsMaster(drm_fd.get()))
{
if (drmSetMaster(drm_fd.get()) != 0)
{
WSI_LOG_ERROR("Failed to set DRM master.");
return std::nullopt;
}
}
drm_resources_owner resources{ drmModeGetResources(drm_fd.get()) };
if (resources == nullptr)
{
WSI_LOG_ERROR("Failed to get DRM resources.");
return std::nullopt;
}
drm_connector_owner connector{ nullptr };
int crtc_id = -1;
for (int i = 0; i < resources->count_connectors; ++i)
{
drm_connector_owner temp_connector{ drmModeGetConnector(drm_fd.get(), resources->connectors[i]) };
if (temp_connector != nullptr && temp_connector->connection == DRM_MODE_CONNECTED)
{
crtc_id = find_compatible_crtc(drm_fd.get(), resources, temp_connector);
if (crtc_id >= 0)
{
connector = std::move(temp_connector);
break;
}
}
}
if (connector == nullptr)
{
WSI_LOG_ERROR("Failed to find connector for DRM device.");
return std::nullopt;
}
uint32_t max_width = 0;
uint32_t max_height = 0;
util::vector<drm_display_mode> display_modes{ allocator };
for (int j = 0; j < connector->count_modes; ++j)
{
/* Need the full drmModeModeInfo cached to supply to drmModeSetCrtc. */
drm_display_mode mode{};
mode.set_drm_mode(connector->modes[j]);
mode.set_preferred(connector->modes[j].type == DRM_MODE_TYPE_PREFERRED);
uint32_t resolution = static_cast<uint32_t>(mode.get_width()) * static_cast<uint32_t>(mode.get_height());
if (resolution >= max_width * max_height)
{
max_width = mode.get_width();
max_height = mode.get_height();
}
if (!display_modes.try_push_back(mode))
{
WSI_LOG_ERROR("Failed to allocate memory for display mode.");
return std::nullopt;
}
}
util::unique_ptr<drm_display_mode> display_modes_mem{ allocator.create<drm_display_mode>(display_modes.size()) };
if (display_modes_mem == nullptr)
{
WSI_LOG_ERROR("Failed to allocate memory for display mode vector.");
return std::nullopt;
}
std::copy(display_modes.begin(), display_modes.end(), display_modes_mem.get());
auto display =
allocator.make_unique<drm_display>(std::move(drm_fd), crtc_id, std::move(connector), std::move(display_modes_mem),
display_modes.size(), max_width, max_height);
if (display == nullptr)
{
WSI_LOG_ERROR("Failed to allocate memory for display object.");
return std::nullopt;
}
return display;
}
drm_display_mode::drm_display_mode()
: m_display(nullptr)
, m_drm_mode_info{}
, m_preferred(false)
{
}
uint16_t drm_display_mode::get_width() const
{
return m_drm_mode_info.hdisplay;
}
uint16_t drm_display_mode::get_height() const
{
return m_drm_mode_info.vdisplay;
}
uint32_t drm_display_mode::get_refresh_rate() const
{
/* DRM provides refresh rate in Hz and vulkan expects mHz */
return m_drm_mode_info.vrefresh * 1000;
}
void drm_display_mode::set_display(const drm_display *disp)
{
m_display = disp;
}
const drm_display *drm_display_mode::get_display()
{
return m_display;
}
drmModeModeInfo drm_display_mode::get_drm_mode() const
{
return m_drm_mode_info;
}
void drm_display_mode::set_drm_mode(drmModeModeInfo mode)
{
m_drm_mode_info = mode;
}
bool drm_display_mode::is_preferred() const
{
return m_preferred;
}
void drm_display_mode::set_preferred(bool preferred)
{
m_preferred = preferred;
}
drm_display_mode *drm_display::get_display_modes_begin() const
{
return m_display_modes.get();
}
drm_display_mode *drm_display::get_display_modes_end() const
{
return m_display_modes.get() + m_num_display_modes;
}
size_t drm_display::get_num_display_modes() const
{
return m_num_display_modes;
}
int drm_display::get_drm_fd() const
{
return m_drm_fd.get();
}
uint32_t drm_display::get_connector_id() const
{
return m_drm_connector->connector_id;
}
int drm_display::get_crtc_id() const
{
return m_crtc_id;
}
drmModeConnector *drm_display::get_connector() const
{
return m_drm_connector.get();
}
uint32_t drm_display::get_max_width() const
{
return m_max_width;
}
uint32_t drm_display::get_max_height() const
{
return m_max_height;
}
} /* namespace display */
} /* namespace wsi */

296
wsi/display/drm_display.hpp Normal file
View file

@ -0,0 +1,296 @@
/*
* Copyright (c) 2024 Arm Limited.
*
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#pragma once
#include <vulkan/vulkan.h>
#include <xf86drmMode.h>
#include <xf86drm.h>
#include <optional>
#include "util/custom_allocator.hpp"
#include "util/file_descriptor.hpp"
namespace wsi
{
namespace display
{
/* Owner types for DRM API objects */
template <typename T, void (*drm_object_free)(T *)>
struct drm_deleter
{
void operator()(T *object)
{
if (object != nullptr)
{
drm_object_free(object);
}
}
};
template <typename T, void (*drm_object_free)(T *)>
using drm_owner = std::unique_ptr<T, drm_deleter<T, drm_object_free>>;
using drm_resources_owner = drm_owner<_drmModeRes, drmModeFreeResources>;
using drm_connector_owner = drm_owner<_drmModeConnector, drmModeFreeConnector>;
using drm_encoder_owner = drm_owner<_drmModeEncoder, drmModeFreeEncoder>;
using drm_plane_owner = drm_owner<_drmModePlane, drmModeFreePlane>;
using drm_plane_resources_owner = drm_owner<_drmModePlaneRes, drmModeFreePlaneResources>;
using drm_object_properties_owner = drm_owner<_drmModeObjectProperties, drmModeFreeObjectProperties>;
using drm_property_owner = drm_owner<_drmModeProperty, drmModeFreeProperty>;
/* Forward declaration */
class drm_display;
/**
* @brief The display mode object.
* The drm_display_mode class stores information
* about a drm mode.
*/
class drm_display_mode
{
public:
/**
* @brief drm_display_mode default constructor.
*/
drm_display_mode();
/**
* @brief Get the width of the display mode.
*
* @return Width of the display mode.
*/
uint16_t get_width() const;
/**
* @brief Get the height of the display mode.
*
* @return Height of the display mode.
*/
uint16_t get_height() const;
/**
* @brief Get the display mode refresh rate.
*
* @return Refresh rate of the display mode.
*/
uint32_t get_refresh_rate() const;
/**
* @brief get function for display instance.
*
* @return The display instance.
*/
const drm_display *get_display();
/**
* @brief Sets the display instance.
*
* @param disp The display instance.
*/
void set_display(const drm_display *disp);
/**
* @brief Get function for the drm mode.
*/
drmModeModeInfo get_drm_mode() const;
/**
* @brief Sets the drm mode info.
*
* @param mode The drm mode.
*/
void set_drm_mode(drmModeModeInfo mode);
/**
* @brief Check if this mode is the preferred mode for the connector.
*
* @return true if the mode is the preferred mode, otherwise false.
*/
bool is_preferred() const;
/**
* @brief Set the preferred state.
*
* @param preferred The state to set.
*/
void set_preferred(bool preferred);
private:
/**
* @brief the display instance.
*/
const drm_display *m_display;
/**
* @brief Cached native drm mode.
*/
drmModeModeInfo m_drm_mode_info;
/**
* @brief Flag for the preferred display mode.
*/
bool m_preferred = false;
};
/**
* @brief The vulkan's display object.
* The display class wraps a VkDisplayKHR.
*/
class drm_display
{
public:
/**
* @brief Construct and initialize a display object.
*
* @param allocator The allocator object that the display will use.
* @return std::optional<drm_display> containing a display if initialization went well, otherwise std::nullopt.
*/
static std::optional<util::unique_ptr<drm_display>> make_display(const util::allocator &allocator,
const char *drm_device);
/**
* @brief display destructor.
*/
~drm_display();
/**
* @brief Get the display modes begin pointer.
*
* @return drm_display_mode* pointer to the first display mode.
*/
drm_display_mode *get_display_modes_begin() const;
/**
* @brief Get the display modes end pointer.
*
* @return drm_display_mode* pointer past the last display mode.
*/
drm_display_mode *get_display_modes_end() const;
/**
* @brief Get number of display modes.
*
* @return const size_t number of display modes.
*/
size_t get_num_display_modes() const;
/**
* @brief Get function for drm device file descriptor.
*
* @return The display device file descriptor.
*/
int get_drm_fd() const;
/**
* @brief Get function for the connector id.
*
* @return The connector id.
*/
uint32_t get_connector_id() const;
/**
* @brief Get connector corresponding to the current connector id.
*
* @return The connector.
*/
drmModeConnector *get_connector() const;
/**
* @brief Get drm resources.
*
* @return The drm resources pointer.
*/
drmModeResPtr get_drm_resources() const;
/**
* @brief Returns a CRTC compatible with this display's connector.
*
* @return The CRTC id.
*/
int get_crtc_id() const;
/**
* @brief Get the max width of the display in pixels.
*/
uint32_t get_max_width() const;
/**
* @brief Get the max height of the display in pixels.
*/
uint32_t get_max_height() const;
private:
/* Allow util::allocator to access the private constructor */
friend class util::allocator;
/**
* @brief display constructor.
*
* @param allocator The allocator that the display will use.
*/
drm_display(util::fd_owner drm_fd, int crtc_id, drm_connector_owner drm_connector,
util::unique_ptr<drm_display_mode> display_modes, size_t num_display_modes, uint32_t max_width,
uint32_t max_height);
/**
* @brief File descriptor for the display device.
*/
util::fd_owner m_drm_fd;
/**
* @brief Id of CRTC compatible with the chosen connector.
*/
int m_crtc_id;
/**
* @brief Handle to the drm connector.
*/
drm_connector_owner m_drm_connector;
/**
* @brief Pointer to available display modes for the connected display.
*/
util::unique_ptr<drm_display_mode> m_display_modes;
/**
* @brief Number of available display modes in @ref m_display_modes.
*/
size_t m_num_display_modes;
/**
* @brief Maximum display resolution width.
*/
uint32_t m_max_width;
/**
* @brief Maximum display resolution height.
*/
uint32_t m_max_height;
};
} /* namespace display */
} /* namespace wsi */

509
wsi/display/surface_properties.cpp Normal file
View file

@ -0,0 +1,509 @@
/*
* Copyright (c) 2024 Arm Limited.
*
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <cstring>
#include <algorithm>
#include "surface_properties.hpp"
#include "util/macros.hpp"
namespace wsi
{
namespace display
{
constexpr int max_core_1_0_formats = VK_FORMAT_ASTC_12x12_SRGB_BLOCK + 1;
VkResult surface_properties::get_surface_capabilities(VkPhysicalDevice physical_device,
VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
{
get_surface_capabilities_common(physical_device, pSurfaceCapabilities);
/* Image count limits */
pSurfaceCapabilities->minImageCount = 2;
pSurfaceCapabilities->maxImageCount = 3;
/* Composite alpha */
pSurfaceCapabilities->supportedCompositeAlpha =
static_cast<VkCompositeAlphaFlagBitsKHR>(VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR | VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR);
return VK_SUCCESS;
}
VkResult surface_properties::get_surface_formats(VkPhysicalDevice physical_device, uint32_t *surfaceFormatCount,
VkSurfaceFormatKHR *surfaceFormats,
VkSurfaceFormat2KHR *extended_surface_formats)
{
int drm_fd = display->get_drm_fd();
if (drm_fd == -1)
{
return VK_ERROR_SURFACE_LOST_KHR;
}
/* Allow userspace to query native primary plane information */
if (drmSetClientCap(drm_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1) != 0)
{
return VK_ERROR_SURFACE_LOST_KHR;
}
drm_plane_resources_owner plane_res{ drmModeGetPlaneResources(drm_fd) };
if (plane_res == nullptr || plane_res->count_planes == 0)
{
return VK_ERROR_SURFACE_LOST_KHR;
}
/* Look for the primary plane */
drm_plane_owner plane{ nullptr };
for (uint32_t i = 0; i < plane_res->count_planes; i++)
{
drm_plane_owner temp_plane{ drmModeGetPlane(drm_fd, plane_res->planes[i]) };
if (temp_plane != nullptr)
{
drm_object_properties_owner props{ drmModeObjectGetProperties(drm_fd, plane_res->planes[i],
DRM_MODE_OBJECT_PLANE) };
if (props != nullptr)
{
auto props_end = props->props + props->count_props;
auto prop = std::find_if(props->props, props_end, [drm_fd](auto &property_id) {
drm_property_owner prop{ drmModeGetProperty(drm_fd, property_id) };
if (prop != nullptr && !strcmp(prop->name, "type"))
{
return true;
}
return false;
});
if (prop != props_end)
{
auto index = std::distance(props->props, prop);
if (props->prop_values[index] == DRM_PLANE_TYPE_PRIMARY)
{
plane = std::move(temp_plane);
break;
}
}
}
}
}
if (plane == nullptr)
{
WSI_LOG_ERROR("Failed to find primary plane.");
return VK_ERROR_SURFACE_LOST_KHR;
}
uint32_t format_count = 0;
/* If this happens, it is just wrong */
assert(plane->count_formats > 0);
assert(plane->count_formats <= max_core_1_0_formats);
std::array<surface_format_properties, max_core_1_0_formats> formats{};
for (uint32_t i = 0; i < plane->count_formats; ++i)
{
auto vk_format = util::drm::drm_to_vk_format(plane->formats[i]);
if (VK_FORMAT_UNDEFINED != vk_format)
{
formats[format_count] = surface_format_properties{ vk_format };
VkPhysicalDeviceImageFormatInfo2KHR format_info = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
nullptr,
vk_format,
VK_IMAGE_TYPE_2D,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
0 };
VkResult res = formats[format_count].check_device_support(physical_device, format_info);
if (VK_SUCCESS == res)
{
#if WSI_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN
if (layer::instance_private_data::get(physical_device).has_image_compression_support(physical_device))
{
formats[format_count].add_device_compression_support(physical_device, format_info);
}
#endif
format_count++;
}
}
/* Certain 8-bit UNORM formats can be interpreted as both UNORM and sRGB by Vulkan, so expose both formats.
* The colorSpace value is how the presentation engine interprets the format.
* The linearity of VkFormat and the display format may be different.
*/
auto vk_srgb_format = util::drm::drm_to_vk_srgb_format(plane->formats[i]);
if (VK_FORMAT_UNDEFINED != vk_srgb_format)
{
formats[format_count] = surface_format_properties{ vk_srgb_format };
VkPhysicalDeviceImageFormatInfo2KHR format_info = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
nullptr,
vk_format,
VK_IMAGE_TYPE_2D,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
0 };
VkResult res = formats[format_count].check_device_support(physical_device, format_info);
if (VK_SUCCESS == res)
{
#if WSI_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN
if (layer::instance_private_data::get(physical_device).has_image_compression_support(physical_device))
{
formats[format_count].add_device_compression_support(physical_device, format_info);
}
#endif
format_count++;
}
}
}
return surface_properties_formats_helper(formats.begin(), formats.begin() + format_count, surfaceFormatCount,
surfaceFormats, extended_surface_formats);
}
VkResult surface_properties::get_surface_present_modes(VkPhysicalDevice physical_device, VkSurfaceKHR surface,
uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
{
UNUSED(physical_device);
UNUSED(surface);
static const std::array<VkPresentModeKHR, 1> modes = { VK_PRESENT_MODE_FIFO_KHR };
return get_surface_present_modes_common(pPresentModeCount, pPresentModes, modes);
}
VWL_VKAPI_CALL(VkResult)
CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator,
VkDisplayModeKHR *pMode)
{
UNUSED(physicalDevice);
UNUSED(pAllocator);
assert(display != VK_NULL_HANDLE);
assert(pMode != nullptr);
assert(pCreateInfo != nullptr);
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR);
assert(pCreateInfo->pNext == NULL);
assert(pCreateInfo->flags == 0);
drm_display *dpy = reinterpret_cast<drm_display *>(display);
const VkDisplayModeParametersKHR *params = &pCreateInfo->parameters;
if (params->visibleRegion.width == 0 || params->visibleRegion.height == 0 || params->refreshRate == 0)
{
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;
});
if (mode != dpy->get_display_modes_end())
{
*pMode = reinterpret_cast<VkDisplayModeKHR>(mode);
return VK_SUCCESS;
}
return VK_ERROR_INITIALIZATION_FAILED;
}
VWL_VKAPI_CALL(VkResult)
CreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
{
UNUSED(instance);
UNUSED(pCreateInfo);
UNUSED(pAllocator);
UNUSED(pSurface);
// TODO: Create the surface object here, which in turn creates the surface_properties object
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
VWL_VKAPI_CALL(VkResult)
GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount,
VkDisplayModePropertiesKHR *pProperties)
{
UNUSED(physicalDevice);
assert(display != VK_NULL_HANDLE);
assert(pPropertyCount != nullptr);
drm_display *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() };
if (pProperties == nullptr)
{
*pPropertyCount = num_modes;
return VK_SUCCESS;
}
uint32_t nr_properties = std::min(*pPropertyCount, static_cast<uint32_t>(num_modes));
*pPropertyCount = 0;
std::for_each(modes, modes + nr_properties, [&pProperties, &pPropertyCount](auto &mode) {
VkDisplayModePropertiesKHR properties = {};
VkDisplayModeKHR display_mode = reinterpret_cast<VkDisplayModeKHR>(&mode);
properties.displayMode = display_mode;
VkDisplayModeParametersKHR parameters{};
parameters.visibleRegion = { mode.get_width(), mode.get_height() };
parameters.refreshRate = mode.get_refresh_rate();
properties.parameters = parameters;
pProperties[*pPropertyCount] = properties;
*pPropertyCount += 1;
});
if (*pPropertyCount < static_cast<uint32_t>(num_modes))
{
return VK_INCOMPLETE;
}
return VK_SUCCESS;
}
VWL_VKAPI_CALL(VkResult)
GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex,
VkDisplayPlaneCapabilitiesKHR *pCapabilities)
{
assert(physicalDevice != VK_NULL_HANDLE);
assert(mode != VK_NULL_HANDLE);
assert(pCapabilities != nullptr);
drm_display_mode *display_mode = reinterpret_cast<drm_display_mode *>(mode);
assert(display_mode != nullptr);
auto dpy = display_mode->get_display();
assert(dpy != nullptr);
/* Implementation supports only one plane for presenting
* images. Therefore plane index must be 0. */
assert(planeIndex == 0);
auto valid_mode =
std::find_if(dpy->get_display_modes_begin(), dpy->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());
});
assert(valid_mode != dpy->get_display_modes_end());
VkDisplayPlaneCapabilitiesKHR planeCapabilities{};
planeCapabilities.supportedAlpha = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
planeCapabilities.minSrcPosition = { 0, 0 };
planeCapabilities.maxSrcPosition = { 0, 0 };
/* Implementation allows swapchains to be a subset of the display area. */
planeCapabilities.minSrcExtent = { 0, 0 };
planeCapabilities.maxSrcExtent = { display_mode->get_width(), display_mode->get_height() };
planeCapabilities.minDstPosition = { 0, 0 };
planeCapabilities.maxDstPosition = { 0, 0 };
planeCapabilities.minDstExtent = { display_mode->get_width(), display_mode->get_height() };
planeCapabilities.maxDstExtent = { display_mode->get_width(), display_mode->get_height() };
*pCapabilities = planeCapabilities;
return VK_SUCCESS;
}
VWL_VKAPI_CALL(VkResult)
GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount,
VkDisplayKHR *pDisplays)
{
assert(physicalDevice != VK_NULL_HANDLE);
assert(pDisplayCount != nullptr);
std::shared_ptr<drm_display> dpy = surface_properties::get_instance().get_display();
assert(dpy != nullptr);
/* Implementation supports only one plane for presenting
* images. Therefore plane index must be 0. */
assert(planeIndex == 0);
if (pDisplays == nullptr)
{
/* Implementation will expose just one (the main)
* plane for the application to use. */
*pDisplayCount = 1;
return VK_SUCCESS;
}
if (*pDisplayCount == 0)
{
return VK_INCOMPLETE;
}
*pDisplays = reinterpret_cast<VkDisplayKHR>(dpy.get());
*pDisplayCount = 1;
return VK_SUCCESS;
}
VWL_VKAPI_CALL(VkResult)
GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
VkDisplayPlanePropertiesKHR *pProperties)
{
assert(physicalDevice != VK_NULL_HANDLE);
assert(pPropertyCount != nullptr);
std::shared_ptr<drm_display> dpy = surface_properties::get_instance().get_display();
assert(dpy != nullptr);
if (pProperties == nullptr)
{
/* Implementation will expose just one (the main)
* plane for the application to use. */
*pPropertyCount = 1;
return VK_SUCCESS;
}
if (*pPropertyCount == 0)
{
return VK_INCOMPLETE;
}
VkDisplayPlanePropertiesKHR planeProperties{};
planeProperties.currentDisplay = reinterpret_cast<VkDisplayKHR>(dpy.get());
/* Since the implementation is exposing just one plane the value for
* the current stack index must be 0.*/
planeProperties.currentStackIndex = 0;
*pProperties = planeProperties;
*pPropertyCount = 1;
return VK_SUCCESS;
}
VWL_VKAPI_CALL(VkResult)
GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
VkDisplayPropertiesKHR *pProperties)
{
assert(physicalDevice != VK_NULL_HANDLE);
assert(pPropertyCount != nullptr);
std::shared_ptr<drm_display> dpy = surface_properties::get_instance().get_display();
if (dpy == nullptr)
{
*pPropertyCount = 0;
return VK_SUCCESS;
}
if (pProperties == nullptr)
{
*pPropertyCount = 1;
return VK_SUCCESS;
}
if (*pPropertyCount == 0)
{
return VK_INCOMPLETE;
}
*pPropertyCount = 1;
VkDisplayPropertiesKHR display_properties = {};
display_properties.display = reinterpret_cast<VkDisplayKHR>(dpy.get());
display_properties.displayName = "DRM display";
display_properties.physicalDimensions = { dpy->get_connector()->mmWidth, dpy->get_connector()->mmHeight };
display_properties.physicalResolution = { dpy->get_max_width(), dpy->get_max_height() };
display_properties.supportedTransforms = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
display_properties.planeReorderPossible = VK_FALSE;
display_properties.persistentContent = VK_FALSE;
*pProperties = display_properties;
return VK_SUCCESS;
}
PFN_vkVoidFunction surface_properties::get_proc_addr(const char *name)
{
if (strcmp(name, "vkCreateDisplayModeKHR") == 0)
{
return reinterpret_cast<PFN_vkVoidFunction>(CreateDisplayModeKHR);
}
else if (strcmp(name, "vkCreateDisplayPlaneSurfaceKHR") == 0)
{
return reinterpret_cast<PFN_vkVoidFunction>(CreateDisplayPlaneSurfaceKHR);
}
else if (strcmp(name, "vkGetDisplayModePropertiesKHR") == 0)
{
return reinterpret_cast<PFN_vkVoidFunction>(GetDisplayModePropertiesKHR);
}
else if (strcmp(name, "vkGetDisplayPlaneCapabilitiesKHR") == 0)
{
return reinterpret_cast<PFN_vkVoidFunction>(GetDisplayPlaneCapabilitiesKHR);
}
else if (strcmp(name, "vkGetDisplayPlaneSupportedDisplaysKHR") == 0)
{
return reinterpret_cast<PFN_vkVoidFunction>(GetDisplayPlaneSupportedDisplaysKHR);
}
else if (strcmp(name, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR") == 0)
{
return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceDisplayPlanePropertiesKHR);
}
else if (strcmp(name, "vkGetPhysicalDeviceDisplayPropertiesKHR") == 0)
{
return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceDisplayPropertiesKHR);
}
return nullptr;
}
VkResult surface_properties::get_required_instance_extensions(util::extension_list &extension_list)
{
const std::array required_instance_extensions{
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
};
return extension_list.add(required_instance_extensions.data(), required_instance_extensions.size());
}
bool surface_properties::is_surface_extension_enabled(const layer::instance_private_data &instance_data)
{
return instance_data.is_instance_extension_enabled(VK_KHR_SURFACE_EXTENSION_NAME);
}
surface_properties &surface_properties::get_instance()
{
static surface_properties instance;
return instance;
}
std::shared_ptr<drm_display> surface_properties::get_display()
{
return display;
}
} /* namespace display */
} /* namespace wsi */

67
wsi/display/surface_properties.hpp Normal file
View file

@ -0,0 +1,67 @@
/*
* Copyright (c) 2024 Arm Limited.
*
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#pragma once
#include <vulkan/vulkan_core.h>
#include "wsi/surface_properties.hpp"
#include "drm_display.hpp"
namespace wsi
{
namespace display
{
class surface_properties : public wsi::surface_properties
{
public:
VkResult get_surface_capabilities(VkPhysicalDevice physical_device,
VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) override;
VkResult get_surface_formats(VkPhysicalDevice physical_device, uint32_t *surfaceFormatCount,
VkSurfaceFormatKHR *surfaceFormats,
VkSurfaceFormat2KHR *extended_surface_formats) override;
VkResult get_surface_present_modes(VkPhysicalDevice physical_device, VkSurfaceKHR surface,
uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes) override;
PFN_vkVoidFunction get_proc_addr(const char *name) override;
VkResult get_required_instance_extensions(util::extension_list &extension_list) override;
bool is_surface_extension_enabled(const layer::instance_private_data &instance_data) override;
static surface_properties &get_instance();
std::shared_ptr<drm_display> get_display();
private:
std::shared_ptr<drm_display> display;
};
} /* namespace display */
} /* namespace wsi */

4
wsi/headless/surface_properties.cpp
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2017-2019, 2021-2023 Arm Limited.
* Copyright (c) 2017-2019, 2021-2024 Arm Limited.
*
* SPDX-License-Identifier: MIT
*
@ -39,8 +39,6 @@
#include "surface.hpp"
#include "util/macros.hpp"
#define UNUSED(x) ((void)(x))
namespace wsi
{
namespace headless

13
wsi/wsi_factory.cpp
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2019-2023 Arm Limited.
* Copyright (c) 2019-2024 Arm Limited.
*
* SPDX-License-Identifier: MIT
*
@ -46,6 +46,10 @@
#include "wayland/surface_properties.hpp"
#endif
#if BUILD_WSI_DISPLAY
#include "display/surface_properties.hpp"
#endif
namespace wsi
{
@ -60,6 +64,9 @@ static struct wsi_extension
#if BUILD_WSI_WAYLAND
{ { VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, VK_KHR_WAYLAND_SURFACE_SPEC_VERSION }, VK_ICD_WSI_PLATFORM_WAYLAND },
#endif
#if BUILD_WSI_DISPLAY
{ { VK_KHR_DISPLAY_EXTENSION_NAME, VK_KHR_DISPLAY_SPEC_VERSION }, VK_ICD_WSI_PLATFORM_DISPLAY },
#endif
};
static surface_properties *get_surface_properties(VkIcdWsiPlatform platform)
@ -73,6 +80,10 @@ static surface_properties *get_surface_properties(VkIcdWsiPlatform platform)
#if BUILD_WSI_WAYLAND
case VK_ICD_WSI_PLATFORM_WAYLAND:
return &wayland::surface_properties::get_instance();
#endif
#if BUILD_WSI_DISPLAY
case VK_ICD_WSI_PLATFORM_DISPLAY:
return &display::surface_properties::get_instance();
#endif
default:
return nullptr;