diff --git a/app/src/main/cpp/waylandcomp/src/blend_pass.c b/app/src/main/cpp/waylandcomp/src/blend_pass.c index 9a4d48d0b..2c9ee8a86 100644 --- a/app/src/main/cpp/waylandcomp/src/blend_pass.c +++ b/app/src/main/cpp/waylandcomp/src/blend_pass.c @@ -6,6 +6,7 @@ #include "blend_vert.h" #include "blend_frag.h" +#include "rotate_vert.h" struct pc_blend { float dst[4]; float src[4]; }; @@ -15,11 +16,11 @@ static VkSampler g_sampler; static VkDescriptorSetLayout g_dsl; static VkPipelineLayout g_pl; static VkDescriptorPool g_dpool; -static VkShaderModule g_vert, g_frag; +static VkShaderModule g_vert, g_frag, g_rot_vert; static unsigned g_frame = 1; #define NFMT 4 -static struct { VkFormat fmt; VkRenderPass rp; VkPipeline pipe; } g_out[NFMT]; +static struct { VkFormat fmt; VkRenderPass rp; VkPipeline pipe, rot; } g_out[NFMT]; #define NSRC 32 static struct { VkImage img; VkImageView view; VkDescriptorSet ds; unsigned frame; } g_src[NSRC]; @@ -85,10 +86,10 @@ static VkRenderPass make_rp(VkFormat fmt) { return rp; } -static VkPipeline make_pipe(VkRenderPass rp) { +static VkPipeline make_pipe(VkRenderPass rp, VkShaderModule vert, int blend) { VkPipelineShaderStageCreateInfo st[2] = { {.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, .stage = VK_SHADER_STAGE_VERTEX_BIT, - .module = g_vert, .pName = "main"}, + .module = vert, .pName = "main"}, {.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, .stage = VK_SHADER_STAGE_FRAGMENT_BIT, .module = g_frag, .pName = "main"}}; VkPipelineVertexInputStateCreateInfo vi = {.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO}; @@ -105,11 +106,12 @@ static VkPipeline make_pipe(VkRenderPass rp) { VkPipelineMultisampleStateCreateInfo ms = {.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT}; VkPipelineColorBlendAttachmentState ba = { - .blendEnable = VK_TRUE, .srcColorBlendFactor = VK_BLEND_FACTOR_ONE, + .blendEnable = blend ? VK_TRUE : VK_FALSE, .srcColorBlendFactor = VK_BLEND_FACTOR_ONE, .dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, .colorBlendOp = VK_BLEND_OP_ADD, .srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE, .dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, .alphaBlendOp = VK_BLEND_OP_ADD, - .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT}; + .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | + (blend ? 0 : VK_COLOR_COMPONENT_A_BIT)}; VkPipelineColorBlendStateCreateInfo cb = {.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, .attachmentCount = 1, .pAttachments = &ba}; VkGraphicsPipelineCreateInfo pi = {.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, .stageCount = 2, @@ -125,11 +127,12 @@ static VkPipeline make_pipe(VkRenderPass rp) { static void objects_destroy(void) { if (g_vert) g_vk.DestroyShaderModule(g_dev, g_vert, NULL); if (g_frag) g_vk.DestroyShaderModule(g_dev, g_frag, NULL); + if (g_rot_vert) g_vk.DestroyShaderModule(g_dev, g_rot_vert, NULL); if (g_dpool) g_vk.DestroyDescriptorPool(g_dev, g_dpool, NULL); if (g_pl) g_vk.DestroyPipelineLayout(g_dev, g_pl, NULL); if (g_dsl) g_vk.DestroyDescriptorSetLayout(g_dev, g_dsl, NULL); if (g_sampler) g_vk.DestroySampler(g_dev, g_sampler, NULL); - g_vert = g_frag = VK_NULL_HANDLE; g_dpool = VK_NULL_HANDLE; g_pl = VK_NULL_HANDLE; + g_vert = g_frag = g_rot_vert = VK_NULL_HANDLE; g_dpool = VK_NULL_HANDLE; g_pl = VK_NULL_HANDLE; g_dsl = VK_NULL_HANDLE; g_sampler = VK_NULL_HANDLE; } @@ -159,6 +162,7 @@ static int objects_ensure(void) { if (g_vk.CreateDescriptorPool(g_dev, &dpi, NULL, &g_dpool) != VK_SUCCESS) goto fail; if (!(g_vert = shader(blend_vert_code, sizeof(blend_vert_code)))) goto fail; if (!(g_frag = shader(blend_frag_code, sizeof(blend_frag_code)))) goto fail; + if (!(g_rot_vert = shader(rotate_vert_code, sizeof(rotate_vert_code)))) goto fail; g_ready = 1; droiddeck_log("gpu", "alpha composition ready on %s: translucent surfaces are blended over what is under them", vkp_gpu_name()); @@ -175,7 +179,7 @@ static int out_slot(VkFormat fmt) { for (i = 0; i < NFMT && g_out[i].pipe; i++) if (g_out[i].fmt == fmt) return i; if (i == NFMT) return -1; VkRenderPass rp = make_rp(fmt); - VkPipeline pipe = rp ? make_pipe(rp) : VK_NULL_HANDLE; + VkPipeline pipe = rp ? make_pipe(rp, g_vert, 1) : VK_NULL_HANDLE; if (!pipe) { if (rp) g_vk.DestroyRenderPass(g_dev, rp, NULL); return -1; @@ -303,3 +307,31 @@ int blendp_draw(VkCommandBuffer cmd, VkImage src, VkFormat src_fmt, int src_w, i if (!src_general) src_layout(cmd, src, sampled, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); return 0; } + +int blendp_rotate(VkCommandBuffer cmd, VkImage src, VkFormat src_fmt, int src_w, int src_h, + VkImage dst, VkFormat dst_fmt, int dst_w, int dst_h, int degrees) { + if (!src || !dst || src_w <= 0 || src_h <= 0 || dst_w <= 0 || dst_h <= 0 || objects_ensure() != 0) return -1; + if (degrees != 90 && degrees != 270) return -1; + int slot = out_slot(dst_fmt); + if (slot < 0) return -1; + if (!g_out[slot].rot && !(g_out[slot].rot = make_pipe(g_out[slot].rp, g_rot_vert, 0))) return -1; + VkDescriptorSet ds = src_ensure(src, src_fmt, VK_IMAGE_LAYOUT_GENERAL); + if (!ds) return -1; + VkFramebuffer fb = dst_ensure(dst, dst_fmt, dst_w, dst_h, g_out[slot].rp); + if (!fb) return -1; + struct pc_blend pc = {.dst = {-1.0f, -1.0f, 1.0f, 1.0f}}; + if (degrees == 90) { pc.src[0] = 0.0f; pc.src[1] = 1.0f; pc.src[2] = 1.0f; pc.src[3] = 0.0f; } + else { pc.src[0] = 1.0f; pc.src[1] = 0.0f; pc.src[2] = 0.0f; pc.src[3] = 1.0f; } + VkRenderPassBeginInfo rpi = {.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, .renderPass = g_out[slot].rp, + .framebuffer = fb, .renderArea = {{0, 0}, {(uint32_t)dst_w, (uint32_t)dst_h}}}; + VkViewport vp = {0, 0, (float)dst_w, (float)dst_h, 0, 1}; + g_vk.CmdBeginRenderPass(cmd, &rpi, VK_SUBPASS_CONTENTS_INLINE); + g_vk.CmdSetViewport(cmd, 0, 1, &vp); + g_vk.CmdSetScissor(cmd, 0, 1, &rpi.renderArea); + g_vk.CmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, g_out[slot].rot); + g_vk.CmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, g_pl, 0, 1, &ds, 0, NULL); + g_vk.CmdPushConstants(cmd, g_pl, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(pc), &pc); + g_vk.CmdDraw(cmd, 4, 1, 0, 0); + g_vk.CmdEndRenderPass(cmd); + return 0; +} diff --git a/app/src/main/cpp/waylandcomp/src/blend_pass.h b/app/src/main/cpp/waylandcomp/src/blend_pass.h index d6f5a8fff..6bf2c3fff 100644 --- a/app/src/main/cpp/waylandcomp/src/blend_pass.h +++ b/app/src/main/cpp/waylandcomp/src/blend_pass.h @@ -10,4 +10,7 @@ void blendp_begin_frame(void); int blendp_draw(VkCommandBuffer cmd, VkImage src, VkFormat src_fmt, int src_w, int src_h, int src_general, VkImage dst, VkFormat dst_fmt, int dst_w, int dst_h, const VkImageBlit *blit); +int blendp_rotate(VkCommandBuffer cmd, VkImage src, VkFormat src_fmt, int src_w, int src_h, + VkImage dst, VkFormat dst_fmt, int dst_w, int dst_h, int degrees); + #endif diff --git a/app/src/main/cpp/waylandcomp/src/rotate.vert b/app/src/main/cpp/waylandcomp/src/rotate.vert new file mode 100644 index 000000000..c6ee6cf74 --- /dev/null +++ b/app/src/main/cpp/waylandcomp/src/rotate.vert @@ -0,0 +1,9 @@ +#version 450 +layout(push_constant) uniform PC { vec4 dst; vec4 src; } pc; +layout(location = 0) out vec2 uv; + +void main() { + vec2 t = vec2(gl_VertexIndex & 1, gl_VertexIndex >> 1); + gl_Position = vec4(mix(pc.dst.xy, pc.dst.zw, t), 0.0, 1.0); + uv = mix(pc.src.xy, pc.src.zw, t.yx); +} diff --git a/app/src/main/cpp/waylandcomp/src/rotate_vert.h b/app/src/main/cpp/waylandcomp/src/rotate_vert.h new file mode 100644 index 000000000..eccfbd91f --- /dev/null +++ b/app/src/main/cpp/waylandcomp/src/rotate_vert.h @@ -0,0 +1,55 @@ + #pragma once +const uint32_t rotate_vert_code[] = { + 0x07230203,0x00010000,0x0008000b,0x0000003b,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, + 0x0008000f,0x00000000,0x00000004,0x6e69616d,0x00000000,0x0000000c,0x0000001b,0x00000031, + 0x00030003,0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d,0x00000000,0x00030005, + 0x00000009,0x00000074,0x00060005,0x0000000c,0x565f6c67,0x65747265,0x646e4978,0x00007865, + 0x00060005,0x00000019,0x505f6c67,0x65567265,0x78657472,0x00000000,0x00060006,0x00000019, + 0x00000000,0x505f6c67,0x7469736f,0x006e6f69,0x00070006,0x00000019,0x00000001,0x505f6c67, + 0x746e696f,0x657a6953,0x00000000,0x00070006,0x00000019,0x00000002,0x435f6c67,0x4470696c, + 0x61747369,0x0065636e,0x00070006,0x00000019,0x00000003,0x435f6c67,0x446c6c75,0x61747369, + 0x0065636e,0x00030005,0x0000001b,0x00000000,0x00030005,0x0000001d,0x00004350,0x00040006, + 0x0000001d,0x00000000,0x00747364,0x00040006,0x0000001d,0x00000001,0x00637273,0x00030005, + 0x0000001f,0x00006370,0x00030005,0x00000031,0x00007675,0x00040047,0x0000000c,0x0000000b, + 0x0000002a,0x00030047,0x00000019,0x00000002,0x00050048,0x00000019,0x00000000,0x0000000b, + 0x00000000,0x00050048,0x00000019,0x00000001,0x0000000b,0x00000001,0x00050048,0x00000019, + 0x00000002,0x0000000b,0x00000003,0x00050048,0x00000019,0x00000003,0x0000000b,0x00000004, + 0x00030047,0x0000001d,0x00000002,0x00050048,0x0000001d,0x00000000,0x00000023,0x00000000, + 0x00050048,0x0000001d,0x00000001,0x00000023,0x00000010,0x00040047,0x00000031,0x0000001e, + 0x00000000,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,0x00030016,0x00000006, + 0x00000020,0x00040017,0x00000007,0x00000006,0x00000002,0x00040020,0x00000008,0x00000007, + 0x00000007,0x00040015,0x0000000a,0x00000020,0x00000001,0x00040020,0x0000000b,0x00000001, + 0x0000000a,0x0004003b,0x0000000b,0x0000000c,0x00000001,0x0004002b,0x0000000a,0x0000000e, + 0x00000001,0x00040017,0x00000015,0x00000006,0x00000004,0x00040015,0x00000016,0x00000020, + 0x00000000,0x0004002b,0x00000016,0x00000017,0x00000001,0x0004001c,0x00000018,0x00000006, + 0x00000017,0x0006001e,0x00000019,0x00000015,0x00000006,0x00000018,0x00000018,0x00040020, + 0x0000001a,0x00000003,0x00000019,0x0004003b,0x0000001a,0x0000001b,0x00000003,0x0004002b, + 0x0000000a,0x0000001c,0x00000000,0x0004001e,0x0000001d,0x00000015,0x00000015,0x00040020, + 0x0000001e,0x00000009,0x0000001d,0x0004003b,0x0000001e,0x0000001f,0x00000009,0x00040020, + 0x00000020,0x00000009,0x00000015,0x0004002b,0x00000006,0x00000029,0x00000000,0x0004002b, + 0x00000006,0x0000002a,0x3f800000,0x00040020,0x0000002e,0x00000003,0x00000015,0x00040020, + 0x00000030,0x00000003,0x00000007,0x0004003b,0x00000030,0x00000031,0x00000003,0x00050036, + 0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000008, + 0x00000009,0x00000007,0x0004003d,0x0000000a,0x0000000d,0x0000000c,0x000500c7,0x0000000a, + 0x0000000f,0x0000000d,0x0000000e,0x0004006f,0x00000006,0x00000010,0x0000000f,0x0004003d, + 0x0000000a,0x00000011,0x0000000c,0x000500c3,0x0000000a,0x00000012,0x00000011,0x0000000e, + 0x0004006f,0x00000006,0x00000013,0x00000012,0x00050050,0x00000007,0x00000014,0x00000010, + 0x00000013,0x0003003e,0x00000009,0x00000014,0x00050041,0x00000020,0x00000021,0x0000001f, + 0x0000001c,0x0004003d,0x00000015,0x00000022,0x00000021,0x0007004f,0x00000007,0x00000023, + 0x00000022,0x00000022,0x00000000,0x00000001,0x00050041,0x00000020,0x00000024,0x0000001f, + 0x0000001c,0x0004003d,0x00000015,0x00000025,0x00000024,0x0007004f,0x00000007,0x00000026, + 0x00000025,0x00000025,0x00000002,0x00000003,0x0004003d,0x00000007,0x00000027,0x00000009, + 0x0008000c,0x00000007,0x00000028,0x00000001,0x0000002e,0x00000023,0x00000026,0x00000027, + 0x00050051,0x00000006,0x0000002b,0x00000028,0x00000000,0x00050051,0x00000006,0x0000002c, + 0x00000028,0x00000001,0x00070050,0x00000015,0x0000002d,0x0000002b,0x0000002c,0x00000029, + 0x0000002a,0x00050041,0x0000002e,0x0000002f,0x0000001b,0x0000001c,0x0003003e,0x0000002f, + 0x0000002d,0x00050041,0x00000020,0x00000032,0x0000001f,0x0000000e,0x0004003d,0x00000015, + 0x00000033,0x00000032,0x0007004f,0x00000007,0x00000034,0x00000033,0x00000033,0x00000000, + 0x00000001,0x00050041,0x00000020,0x00000035,0x0000001f,0x0000000e,0x0004003d,0x00000015, + 0x00000036,0x00000035,0x0007004f,0x00000007,0x00000037,0x00000036,0x00000036,0x00000002, + 0x00000003,0x0004003d,0x00000007,0x00000038,0x00000009,0x0007004f,0x00000007,0x00000039, + 0x00000038,0x00000038,0x00000001,0x00000000,0x0008000c,0x00000007,0x0000003a,0x00000001, + 0x0000002e,0x00000034,0x00000037,0x00000039,0x0003003e,0x00000031,0x0000003a,0x000100fd, + 0x00010038 +}; diff --git a/app/src/main/cpp/waylandcomp/src/vk_present.c b/app/src/main/cpp/waylandcomp/src/vk_present.c index 8d6b3480a..d8a060fc1 100644 --- a/app/src/main/cpp/waylandcomp/src/vk_present.c +++ b/app/src/main/cpp/waylandcomp/src/vk_present.c @@ -116,7 +116,8 @@ static VkResult timed_wait(VkFence fence, uint64_t timeout) { static struct { VkImage img; VkDeviceMemory mem; int w, h; } g_scene; struct vkp_img_slot { VkImage img; VkDeviceMemory mem; int w, h; VkFormat fmt; }; -static struct vkp_img_slot g_mixed, g_hdrscene, g_fgscene; +static struct vkp_img_slot g_mixed, g_hdrscene, g_fgscene, g_land; +static int g_prerot, g_prerot_failed; #define HDR_FMT VK_FORMAT_A2B10G10R10_UNORM_PACK32 #define FG_HDR_FMT VK_FORMAT_R16G16B16A16_SFLOAT @@ -661,6 +662,20 @@ static void log_surface_formats(const VkSurfaceFormatKHR *f, uint32_t n) { hdr_n ? hdr : "none", hdr_cut ? " (+more)" : ""); } +struct vkp_img_slot; +static int ensure_img(struct vkp_img_slot *s, int w, int h, VkFormat fmt, VkImageUsageFlags usage, const char *what); + +static int prerotate_degrees(const VkSurfaceCapabilitiesKHR *caps) { + if (g_prerot_failed) return 0; + char v[PROP_VALUE_MAX] = ""; + __system_property_get("debug.droiddeck.prerotate", v); + if (v[0] == '0') return 0; + if (!(caps->supportedTransforms & caps->currentTransform)) return 0; + if (caps->currentTransform == VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR) return 90; + if (caps->currentTransform == VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR) return 270; + return 0; +} + static int swap_init_locked(void) { VkAndroidSurfaceCreateInfoKHR aci = { @@ -733,11 +748,18 @@ static int swap_init_locked(void) { VkSurfaceTransformFlagBitsKHR pretrans = (caps.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) ? VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR : caps.currentTransform; + g_prerot = prerotate_degrees(&caps); + VkExtent2D image_extent = g_extent; + if (g_prerot) { + pretrans = caps.currentTransform; + image_extent.width = g_extent.height; + image_extent.height = g_extent.width; + } VkSwapchainCreateInfoKHR sci = { .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, .surface = g_surface, .minImageCount = want, .imageFormat = chosen.format, .imageColorSpace = chosen.colorSpace, - .imageExtent = g_extent, .imageArrayLayers = 1, + .imageExtent = image_extent, .imageArrayLayers = 1, .imageUsage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE, .preTransform = pretrans, .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, @@ -754,6 +776,17 @@ static int swap_init_locked(void) { g_swap_fmt = sdr_choice.format; cr = g_vk.CreateSwapchainKHR(g_dev, &sci, NULL, &g_swapchain); } + if (cr != VK_SUCCESS && g_prerot) { + droiddeck_log("gpu", "the driver refused a swapchain turned for the panel (%s): the display rotates the " + "picture instead", vk_result_name(cr)); + g_prerot = 0; + g_prerot_failed = 1; + g_swapchain = VK_NULL_HANDLE; + sci.preTransform = (caps.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) + ? VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR : caps.currentTransform; + sci.imageExtent = g_extent; + cr = g_vk.CreateSwapchainKHR(g_dev, &sci, NULL, &g_swapchain); + } if (cr != VK_SUCCESS) { g_swapchain = VK_NULL_HANDLE; SWLOGE("present: vkCreateSwapchainKHR failed (%d)", (int)cr); @@ -762,6 +795,18 @@ static int swap_init_locked(void) { g_vk.GetSwapchainImagesKHR(g_dev, g_swapchain, &g_nimg, NULL); g_images = calloc(g_nimg, sizeof(VkImage)); g_vk.GetSwapchainImagesKHR(g_dev, g_swapchain, &g_nimg, g_images); + if (g_prerot && ensure_img(&g_land, (int)g_extent.width, (int)g_extent.height, g_swap_fmt, + VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | + VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, + "panel rotation") != 0) { + g_prerot_failed = 1; + droiddeck_log("gpu", "the panel-rotation image could not be made: the display rotates the picture instead"); + destroy_swapchain(); + return -1; + } + if (g_prerot) + droiddeck_log("gpu", "the panel is mounted at %d degrees: frames are turned on the GPU before they are shown, " + "so the display hardware can show the game layer directly", g_prerot); droiddeck_log("gpu", "screen output %ux%u, %u buffers, vsync%s", g_extent.width, g_extent.height, g_nimg, g_swap_extra ? " (frame generation: several presents per frame)" : ""); @@ -1345,6 +1390,53 @@ static const char *vk_result_name(VkResult r) { } +static VkImage out_image(uint32_t img) { + return g_prerot ? g_land.img : g_images[img]; +} + +static void finish_out_image(VkCommandBuffer cmd, uint32_t img) { + VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; + if (!g_prerot) { + VkImageMemoryBarrier b_present = { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = g_images[img], + .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, &b_present); + return; + } + VkImageMemoryBarrier pre[2] = { + {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + .newLayout = VK_IMAGE_LAYOUT_GENERAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = g_land.img, .subresourceRange = range, + .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, + .dstAccessMask = VK_ACCESS_SHADER_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_IGNORED, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = g_images[img], .subresourceRange = range, + .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT}}; + g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, + 0, 0, NULL, 0, NULL, 2, pre); + VkClearColorValue black = {.float32 = {0.0f, 0.0f, 0.0f, 1.0f}}; + g_vk.CmdClearColorImage(cmd, g_images[img], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &black, 1, &range); + if (blendp_rotate(cmd, g_land.img, g_swap_fmt, (int)g_extent.width, (int)g_extent.height, g_images[img], + g_swap_fmt, (int)g_extent.height, (int)g_extent.width, g_prerot) != 0 && !g_prerot_failed) { + g_prerot_failed = 1; + droiddeck_log("gpu", "the panel-rotation pass could not be built on this driver: the display rotates the " + "picture from the next frame"); + g_surface_checked_ns = 0; + } + VkImageMemoryBarrier b_present = { + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = g_images[img], .subresourceRange = range, + .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT}; + g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0, NULL, 1, &b_present); +} + static void record_screen_blit(VkCommandBuffer cmd, VkImage src, int src_w, int src_h, int scene_w, int scene_h, uint32_t img, VkFilter filter, int cardboard) { VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; @@ -1370,7 +1462,7 @@ static void record_screen_blit(VkCommandBuffer cmd, VkImage src, int src_w, int {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, - .image = g_images[img], .subresourceRange = range, .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT}, + .image = out_image(img), .subresourceRange = range, .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT}, {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_GENERAL, .newLayout = VK_IMAGE_LAYOUT_GENERAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, @@ -1387,9 +1479,9 @@ static void record_screen_blit(VkCommandBuffer cmd, VkImage src, int src_w, int .srcOffsets = {{0, 0, 0}, {src_w, src_h, 1}}, .dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, .dstOffsets = {{0, 0, 0}, {src_w, src_h, 1}}}; - if (!have_blit || !record_bars_clear(cmd, g_images[img], &blit)) { + if (!have_blit || !record_bars_clear(cmd, out_image(img), &blit)) { VkClearColorValue black = {.float32 = {0.0f, 0.0f, 0.0f, 1.0f}}; - g_vk.CmdClearColorImage(cmd, g_images[img], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &black, 1, &range); + g_vk.CmdClearColorImage(cmd, out_image(img), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &black, 1, &range); } VkMemoryBarrier mb = {.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER, .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, @@ -1397,15 +1489,9 @@ static void record_screen_blit(VkCommandBuffer cmd, VkImage src, int src_w, int g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &mb, 0, NULL, 0, NULL); if (have_blit) - g_vk.CmdBlitImage(cmd, src, VK_IMAGE_LAYOUT_GENERAL, g_images[img], + g_vk.CmdBlitImage(cmd, src, VK_IMAGE_LAYOUT_GENERAL, out_image(img), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit, filter); - VkImageMemoryBarrier b_present = { - .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, - .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = g_images[img], - .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, &b_present); + finish_out_image(cmd, img); } static int acquire_image(int k, int first, uint32_t *img, VkResult *ar_out) { @@ -1439,6 +1525,10 @@ int vkp_render_plain(int scene_w, int scene_h) { static void check_surface_changed(void) { if (!g_swapchain || !g_surface || g_dev_state != 1) return; + if (g_prerot && g_prerot_failed) { + destroy_swapchain(); + return; + } const int64_t now = perf_now(); if (now - g_surface_checked_ns < 100000000LL) return; g_surface_checked_ns = now; @@ -1612,7 +1702,7 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, - .image = pass ? scene_img : g_images[img], .subresourceRange = range, + .image = pass ? scene_img : out_image(img), .subresourceRange = range, .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT}; for (int i = 0; i < n; i++) { struct vkp_image *im = draws[i].img; @@ -1636,11 +1726,11 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i } } g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_HOST_BIT | VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT | - (pass ? VK_PIPELINE_STAGE_ALL_COMMANDS_BIT : 0), + ((pass || g_prerot) ? VK_PIPELINE_STAGE_ALL_COMMANDS_BIT : 0), VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, (uint32_t)nb, bars); free(bars); - VkImage target = pass ? scene_img : g_images[img]; + VkImage target = pass ? scene_img : out_image(img); int covered = 0; VkImageBlit cover_blit; if (!(hf && pass)) { @@ -1687,13 +1777,7 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i VkImage result = scene_img; int rw = scene_w, rh = scene_h; if (!pass) { - VkImageMemoryBarrier b_present = { - .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, - .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = g_images[img], - .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, &b_present); + finish_out_image(cmd, img); } else { VkImageLayout result_layout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; if (fx) { diff --git a/tools/tests/test_panel_rotation.py b/tools/tests/test_panel_rotation.py new file mode 100644 index 000000000..a59ce29fb --- /dev/null +++ b/tools/tests/test_panel_rotation.py @@ -0,0 +1,59 @@ +from pathlib import Path +import re +import shutil +import subprocess +import tempfile +import unittest + +ROOT = Path(__file__).resolve().parents[2] +SRC = ROOT / 'app' / 'src' / 'main' / 'cpp' / 'waylandcomp' / 'src' + + +def spirv_words(header): + return re.findall(r'0x[0-9a-fA-F]{8}', header) + + +@unittest.skipUnless(shutil.which('glslangValidator'), 'needs glslangValidator') +class RotateShaderTest(unittest.TestCase): + def test_committed_spirv_matches_the_glsl(self): + with tempfile.TemporaryDirectory() as folder: + out = Path(folder) / 'rotate_vert.h' + subprocess.run(['glslangValidator', '-V', '--vn', 'rotate_vert_code', '-o', str(out), + str(SRC / 'rotate.vert')], check=True, capture_output=True) + self.assertEqual(spirv_words(out.read_text()), spirv_words((SRC / 'rotate_vert.h').read_text())) + + def test_push_constants_match_the_blend_pass(self): + rotate = (SRC / 'rotate.vert').read_text() + blend = (SRC / 'blend.vert').read_text() + pattern = r'uniform PC \{[^}]*\}' + self.assertEqual(re.search(pattern, blend).group(0), re.search(pattern, rotate).group(0)) + + +class PanelRotationSourceTest(unittest.TestCase): + def setUp(self): + self.present = (SRC / 'vk_present.c').read_text() + + def function(self, name): + start = self.present.index(name) + return self.present[start:self.present.index('\n}\n', start)] + + def test_only_the_final_pass_touches_swapchain_images_while_rotating(self): + for name in ('static void record_screen_blit(', 'static int render_impl('): + self.assertNotIn('g_images[img]', self.function(name), name) + + def test_rotation_is_limited_to_quarter_turns_and_can_be_switched_off(self): + body = self.function('static int prerotate_degrees(') + self.assertIn('debug.droiddeck.prerotate', body) + self.assertIn('ROTATE_90_BIT_KHR) return 90', body) + self.assertIn('ROTATE_270_BIT_KHR) return 270', body) + self.assertNotIn('ROTATE_180', body) + self.assertIn('if (g_prerot_failed) return 0;', body) + + def test_a_refused_rotated_swapchain_falls_back_to_the_display_rotating(self): + body = self.function('static int swap_init_locked(void) {') + self.assertIn('cr != VK_SUCCESS && g_prerot', body) + self.assertIn('sci.imageExtent = g_extent;', body) + + +if __name__ == '__main__': + unittest.main()