From a2587f4f207673435ee3718a608b3bc45f6724c8 Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Sat, 21 Nov 2026 23:40:11 -0500 Subject: [PATCH] fix(display): preserve padded layer buffer layouts (#2985) * fix(display): preserve padded layer buffer layouts * fix(display): fall back when layer allocation fails * fix(display): write linear targets at their row pitch --- app/src/main/cpp/waylandcomp/src/sc_layer.c | 8 +- .../cpp/waylandcomp/src/vk_linear_dmabuf.h | 12 +- app/src/main/cpp/waylandcomp/src/vk_loader.h | 2 +- app/src/main/cpp/waylandcomp/src/vk_present.c | 121 +++++++++++------- tools/tests/test_vk_linear_dmabuf.py | 17 +++ tools/tests/vk_linear_dmabuf_test.c | 22 +++- 6 files changed, 125 insertions(+), 57 deletions(-) diff --git a/app/src/main/cpp/waylandcomp/src/sc_layer.c b/app/src/main/cpp/waylandcomp/src/sc_layer.c index 05b201b2e..a843500c9 100644 --- a/app/src/main/cpp/waylandcomp/src/sc_layer.c +++ b/app/src/main/cpp/waylandcomp/src/sc_layer.c @@ -518,6 +518,10 @@ static int alloc_slot(struct layer *l, struct slot *s, int w, int h, uint32_t fm img = vkp_image_import_dmabuf(nh->data[0], fmt == AHB_RGB10A2 ? DRM_ABGR2101010 : DRM_ABGR8888, mod, w, h, got.stride * 4, 0, 1); path = "dma-buf (QTI handle)"; + if (!img && mod == MOD_LINEAR && vkp_can_import_ahb()) { + img = vkp_image_import_ahb(ahb, info, sizeof(info)); + if (img) { mod = SC_MOD_GRALLOC; path = "AHardwareBuffer"; } + } } else { if (tier == TIER_UBWC) { char hd[256]; @@ -941,7 +945,7 @@ int sc_layer_present(struct vkp_image *src, int scene_w, int scene_h, const stru int wait_fd; int idx = take_free_slot(l, sw, sh, AHB_RGBA8, &wait_fd); - if (idx < 0) { log_drop(l); return 0; } + if (idx < 0) { log_drop(l); return g_alloc_failed ? -1 : 0; } if (vkp_blit_image(src, l->slots[idx].img, wait_fd) != 0) return -1; if (present_slot(l, idx, r, color, 0) != 0) return -1; if (color && color->dataspace) droiddeck_color_frame_shown(color, DROIDDECK_HDR_LAYER_COPY, AHB_RGBA8); @@ -1150,7 +1154,7 @@ int sc_layer_present_overlay(struct vkp_image *src, const int geo[8], int transl if (sw <= 0 || sh <= 0) return -1; int wait_fd; int idx = take_free_slot(l, sw, sh, AHB_RGBA8, &wait_fd); - if (idx < 0) { log_drop(l); return 0; } + if (idx < 0) { log_drop(l); return g_alloc_failed ? -1 : 0; } if (vkp_blit_image(src, l->slots[idx].img, wait_fd) != 0) return -1; if (present_slot(l, idx, geo, NULL, translucent) != 0) return -1; if (!l->first_logged) { diff --git a/app/src/main/cpp/waylandcomp/src/vk_linear_dmabuf.h b/app/src/main/cpp/waylandcomp/src/vk_linear_dmabuf.h index f0c92229a..a82002693 100644 --- a/app/src/main/cpp/waylandcomp/src/vk_linear_dmabuf.h +++ b/app/src/main/cpp/waylandcomp/src/vk_linear_dmabuf.h @@ -24,6 +24,12 @@ static inline uint32_t vkp_linear_dmabuf_texel_bytes(VkFormat fmt) { return fmt == VK_FORMAT_R16G16B16A16_SFLOAT ? 8u : 4u; } +static inline int vkp_padded_linear_target_needs_layout(int drm_modifiers, uint64_t modifier, VkFormat fmt, + int w, uint32_t stride, uint32_t offset) { + return !drm_modifiers && modifier == 0 && + (offset != 0 || (uint64_t)stride != (uint64_t)w * vkp_linear_dmabuf_texel_bytes(fmt)); +} + static inline VkDeviceSize vkp_linear_dmabuf_copy(VkFormat fmt, int w, int h, uint32_t stride, uint32_t offset, VkBufferImageCopy *copy) { const uint32_t texel = vkp_linear_dmabuf_texel_bytes(fmt); @@ -39,11 +45,11 @@ static inline VkDeviceSize vkp_linear_dmabuf_copy(VkFormat fmt, int w, int h, ui } static inline VkBufferMemoryBarrier vkp_linear_dmabuf_ownership(VkBuffer buffer, uint32_t queue_family, - int acquire) { + VkAccessFlags access, int acquire) { return (VkBufferMemoryBarrier){ .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, - .srcAccessMask = acquire ? 0 : VK_ACCESS_TRANSFER_READ_BIT, - .dstAccessMask = acquire ? VK_ACCESS_TRANSFER_READ_BIT : 0, + .srcAccessMask = acquire ? 0 : access, + .dstAccessMask = acquire ? access : 0, .srcQueueFamilyIndex = acquire ? VK_QUEUE_FAMILY_FOREIGN_EXT : queue_family, .dstQueueFamilyIndex = acquire ? queue_family : VK_QUEUE_FAMILY_FOREIGN_EXT, .buffer = buffer, diff --git a/app/src/main/cpp/waylandcomp/src/vk_loader.h b/app/src/main/cpp/waylandcomp/src/vk_loader.h index ee6328a28..c0782140f 100644 --- a/app/src/main/cpp/waylandcomp/src/vk_loader.h +++ b/app/src/main/cpp/waylandcomp/src/vk_loader.h @@ -22,7 +22,7 @@ X(ResetCommandBuffer) X(BeginCommandBuffer) X(CmdPipelineBarrier) X(CmdBlitImage) \ X(EndCommandBuffer) X(ResetFences) X(QueueSubmit) X(QueuePresentKHR) X(WaitForFences) \ X(QueueWaitIdle) X(GetMemoryFdPropertiesKHR) X(GetAndroidHardwareBufferPropertiesANDROID) \ - X(GetImageSubresourceLayout) X(MapMemory) X(UnmapMemory) X(CmdClearColorImage) \ + X(GetImageSubresourceLayout) X(MapMemory) X(UnmapMemory) X(CmdClearColorImage) X(CmdCopyImageToBuffer) \ X(CreateBuffer) X(DestroyBuffer) X(GetBufferMemoryRequirements) X(BindBufferMemory) \ X(CmdCopyBufferToImage) \ \ diff --git a/app/src/main/cpp/waylandcomp/src/vk_present.c b/app/src/main/cpp/waylandcomp/src/vk_present.c index ebd940428..7184ff644 100644 --- a/app/src/main/cpp/waylandcomp/src/vk_present.c +++ b/app/src/main/cpp/waylandcomp/src/vk_present.c @@ -1123,7 +1123,7 @@ static void release_external_client_draws(VkCommandBuffer cmd, const struct vkp_ static void stage_linear_dmabuf(VkCommandBuffer cmd, const struct vkp_image *img) { if (!img || !img->linear_buf) return; const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; - VkBufferMemoryBarrier acquire = vkp_linear_dmabuf_ownership(img->linear_buf, g_qfam, 1); + VkBufferMemoryBarrier acquire = vkp_linear_dmabuf_ownership(img->linear_buf, g_qfam, VK_ACCESS_TRANSFER_READ_BIT, 1); VkImageMemoryBarrier write = { .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, .newLayout = VK_IMAGE_LAYOUT_GENERAL, @@ -1132,7 +1132,7 @@ static void stage_linear_dmabuf(VkCommandBuffer cmd, const struct vkp_image *img g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 1, &acquire, 1, &write); g_vk.CmdCopyBufferToImage(cmd, img->linear_buf, img->image, VK_IMAGE_LAYOUT_GENERAL, 1, &img->linear_copy); - VkBufferMemoryBarrier release = vkp_linear_dmabuf_ownership(img->linear_buf, g_qfam, 0); + VkBufferMemoryBarrier release = vkp_linear_dmabuf_ownership(img->linear_buf, g_qfam, VK_ACCESS_TRANSFER_READ_BIT, 0); VkImageMemoryBarrier read = { .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_GENERAL, .newLayout = VK_IMAGE_LAYOUT_GENERAL, @@ -1259,7 +1259,8 @@ static int import_linear_dmabuf(struct vkp_image *img, int fd, const VkBufferIma .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT}; VkBufferCreateInfo bci = {.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .pNext = &ext, .size = size, - .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT, .sharingMode = VK_SHARING_MODE_EXCLUSIVE}; + .usage = img->blit_dst ? VK_BUFFER_USAGE_TRANSFER_DST_BIT : VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + .sharingMode = VK_SHARING_MODE_EXCLUSIVE}; VkResult r = g_vk.CreateBuffer(g_dev, &bci, NULL, &img->linear_buf); if (r != VK_SUCCESS) goto fail; uint32_t allowed = 0xffffffff; @@ -1312,8 +1313,8 @@ static int import_linear_dmabuf(struct vkp_image *img, int fd, const VkBufferIma img->in_general = 1; return 0; fail: - LOGE("dmabuf: reading the linear %dx%d buffer at its row pitch failed (%s); importing it as an image", - img->w, img->h, vk_result_name(r)); + LOGE("dmabuf: %s the linear %dx%d buffer at its row pitch failed (%s)", + img->blit_dst ? "writing" : "reading", img->w, img->h, vk_result_name(r)); if (dupfd >= 0) close(dupfd); destroy_image_objects(img); return -1; @@ -1324,15 +1325,20 @@ struct vkp_image *vkp_image_import_dmabuf(int fd, uint32_t drm_format, uint64_t if (modifier == MOD_INVALID || w <= 0 || h <= 0) return NULL; if (dev_init() != 0) return NULL; + const VkFormat format = drm_to_vk(drm_format); + const int padded_target = as_blit_dst && + vkp_padded_linear_target_needs_layout(g_drm_modifiers, modifier, format, w, stride, offset); + if (padded_target && !g_vk.CmdCopyImageToBuffer) return NULL; + struct vkp_image *img = calloc(1, sizeof(*img)); if (!img) return NULL; img->w = w; img->h = h; img->dmabuf = 1; img->blit_dst = as_blit_dst ? 1 : 0; - img->fmt = drm_to_vk(drm_format); - const int through_buffer = vkp_linear_dmabuf_through_buffer(g_drm_modifiers, modifier, as_blit_dst); + img->fmt = format; + const int through_buffer = padded_target || vkp_linear_dmabuf_through_buffer(g_drm_modifiers, modifier, as_blit_dst); const VkImageUsageFlags sampled_usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT; const int modifier_sampled = !as_blit_dst && g_drm_modifiers && g_vk.GetPhysicalDeviceImageFormatProperties2 && modifier_importable(img->fmt, modifier, sampled_usage); - img->sampled = through_buffer ? optimal_sampled(img->fmt) : modifier_sampled; + img->sampled = !as_blit_dst && (through_buffer ? optimal_sampled(img->fmt) : modifier_sampled); /* Each new format/modifier/size a client hands over, once, for the graphics report: a colour * or swizzle mismatch on a non-Adreno driver shows up as the pair it arrived as. */ { @@ -1358,7 +1364,12 @@ struct vkp_image *vkp_image_import_dmabuf(int fd, uint32_t drm_format, uint64_t if (through_buffer) { VkBufferImageCopy linear_copy; const VkDeviceSize linear_size = vkp_linear_dmabuf_copy(img->fmt, w, h, stride, offset, &linear_copy); - if (linear_size && import_linear_dmabuf(img, fd, &linear_copy, linear_size) == 0) return img; + if (linear_size && import_linear_dmabuf(img, fd, &linear_copy, linear_size) == 0) { + if (padded_target) droiddeck_log("gpu", "linear layer target %dx%d writes at pitch %u via DMA-BUF", + w, h, stride); + return img; + } + if (padded_target) { free(img); return NULL; } img->sampled = modifier_sampled; } VkSubresourceLayout plane = {.offset = offset, .rowPitch = stride}; @@ -2522,6 +2533,48 @@ int vkp_map_draw(const struct vkp_draw *d, int out[8]) { return 1; } +static void blit_to_layer(VkCommandBuffer cmd, VkImage src, VkImageLayout src_layout, struct vkp_image *dst, + const VkImageBlit *blit, VkFilter filter) { + const VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; + const VkImageMemoryBarrier acquire = { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, + .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + .srcQueueFamilyIndex = dst->staged ? VK_QUEUE_FAMILY_IGNORED : VK_QUEUE_FAMILY_FOREIGN_EXT, + .dstQueueFamilyIndex = dst->staged ? VK_QUEUE_FAMILY_IGNORED : g_qfam, + .image = dst->image, .subresourceRange = range, .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT}; + g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, + 0, 0, NULL, 0, NULL, 1, &acquire); + g_vk.CmdBlitImage(cmd, src, src_layout, dst->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, blit, filter); + if (dst->staged) { + const VkImageMemoryBarrier read = { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + .newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .image = dst->image, .subresourceRange = range, .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, + .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT}; + g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, + 0, 0, NULL, 0, NULL, 1, &read); + const VkBufferMemoryBarrier write = vkp_linear_dmabuf_ownership(dst->linear_buf, g_qfam, VK_ACCESS_TRANSFER_WRITE_BIT, 1); + g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, + 0, 0, NULL, 1, &write, 0, NULL); + VkBufferImageCopy copy = dst->linear_copy; + copy.imageExtent.width = (uint32_t)blit->dstOffsets[1].x; + copy.imageExtent.height = (uint32_t)blit->dstOffsets[1].y; + g_vk.CmdCopyImageToBuffer(cmd, dst->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst->linear_buf, 1, ©); + const VkBufferMemoryBarrier release = vkp_linear_dmabuf_ownership(dst->linear_buf, g_qfam, VK_ACCESS_TRANSFER_WRITE_BIT, 0); + g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + 0, 0, NULL, 1, &release, 0, NULL); + return; + } + const VkImageMemoryBarrier release = { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + .newLayout = VK_IMAGE_LAYOUT_GENERAL, .srcQueueFamilyIndex = g_qfam, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT, .image = dst->image, .subresourceRange = range, + .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT}; + g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + 0, 0, NULL, 0, NULL, 1, &release); +} + int vkp_blit_image(struct vkp_image *src, struct vkp_image *dst, int wait_fd) { if (!src || src->blit_dst || !dst || !dst->blit_dst || g_dev_state == -2 || dev_init() != 0) { if (wait_fd >= 0) close(wait_fd); @@ -2540,41 +2593,28 @@ int vkp_blit_image(struct vkp_image *src, struct vkp_image *dst, int wait_fd) { struct vkp_external_client_barrier_pair src_pair; const int src_external = vkp_external_client_barrier_pair( src->image, g_qfam, foreign_image(src), src->blit_dst, &src_pair); - VkImageMemoryBarrier acq[2] = { - src_external ? src_pair.acquire : (VkImageMemoryBarrier){ + VkImageMemoryBarrier acq = src_external ? src_pair.acquire : (VkImageMemoryBarrier){ .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, .newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, - .image = src->image, .subresourceRange = range, .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT}, - {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, - .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - .srcQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT, .dstQueueFamilyIndex = g_qfam, - .image = dst->image, .subresourceRange = range, .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT}}; + .image = src->image, .subresourceRange = range, .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT}; if (!src_external) { - acq[0].oldLayout = src->in_general ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_PREINITIALIZED; - acq[0].newLayout = VK_IMAGE_LAYOUT_GENERAL; - acq[0].srcAccessMask = VK_ACCESS_HOST_WRITE_BIT; + acq.oldLayout = src->in_general ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_PREINITIALIZED; + acq.newLayout = VK_IMAGE_LAYOUT_GENERAL; + acq.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT; src->in_general = 1; } g_vk.CmdPipelineBarrier(g_cmd, VK_PIPELINE_STAGE_HOST_BIT | VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, - VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 2, acq); + VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 1, &acq); int bw = src->w < dst->w ? src->w : dst->w, bh = src->h < dst->h ? src->h : dst->h; VkImageBlit blit = {.srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, .srcOffsets = {{0, 0, 0}, {bw, bh, 1}}, .dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, .dstOffsets = {{0, 0, 0}, {bw, bh, 1}}}; - g_vk.CmdBlitImage(g_cmd, src->image, - src_external ? VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL, - dst->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit, VK_FILTER_NEAREST); + blit_to_layer(g_cmd, src->image, src_external ? VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL, + dst, &blit, VK_FILTER_NEAREST); release_external_client_image(g_cmd, src); - VkImageMemoryBarrier rel = { - .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - .newLayout = VK_IMAGE_LAYOUT_GENERAL, .srcQueueFamilyIndex = g_qfam, - .dstQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT, .image = dst->image, .subresourceRange = range, - .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT}; - g_vk.CmdPipelineBarrier(g_cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, - 0, 0, NULL, 0, NULL, 1, &rel); g_vk.EndCommandBuffer(g_cmd); VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_TRANSFER_BIT; @@ -2890,31 +2930,14 @@ static int pass_finish(const VkImage *srcs, VkImageLayout src_layout, struct vkp } const int gpu_wait = take_wait_fd(wait_fd); if (gpu_wait < 0) { g_vk.EndCommandBuffer(cmd); return -1; } - VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; - for (int i = 0; i < n; i++) { struct vkp_image *dst = dsts[i]; - VkImageMemoryBarrier acq = { - .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, - .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT, - .dstQueueFamilyIndex = g_qfam, .image = dst->image, .subresourceRange = range, - .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT}; - g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, - 0, 0, NULL, 0, NULL, 1, &acq); VkImageBlit blit = {.srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, .srcOffsets = {{0, 0, 0}, {g_pass.rw, g_pass.rh, 1}}, .dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, .dstOffsets = {{0, 0, 0}, {dst->w, dst->h, 1}}}; - g_vk.CmdBlitImage(cmd, srcs[i], src_layout, dst->image, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit, - (g_pass.rw == dst->w && g_pass.rh == dst->h) ? VK_FILTER_NEAREST : VK_FILTER_LINEAR); - VkImageMemoryBarrier rel = { - .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - .newLayout = VK_IMAGE_LAYOUT_GENERAL, .srcQueueFamilyIndex = g_qfam, - .dstQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT, .image = dst->image, .subresourceRange = range, - .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT}; - g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, - 0, 0, NULL, 0, NULL, 1, &rel); + blit_to_layer(cmd, srcs[i], src_layout, dst, &blit, + (g_pass.rw == dst->w && g_pass.rh == dst->h) ? VK_FILTER_NEAREST : VK_FILTER_LINEAR); } g_vk.EndCommandBuffer(cmd); diff --git a/tools/tests/test_vk_linear_dmabuf.py b/tools/tests/test_vk_linear_dmabuf.py index a91df519c..08c4a2457 100644 --- a/tools/tests/test_vk_linear_dmabuf.py +++ b/tools/tests/test_vk_linear_dmabuf.py @@ -134,6 +134,23 @@ class VkLinearDmabufTest(unittest.TestCase): source.write_text(harness) compile_and_run(self, source, tmp, "vk-linear-layer") + def test_layer_import_failure_requests_compositor_fallback(self): + source = (SRC / "sc_layer.c").read_text() + for name in ("sc_layer_present", "sc_layer_present_overlay"): + with self.subTest(layer=name): + body = function(source, name) + self.assertRegex(body, r"if \(idx < 0\) \{ log_drop\(l\); return g_alloc_failed \? -1 : 0; \}") + + def test_layer_blits_use_the_imported_output_row_pitch(self): + source = (SRC / "vk_present.c").read_text() + blit = function(source, "blit_to_layer") + copy = blit.index("CmdCopyImageToBuffer") + self.assertLess(blit.index("VkBufferImageCopy copy = dst->linear_copy"), copy) + self.assertLess(blit.index("VK_ACCESS_TRANSFER_WRITE_BIT, 1"), copy) + self.assertGreater(blit.index("VK_ACCESS_TRANSFER_WRITE_BIT, 0"), copy) + for name in ("vkp_blit_image", "pass_finish"): + self.assertIn("blit_to_layer(", function(source, name)) + if __name__ == "__main__": unittest.main() diff --git a/tools/tests/vk_linear_dmabuf_test.c b/tools/tests/vk_linear_dmabuf_test.c index 3abb66da1..380dfa5c1 100644 --- a/tools/tests/vk_linear_dmabuf_test.c +++ b/tools/tests/vk_linear_dmabuf_test.c @@ -63,6 +63,16 @@ static void check_foreign_image(void) { assert(!vkp_linear_dmabuf_foreign_image(0, 1)); } +static void check_padded_layer_targets(void) { + const VkFormat rgba = VK_FORMAT_R8G8B8A8_UNORM; + const uint64_t qcom_compressed = 0x0500000000000001ULL; + assert(vkp_padded_linear_target_needs_layout(0, 0, rgba, 720, 3072, 0)); + assert(vkp_padded_linear_target_needs_layout(0, 0, rgba, 720, 2880, 64)); + assert(!vkp_padded_linear_target_needs_layout(0, 0, rgba, 1280, 5120, 0)); + assert(!vkp_padded_linear_target_needs_layout(1, 0, rgba, 720, 3072, 0)); + assert(!vkp_padded_linear_target_needs_layout(0, qcom_compressed, rgba, 720, 3072, 0)); +} + static void check_readback_order(void) { assert(vkp_linear_dmabuf_readback_stage(1) & VK_PIPELINE_STAGE_TRANSFER_BIT); assert(vkp_linear_dmabuf_readback_access(1) & VK_ACCESS_TRANSFER_WRITE_BIT); @@ -73,7 +83,7 @@ static void check_readback_order(void) { static void check_ownership(void) { const VkBuffer buffer = (VkBuffer)(uintptr_t)0x4321; const uint32_t queue_family = 3; - const VkBufferMemoryBarrier acquire = vkp_linear_dmabuf_ownership(buffer, queue_family, 1); + const VkBufferMemoryBarrier acquire = vkp_linear_dmabuf_ownership(buffer, queue_family, VK_ACCESS_TRANSFER_READ_BIT, 1); assert(acquire.sType == VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER); assert(acquire.pNext == NULL); assert(acquire.srcQueueFamilyIndex == VK_QUEUE_FAMILY_FOREIGN_EXT); @@ -84,7 +94,7 @@ static void check_ownership(void) { assert(acquire.offset == 0); assert(acquire.size == VK_WHOLE_SIZE); - const VkBufferMemoryBarrier release = vkp_linear_dmabuf_ownership(buffer, queue_family, 0); + const VkBufferMemoryBarrier release = vkp_linear_dmabuf_ownership(buffer, queue_family, VK_ACCESS_TRANSFER_READ_BIT, 0); assert(release.sType == VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER); assert(release.srcQueueFamilyIndex == queue_family); assert(release.dstQueueFamilyIndex == VK_QUEUE_FAMILY_FOREIGN_EXT); @@ -92,6 +102,13 @@ static void check_ownership(void) { assert(release.dstAccessMask == 0); assert(release.buffer == buffer); assert(release.size == VK_WHOLE_SIZE); + + const VkBufferMemoryBarrier write = vkp_linear_dmabuf_ownership(buffer, queue_family, VK_ACCESS_TRANSFER_WRITE_BIT, 1); + const VkBufferMemoryBarrier written = vkp_linear_dmabuf_ownership(buffer, queue_family, VK_ACCESS_TRANSFER_WRITE_BIT, 0); + assert(write.srcQueueFamilyIndex == VK_QUEUE_FAMILY_FOREIGN_EXT); + assert(write.dstAccessMask == VK_ACCESS_TRANSFER_WRITE_BIT); + assert(written.dstQueueFamilyIndex == VK_QUEUE_FAMILY_FOREIGN_EXT); + assert(written.srcAccessMask == VK_ACCESS_TRANSFER_WRITE_BIT); } int main(void) { @@ -99,6 +116,7 @@ int main(void) { check_offset_and_wide_texels(); check_rejected_layouts(); check_path_choice(); + check_padded_layer_targets(); check_foreign_image(); check_readback_order(); check_ownership();