mirrors/wlroots
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wlroots/wlroots.git synced 2026-04-18 06:47:31 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'vk-shared-blend' into 'master'

Browse source 
Draft: render/vulkan: Cache blending buffer on swapchain

See merge request wlroots/wlroots!4740
This commit is contained in:
Kenny Levinsen 2024-10-28 00:28:25 +00:00
commit 2ba9e6424a
5 changed files with 252 additions and 83 deletions
Download patch file Download diff file Expand all files Collapse all files

14
include/render/vulkan.h
View file

@ -197,6 +197,15 @@ struct wlr_vk_render_format_setup {
struct wl_list pipelines; // struct wlr_vk_pipeline.link
};
// Internal blending buffer shraed between render buffers
struct wlr_vk_blend_buffer {
struct wlr_vk_renderer *renderer;
VkImageView blend_image_view;
VkImage blend_image;
VkDeviceMemory blend_memory;
int refcnt;
};
// Renderer-internal represenation of an wlr_buffer imported for rendering.
struct wlr_vk_render_buffer {
struct wlr_buffer *wlr_buffer;
@ -228,9 +237,8 @@ struct wlr_vk_render_buffer {
VkFramebuffer framebuffer;
bool transitioned;
VkImage blend_image;
VkImageView blend_image_view;
VkDeviceMemory blend_memory;
struct wlr_vk_blend_buffer *blend_buffer;
VkDescriptorSet blend_descriptor_set;
struct wlr_vk_descriptor_pool *blend_attachment_pool;
bool blend_transitioned;

6
include/wlr/render/swapchain.h
View file

@ -4,6 +4,7 @@
#include <stdbool.h>
#include <wayland-server-core.h>
#include <wlr/render/drm_format_set.h>
#include <wlr/util/addon.h>
#define WLR_SWAPCHAIN_CAP 4
@ -23,6 +24,8 @@ struct wlr_swapchain {
struct wlr_swapchain_slot slots[WLR_SWAPCHAIN_CAP];
struct wl_listener allocator_destroy;
struct wlr_addon_set addons;
};
struct wlr_swapchain *wlr_swapchain_create(
@ -43,4 +46,7 @@ struct wlr_buffer *wlr_swapchain_acquire(struct wlr_swapchain *swapchain);
bool wlr_swapchain_has_buffer(struct wlr_swapchain *swapchain,
struct wlr_buffer *buffer);
struct wlr_swapchain *wlr_swapchain_try_from_wlr_buffer(
struct wlr_buffer *buffer);
#endif

44
render/swapchain.c
View file

@ -6,6 +6,36 @@
#include "render/allocator/allocator.h"
#include "render/drm_format_set.h"
struct wlr_swapchain_buffer {
struct wlr_addon buffer_addon;
struct wlr_swapchain *swapchain;
};
static void wlr_swapchain_buffer_destroy(struct wlr_addon *addon) {
struct wlr_swapchain_buffer *swapchain_buffer =
wl_container_of(addon, swapchain_buffer, buffer_addon);
wlr_addon_finish(&swapchain_buffer->buffer_addon);
swapchain_buffer->swapchain = NULL;
free(swapchain_buffer);
}
static const struct wlr_addon_interface buffer_addon_impl = {
.name = "wlr_swapchain_buffer",
.destroy = wlr_swapchain_buffer_destroy,
};
struct wlr_swapchain *wlr_swapchain_try_from_wlr_buffer(struct wlr_buffer *buffer) {
struct wlr_addon *addon =
wlr_addon_find(&buffer->addons, NULL, &buffer_addon_impl);
if (addon == NULL) {
return NULL;
}
struct wlr_swapchain_buffer *swapchain_buffer =
wl_container_of(addon, swapchain_buffer, buffer_addon);
return swapchain_buffer->swapchain;
}
static void swapchain_handle_allocator_destroy(struct wl_listener *listener,
void *data) {
struct wlr_swapchain *swapchain =
@ -33,6 +63,7 @@ struct wlr_swapchain *wlr_swapchain_create(
swapchain->allocator_destroy.notify = swapchain_handle_allocator_destroy;
wl_signal_add(&alloc->events.destroy, &swapchain->allocator_destroy);
wlr_addon_set_init(&swapchain->addons);
return swapchain;
}
@ -54,6 +85,7 @@ void wlr_swapchain_destroy(struct wlr_swapchain *swapchain) {
}
wl_list_remove(&swapchain->allocator_destroy.link);
wlr_drm_format_finish(&swapchain->format);
wlr_addon_set_finish(&swapchain->addons);
free(swapchain);
}
@ -98,13 +130,25 @@ struct wlr_buffer *wlr_swapchain_acquire(struct wlr_swapchain *swapchain) {
return NULL;
}
struct wlr_swapchain_buffer *swapchain_buffer =
calloc(1, sizeof(*swapchain_buffer));
if (swapchain_buffer == NULL) {
return NULL;
}
swapchain_buffer->swapchain = swapchain;
wlr_log(WLR_DEBUG, "Allocating new swapchain buffer");
free_slot->buffer = wlr_allocator_create_buffer(swapchain->allocator,
swapchain->width, swapchain->height, &swapchain->format);
if (free_slot->buffer == NULL) {
wlr_log(WLR_ERROR, "Failed to allocate buffer");
free(swapchain_buffer);
return NULL;
}
wlr_addon_init(&swapchain_buffer->buffer_addon, &free_slot->buffer->addons,
NULL, &buffer_addon_impl);
return slot_acquire(swapchain, free_slot);
}

2
render/vulkan/pass.c
View file

@ -274,7 +274,7 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = render_buffer->plain.blend_image,
.image = render_buffer->plain.blend_buffer->blend_image,
.oldLayout = blend_src_layout,
.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.srcAccessMask = VK_ACCESS_SHADER_READ_BIT,

269
render/vulkan/renderer.c
View file

@ -10,6 +10,7 @@
#include <vulkan/vulkan.h>
#include <wlr/render/color.h>
#include <wlr/render/interface.h>
#include <wlr/render/swapchain.h>
#include <wlr/types/wlr_drm.h>
#include <wlr/util/box.h>
#include <wlr/util/log.h>
@ -576,6 +577,26 @@ void vulkan_reset_command_buffer(struct wlr_vk_command_buffer *cb) {
}
}
static void vulkan_blend_buffer_unref(struct wlr_vk_blend_buffer *bb) {
if (bb == NULL || --bb->refcnt > 0) {
return;
}
VkDevice dev = bb->renderer->dev->dev;
vkDestroyImageView(dev, bb->blend_image_view, NULL);
vkDestroyImage(dev, bb->blend_image, NULL);
vkFreeMemory(dev, bb->blend_memory, NULL);
free(bb);
}
static struct wlr_vk_blend_buffer *vulkan_blend_buffer_ref(
struct wlr_vk_blend_buffer *bb) {
bb->refcnt++;
return bb;
}
static void destroy_render_buffer(struct wlr_vk_render_buffer *buffer) {
wl_list_remove(&buffer->link);
wlr_addon_finish(&buffer->addon);
@ -594,9 +615,7 @@ static void destroy_render_buffer(struct wlr_vk_render_buffer *buffer) {
vkDestroyFramebuffer(dev, buffer->plain.framebuffer, NULL);
vkDestroyImageView(dev, buffer->plain.image_view, NULL);
vkDestroyImage(dev, buffer->plain.blend_image, NULL);
vkFreeMemory(dev, buffer->plain.blend_memory, NULL);
vkDestroyImageView(dev, buffer->plain.blend_image_view, NULL);
vulkan_blend_buffer_unref(buffer->plain.blend_buffer);
if (buffer->plain.blend_attachment_pool) {
vulkan_free_ds(buffer->renderer, buffer->plain.blend_attachment_pool,
buffer->plain.blend_descriptor_set);
@ -620,12 +639,178 @@ static struct wlr_addon_interface render_buffer_addon_impl = {
.destroy = handle_render_buffer_destroy,
};
struct vulkan_swapchain_blend_buffer {
struct wlr_addon swapchain_addon;
struct wlr_vk_blend_buffer *blend_buffer;
};
static void handle_swapchain_destroy(struct wlr_addon *addon) {
struct vulkan_swapchain_blend_buffer *bb =
wl_container_of(addon, bb, swapchain_addon);
vulkan_blend_buffer_unref(bb->blend_buffer);
wlr_addon_finish(&bb->swapchain_addon);
}
static struct wlr_addon_interface vulkan_swapchain_blend_buffer_addon_impl = {
.name = "vulkan_swapchain_blend_buffer",
.destroy = handle_swapchain_destroy,
};
static struct wlr_vk_blend_buffer *vulkan_create_blend_buffer(
struct wlr_vk_renderer *renderer, int width, int height) {
VkResult res;
VkDevice dev = renderer->dev->dev;
struct wlr_vk_blend_buffer *bb = calloc(1, sizeof(*bb));
if (!bb) {
wlr_log_errno(WLR_ERROR, "Allocation failed");
return NULL;
}
bb->renderer = renderer;
// Set up an extra 16F buffer on which to do linear blending,
// and afterwards to render onto the target
VkImageCreateInfo img_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
.imageType = VK_IMAGE_TYPE_2D,
.format = VK_FORMAT_R16G16B16A16_SFLOAT,
.mipLevels = 1,
.arrayLayers = 1,
.samples = VK_SAMPLE_COUNT_1_BIT,
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
.tiling = VK_IMAGE_TILING_OPTIMAL,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.extent = (VkExtent3D) { width, height, 1 },
.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
};
res = vkCreateImage(dev, &img_info, NULL, &bb->blend_image);
if (res != VK_SUCCESS) {
wlr_vk_error("vkCreateImage failed", res);
goto error;
}
VkMemoryRequirements mem_reqs;
vkGetImageMemoryRequirements(dev, bb->blend_image, &mem_reqs);
int mem_type_index = vulkan_find_mem_type(renderer->dev,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, mem_reqs.memoryTypeBits);
if (mem_type_index == -1) {
wlr_log(WLR_ERROR, "failed to find suitable vulkan memory type");
goto error;
}
VkMemoryAllocateInfo mem_info = {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
.allocationSize = mem_reqs.size,
.memoryTypeIndex = mem_type_index,
};
res = vkAllocateMemory(dev, &mem_info, NULL, &bb->blend_memory);
if (res != VK_SUCCESS) {
wlr_vk_error("vkAllocatorMemory failed", res);
goto error;
}
res = vkBindImageMemory(dev, bb->blend_image, bb->blend_memory, 0);
if (res != VK_SUCCESS) {
wlr_vk_error("vkBindMemory failed", res);
goto error;
}
VkImageViewCreateInfo blend_view_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = bb->blend_image,
.viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = img_info.format,
.components.r = VK_COMPONENT_SWIZZLE_IDENTITY,
.components.g = VK_COMPONENT_SWIZZLE_IDENTITY,
.components.b = VK_COMPONENT_SWIZZLE_IDENTITY,
.components.a = VK_COMPONENT_SWIZZLE_IDENTITY,
.subresourceRange = (VkImageSubresourceRange) {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0,
.levelCount = 1,
.baseArrayLayer = 0,
.layerCount = 1,
},
};
res = vkCreateImageView(dev, &blend_view_info, NULL, &bb->blend_image_view);
if (res != VK_SUCCESS) {
wlr_vk_error("vkCreateImageView failed", res);
goto error;
}
return bb;
error:
if (bb->blend_image_view) {
vkDestroyImageView(dev, bb->blend_image_view, NULL);
}
if (bb->blend_image) {
vkDestroyImage(dev, bb->blend_image, NULL);
}
if (bb->blend_memory) {
vkFreeMemory(dev, bb->blend_memory, NULL);
}
return NULL;
}
static struct wlr_vk_blend_buffer *vulkan_get_swapchain_blend_buffer(
struct wlr_vk_renderer *renderer, struct wlr_swapchain *swapchain,
int width, int height) {
if (!swapchain) {
wlr_log(WLR_DEBUG, "No swapchain for blending buffer");
return vulkan_create_blend_buffer(renderer, width, height);
}
struct vulkan_swapchain_blend_buffer *sbb;
struct wlr_addon *addon = wlr_addon_find(&swapchain->addons, renderer,
&vulkan_swapchain_blend_buffer_addon_impl);
if (addon) {
wlr_log(WLR_DEBUG, "Reusing blending buffer");
sbb = wl_container_of(addon, sbb, swapchain_addon);
return sbb->blend_buffer;
}
sbb = calloc(1, sizeof(*sbb));
if (!sbb) {
wlr_log_errno(WLR_ERROR, "Allocation failed");
return NULL;
}
struct wlr_vk_blend_buffer *bb = vulkan_create_blend_buffer(renderer, width, height);
if (!bb) {
free(sbb);
return NULL;
}
sbb->blend_buffer = vulkan_blend_buffer_ref(bb);
wlr_log(WLR_DEBUG, "New swapchain blending buffer");
wlr_addon_init(&sbb->swapchain_addon, &swapchain->addons, renderer,
&vulkan_swapchain_blend_buffer_addon_impl);
return sbb->blend_buffer;
}
bool vulkan_setup_plain_framebuffer(struct wlr_vk_render_buffer *buffer,
const struct wlr_dmabuf_attributes *dmabuf) {
struct wlr_vk_renderer *renderer = buffer->renderer;
VkResult res;
VkDevice dev = renderer->dev->dev;
struct wlr_swapchain *swapchain =
wlr_swapchain_try_from_wlr_buffer(buffer->wlr_buffer);
struct wlr_vk_blend_buffer *bb = vulkan_get_swapchain_blend_buffer(renderer,
swapchain, dmabuf->width, dmabuf->height);
if (!bb) {
return false;
}
buffer->plain.blend_buffer = vulkan_blend_buffer_ref(bb);
const struct wlr_vk_format_props *fmt = vulkan_format_props_from_drm(
renderer->dev, dmabuf->format);
assert(fmt);
@ -660,80 +845,6 @@ bool vulkan_setup_plain_framebuffer(struct wlr_vk_render_buffer *buffer,
goto error;
}
// Set up an extra 16F buffer on which to do linear blending,
// and afterwards to render onto the target
VkImageCreateInfo img_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
.imageType = VK_IMAGE_TYPE_2D,
.format = VK_FORMAT_R16G16B16A16_SFLOAT,
.mipLevels = 1,
.arrayLayers = 1,
.samples = VK_SAMPLE_COUNT_1_BIT,
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
.tiling = VK_IMAGE_TILING_OPTIMAL,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.extent = (VkExtent3D) { dmabuf->width, dmabuf->height, 1 },
.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
};
res = vkCreateImage(dev, &img_info, NULL, &buffer->plain.blend_image);
if (res != VK_SUCCESS) {
wlr_vk_error("vkCreateImage failed", res);
goto error;
}
VkMemoryRequirements mem_reqs;
vkGetImageMemoryRequirements(dev, buffer->plain.blend_image, &mem_reqs);
int mem_type_index = vulkan_find_mem_type(renderer->dev,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, mem_reqs.memoryTypeBits);
if (mem_type_index == -1) {
wlr_log(WLR_ERROR, "failed to find suitable vulkan memory type");
goto error;
}
VkMemoryAllocateInfo mem_info = {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
.allocationSize = mem_reqs.size,
.memoryTypeIndex = mem_type_index,
};
res = vkAllocateMemory(dev, &mem_info, NULL, &buffer->plain.blend_memory);
if (res != VK_SUCCESS) {
wlr_vk_error("vkAllocatorMemory failed", res);
goto error;
}
res = vkBindImageMemory(dev, buffer->plain.blend_image, buffer->plain.blend_memory, 0);
if (res != VK_SUCCESS) {
wlr_vk_error("vkBindMemory failed", res);
goto error;
}
VkImageViewCreateInfo blend_view_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = buffer->plain.blend_image,
.viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = img_info.format,
.components.r = VK_COMPONENT_SWIZZLE_IDENTITY,
.components.g = VK_COMPONENT_SWIZZLE_IDENTITY,
.components.b = VK_COMPONENT_SWIZZLE_IDENTITY,
.components.a = VK_COMPONENT_SWIZZLE_IDENTITY,
.subresourceRange = (VkImageSubresourceRange) {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0,
.levelCount = 1,
.baseArrayLayer = 0,
.layerCount = 1,
},
};
res = vkCreateImageView(dev, &blend_view_info, NULL, &buffer->plain.blend_image_view);
if (res != VK_SUCCESS) {
wlr_vk_error("vkCreateImageView failed", res);
goto error;
}
buffer->plain.blend_attachment_pool = vulkan_alloc_blend_ds(renderer,
&buffer->plain.blend_descriptor_set);
if (!buffer->plain.blend_attachment_pool) {
@ -743,7 +854,7 @@ bool vulkan_setup_plain_framebuffer(struct wlr_vk_render_buffer *buffer,
VkDescriptorImageInfo ds_attach_info = {
.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
.imageView = buffer->plain.blend_image_view,
.imageView = bb->blend_image_view,
.sampler = VK_NULL_HANDLE,
};
VkWriteDescriptorSet ds_write = {
@ -757,7 +868,7 @@ bool vulkan_setup_plain_framebuffer(struct wlr_vk_render_buffer *buffer,
vkUpdateDescriptorSets(dev, 1, &ds_write, 0, NULL);
VkImageView attachments[2] = {
buffer->plain.blend_image_view,
bb->blend_image_view,
buffer->plain.image_view
};
VkFramebufferCreateInfo fb_info = {