#include "wsi_common_private.h"
#include "drm-uapi/drm_fourcc.h"
#include "util/macros.h"
+#include "util/os_file.h"
#include "util/xmlconfig.h"
#include "vk_util.h"
const struct driOptionCache *dri_options)
{
const char *present_mode;
- VkResult result;
+ UNUSED VkResult result;
memset(wsi, 0, sizeof(*wsi));
WSI_GET_CB(FreeMemory);
WSI_GET_CB(FreeCommandBuffers);
WSI_GET_CB(GetBufferMemoryRequirements);
+ WSI_GET_CB(GetImageDrmFormatModifierPropertiesEXT);
WSI_GET_CB(GetImageMemoryRequirements);
WSI_GET_CB(GetImageSubresourceLayout);
WSI_GET_CB(GetMemoryFdKHR);
WSI_GET_CB(GetPhysicalDeviceFormatProperties);
WSI_GET_CB(GetPhysicalDeviceFormatProperties2KHR);
+ WSI_GET_CB(GetPhysicalDeviceImageFormatProperties2);
WSI_GET_CB(ResetFences);
WSI_GET_CB(QueueSubmit);
WSI_GET_CB(WaitForFences);
if (driCheckOption(dri_options, "adaptive_sync", DRI_BOOL))
wsi->enable_adaptive_sync = driQueryOptionb(dri_options,
"adaptive_sync");
+
+ if (driCheckOption(dri_options, "vk_wsi_force_bgra8_unorm_first", DRI_BOOL)) {
+ wsi->force_bgra8_unorm_first =
+ driQueryOptionb(dri_options, "vk_wsi_force_bgra8_unorm_first");
+ }
}
return VK_SUCCESS;
-
+#if defined(VK_USE_PLATFORM_XCB_KHR) || \
+ defined(VK_USE_PLATFORM_WAYLAND_KHR) || \
+ defined(VK_USE_PLATFORM_DISPLAY_KHR)
fail:
wsi_device_finish(wsi, alloc);
return result;
+#endif
}
void
memset(chain, 0, sizeof(*chain));
+ vk_object_base_init(NULL, &chain->base, VK_OBJECT_TYPE_SWAPCHAIN_KHR);
+
chain->wsi = wsi;
chain->device = device;
chain->alloc = *pAllocator;
&chain->alloc);
}
vk_free(&chain->alloc, chain->cmd_pools);
+
+ vk_object_base_finish(&chain->base);
}
static uint32_t
for (int i = 0; i < ARRAY_SIZE(image->fds); i++)
image->fds[i] = -1;
- struct wsi_image_create_info image_wsi_info = {
- .sType = VK_STRUCTURE_TYPE_WSI_IMAGE_CREATE_INFO_MESA,
- .pNext = NULL,
+ VkImageCreateInfo image_info = {
+ .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+ .flags = 0,
+ .imageType = VK_IMAGE_TYPE_2D,
+ .format = pCreateInfo->imageFormat,
+ .extent = {
+ .width = pCreateInfo->imageExtent.width,
+ .height = pCreateInfo->imageExtent.height,
+ .depth = 1,
+ },
+ .mipLevels = 1,
+ .arrayLayers = 1,
+ .samples = VK_SAMPLE_COUNT_1_BIT,
+ .tiling = VK_IMAGE_TILING_OPTIMAL,
+ .usage = pCreateInfo->imageUsage,
+ .sharingMode = pCreateInfo->imageSharingMode,
+ .queueFamilyIndexCount = pCreateInfo->queueFamilyIndexCount,
+ .pQueueFamilyIndices = pCreateInfo->pQueueFamilyIndices,
+ .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
};
+ VkImageFormatListCreateInfoKHR image_format_list;
+ if (pCreateInfo->flags & VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR) {
+ image_info.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT |
+ VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR;
+
+ const VkImageFormatListCreateInfoKHR *format_list =
+ vk_find_struct_const(pCreateInfo->pNext,
+ IMAGE_FORMAT_LIST_CREATE_INFO_KHR);
+
+#ifndef NDEBUG
+ assume(format_list && format_list->viewFormatCount > 0);
+ bool format_found = false;
+ for (int i = 0; i < format_list->viewFormatCount; i++)
+ if (pCreateInfo->imageFormat == format_list->pViewFormats[i])
+ format_found = true;
+ assert(format_found);
+#endif
+
+ image_format_list = *format_list;
+ image_format_list.pNext = NULL;
+ __vk_append_struct(&image_info, &image_format_list);
+ }
+
+ struct wsi_image_create_info image_wsi_info;
+ VkImageDrmFormatModifierListCreateInfoEXT image_modifier_list;
+
uint32_t image_modifier_count = 0, modifier_prop_count = 0;
- struct wsi_format_modifier_properties *modifier_props = NULL;
+ struct VkDrmFormatModifierPropertiesEXT *modifier_props = NULL;
uint64_t *image_modifiers = NULL;
if (num_modifier_lists == 0) {
/* If we don't have modifiers, fall back to the legacy "scanout" flag */
- image_wsi_info.scanout = true;
+ image_wsi_info = (struct wsi_image_create_info) {
+ .sType = VK_STRUCTURE_TYPE_WSI_IMAGE_CREATE_INFO_MESA,
+ .scanout = true,
+ };
+ __vk_append_struct(&image_info, &image_wsi_info);
} else {
/* The winsys can't request modifiers if we don't support them. */
assert(wsi->supports_modifiers);
- struct wsi_format_modifier_properties_list modifier_props_list = {
- .sType = VK_STRUCTURE_TYPE_WSI_FORMAT_MODIFIER_PROPERTIES_LIST_MESA,
- .pNext = NULL,
+ struct VkDrmFormatModifierPropertiesListEXT modifier_props_list = {
+ .sType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT,
};
VkFormatProperties2 format_props = {
.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
wsi->GetPhysicalDeviceFormatProperties2KHR(wsi->pdevice,
pCreateInfo->imageFormat,
&format_props);
- assert(modifier_props_list.modifier_count > 0);
+ assert(modifier_props_list.drmFormatModifierCount > 0);
modifier_props = vk_alloc(&chain->alloc,
sizeof(*modifier_props) *
- modifier_props_list.modifier_count,
+ modifier_props_list.drmFormatModifierCount,
8,
VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
if (!modifier_props) {
goto fail;
}
- modifier_props_list.modifier_properties = modifier_props;
+ modifier_props_list.pDrmFormatModifierProperties = modifier_props;
wsi->GetPhysicalDeviceFormatProperties2KHR(wsi->pdevice,
pCreateInfo->imageFormat,
&format_props);
- modifier_prop_count = modifier_props_list.modifier_count;
+
+ /* Call GetImageFormatProperties with every modifier and filter the list
+ * down to those that we know work.
+ */
+ modifier_prop_count = 0;
+ for (uint32_t i = 0; i < modifier_props_list.drmFormatModifierCount; i++) {
+ VkPhysicalDeviceImageDrmFormatModifierInfoEXT mod_info = {
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
+ .drmFormatModifier = modifier_props[i].drmFormatModifier,
+ .sharingMode = pCreateInfo->imageSharingMode,
+ .queueFamilyIndexCount = pCreateInfo->queueFamilyIndexCount,
+ .pQueueFamilyIndices = pCreateInfo->pQueueFamilyIndices,
+ };
+ VkPhysicalDeviceImageFormatInfo2 format_info = {
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
+ .format = pCreateInfo->imageFormat,
+ .type = VK_IMAGE_TYPE_2D,
+ .tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT,
+ .usage = pCreateInfo->imageUsage,
+ .flags = image_info.flags,
+ };
+
+ VkImageFormatListCreateInfoKHR format_list;
+ if (image_info.flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) {
+ format_list = image_format_list;
+ format_list.pNext = NULL;
+ __vk_append_struct(&format_info, &format_list);
+ }
+
+ VkImageFormatProperties2 format_props = {
+ .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
+ .pNext = NULL,
+ };
+ __vk_append_struct(&format_info, &mod_info);
+ result = wsi->GetPhysicalDeviceImageFormatProperties2(wsi->pdevice,
+ &format_info,
+ &format_props);
+ if (result == VK_SUCCESS)
+ modifier_props[modifier_prop_count++] = modifier_props[i];
+ }
uint32_t max_modifier_count = 0;
for (uint32_t l = 0; l < num_modifier_lists; l++)
*/
for (uint32_t i = 0; i < num_modifiers[l]; i++) {
for (uint32_t j = 0; j < modifier_prop_count; j++) {
- if (modifier_props[j].modifier == modifiers[l][i])
+ if (modifier_props[j].drmFormatModifier == modifiers[l][i])
image_modifiers[image_modifier_count++] = modifiers[l][i];
}
}
}
if (image_modifier_count > 0) {
- image_wsi_info.modifier_count = image_modifier_count;
- image_wsi_info.modifiers = image_modifiers;
+ image_modifier_list = (VkImageDrmFormatModifierListCreateInfoEXT) {
+ .sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT,
+ .drmFormatModifierCount = image_modifier_count,
+ .pDrmFormatModifiers = image_modifiers,
+ };
+ image_info.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT;
+ __vk_append_struct(&image_info, &image_modifier_list);
} else {
/* TODO: Add a proper error here */
assert(!"Failed to find a supported modifier! This should never "
}
}
- const VkImageCreateInfo image_info = {
- .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
- .pNext = &image_wsi_info,
- .flags = 0,
- .imageType = VK_IMAGE_TYPE_2D,
- .format = pCreateInfo->imageFormat,
- .extent = {
- .width = pCreateInfo->imageExtent.width,
- .height = pCreateInfo->imageExtent.height,
- .depth = 1,
- },
- .mipLevels = 1,
- .arrayLayers = 1,
- .samples = VK_SAMPLE_COUNT_1_BIT,
- .tiling = VK_IMAGE_TILING_OPTIMAL,
- .usage = pCreateInfo->imageUsage,
- .sharingMode = pCreateInfo->imageSharingMode,
- .queueFamilyIndexCount = pCreateInfo->queueFamilyIndexCount,
- .pQueueFamilyIndices = pCreateInfo->pQueueFamilyIndices,
- .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
- };
result = wsi->CreateImage(chain->device, &image_info,
&chain->alloc, &image->image);
if (result != VK_SUCCESS)
goto fail;
if (num_modifier_lists > 0) {
- image->drm_modifier = wsi->image_get_modifier(image->image);
+ VkImageDrmFormatModifierPropertiesEXT image_mod_props = {
+ .sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
+ };
+ result = wsi->GetImageDrmFormatModifierPropertiesEXT(chain->device,
+ image->image,
+ &image_mod_props);
+ if (result != VK_SUCCESS) {
+ close(fd);
+ goto fail;
+ }
+ image->drm_modifier = image_mod_props.drmFormatModifier;
assert(image->drm_modifier != DRM_FORMAT_MOD_INVALID);
for (uint32_t j = 0; j < modifier_prop_count; j++) {
- if (modifier_props[j].modifier == image->drm_modifier) {
- image->num_planes = modifier_props[j].modifier_plane_count;
+ if (modifier_props[j].drmFormatModifier == image->drm_modifier) {
+ image->num_planes = modifier_props[j].drmFormatModifierPlaneCount;
break;
}
}
if (p == 0) {
image->fds[p] = fd;
} else {
- image->fds[p] = dup(fd);
+ image->fds[p] = os_dupfd_cloexec(fd);
if (image->fds[p] == -1) {
for (uint32_t i = 0; i < p; i++)
- close(image->fds[p]);
+ close(image->fds[i]);
+ result = VK_ERROR_OUT_OF_HOST_MEMORY;
goto fail;
}
}
VkSwapchainKHR _swapchain,
const VkAllocationCallbacks *pAllocator)
{
- WSI_FROM_HANDLE(wsi_swapchain, swapchain, _swapchain);
+ VK_FROM_HANDLE(wsi_swapchain, swapchain, _swapchain);
if (!swapchain)
return;
uint32_t *pSwapchainImageCount,
VkImage *pSwapchainImages)
{
- WSI_FROM_HANDLE(wsi_swapchain, swapchain, _swapchain);
+ VK_FROM_HANDLE(wsi_swapchain, swapchain, _swapchain);
VK_OUTARRAY_MAKE(images, pSwapchainImages, pSwapchainImageCount);
for (uint32_t i = 0; i < swapchain->image_count; i++) {
const VkAcquireNextImageInfoKHR *pAcquireInfo,
uint32_t *pImageIndex)
{
- WSI_FROM_HANDLE(wsi_swapchain, swapchain, pAcquireInfo->swapchain);
+ VK_FROM_HANDLE(wsi_swapchain, swapchain, pAcquireInfo->swapchain);
VkResult result = swapchain->acquire_next_image(swapchain, pAcquireInfo,
pImageIndex);
if (result != VK_SUCCESS)
return result;
+ if (wsi->set_memory_ownership) {
+ VkDeviceMemory mem = swapchain->get_wsi_image(swapchain, *pImageIndex)->memory;
+ wsi->set_memory_ownership(swapchain->device, mem, true);
+ }
+
if (pAcquireInfo->semaphore != VK_NULL_HANDLE &&
wsi->signal_semaphore_for_memory != NULL) {
struct wsi_image *image =
vk_find_struct_const(pPresentInfo->pNext, PRESENT_REGIONS_KHR);
for (uint32_t i = 0; i < pPresentInfo->swapchainCount; i++) {
- WSI_FROM_HANDLE(wsi_swapchain, swapchain, pPresentInfo->pSwapchains[i]);
+ VK_FROM_HANDLE(wsi_swapchain, swapchain, pPresentInfo->pSwapchains[i]);
uint32_t image_index = pPresentInfo->pImageIndices[i];
VkResult result;
if (result != VK_SUCCESS)
goto fail_present;
+ if (wsi->set_memory_ownership) {
+ VkDeviceMemory mem = swapchain->get_wsi_image(swapchain, image_index)->memory;
+ wsi->set_memory_ownership(swapchain->device, mem, false);
+ }
+
fail_present:
if (pPresentInfo->pResults != NULL)
pPresentInfo->pResults[i] = result;
projects / mesa.git / blobdiff