| // Copyright 2013 The Flutter Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "vulkan_swapchain.h" |
| |
| #include "flutter/vulkan/procs/vulkan_proc_table.h" |
| |
| #include "third_party/skia/include/core/SkColorSpace.h" |
| #include "third_party/skia/include/gpu/GrBackendSurface.h" |
| #include "third_party/skia/include/gpu/GrDirectContext.h" |
| #include "third_party/skia/include/gpu/vk/GrVkTypes.h" |
| |
| #include "vulkan_backbuffer.h" |
| #include "vulkan_device.h" |
| #include "vulkan_image.h" |
| #include "vulkan_surface.h" |
| |
| namespace vulkan { |
| |
| namespace { |
| struct FormatInfo { |
| VkFormat format_; |
| SkColorType color_type_; |
| sk_sp<SkColorSpace> color_space_; |
| }; |
| } // namespace |
| |
| static std::vector<FormatInfo> DesiredFormatInfos() { |
| return {{VK_FORMAT_R8G8B8A8_SRGB, kRGBA_8888_SkColorType, |
| SkColorSpace::MakeSRGB()}, |
| {VK_FORMAT_B8G8R8A8_SRGB, kRGBA_8888_SkColorType, |
| SkColorSpace::MakeSRGB()}, |
| {VK_FORMAT_R16G16B16A16_SFLOAT, kRGBA_F16_SkColorType, |
| SkColorSpace::MakeSRGBLinear()}, |
| {VK_FORMAT_R8G8B8A8_UNORM, kRGBA_8888_SkColorType, |
| SkColorSpace::MakeSRGB()}, |
| {VK_FORMAT_B8G8R8A8_UNORM, kRGBA_8888_SkColorType, |
| SkColorSpace::MakeSRGB()}}; |
| } |
| |
| VulkanSwapchain::VulkanSwapchain(const VulkanProcTable& p_vk, |
| const VulkanDevice& device, |
| const VulkanSurface& surface, |
| GrDirectContext* skia_context, |
| std::unique_ptr<VulkanSwapchain> old_swapchain, |
| uint32_t queue_family_index) |
| : vk(p_vk), |
| device_(device), |
| capabilities_(), |
| surface_format_(), |
| current_pipeline_stage_(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT), |
| current_backbuffer_index_(0), |
| current_image_index_(0), |
| valid_(false) { |
| if (!device_.IsValid() || !surface.IsValid() || skia_context == nullptr) { |
| FML_DLOG(INFO) << "Device or surface is invalid."; |
| return; |
| } |
| |
| if (!device_.GetSurfaceCapabilities(surface, &capabilities_)) { |
| FML_DLOG(INFO) << "Could not find surface capabilities."; |
| return; |
| } |
| |
| const auto format_infos = DesiredFormatInfos(); |
| std::vector<VkFormat> desired_formats(format_infos.size()); |
| for (size_t i = 0; i < format_infos.size(); ++i) { |
| if (skia_context->colorTypeSupportedAsSurface( |
| format_infos[i].color_type_)) { |
| desired_formats[i] = format_infos[i].format_; |
| } else { |
| desired_formats[i] = VK_FORMAT_UNDEFINED; |
| } |
| } |
| |
| int format_index = |
| device_.ChooseSurfaceFormat(surface, desired_formats, &surface_format_); |
| if (format_index < 0) { |
| FML_DLOG(INFO) << "Could not choose surface format."; |
| return; |
| } |
| |
| VkPresentModeKHR present_mode = VK_PRESENT_MODE_FIFO_KHR; |
| if (!device_.ChoosePresentMode(surface, &present_mode)) { |
| FML_DLOG(INFO) << "Could not choose present mode."; |
| return; |
| } |
| |
| // Check if the surface can present. |
| |
| VkBool32 supported = VK_FALSE; |
| if (VK_CALL_LOG_ERROR(vk.GetPhysicalDeviceSurfaceSupportKHR( |
| device_.GetPhysicalDeviceHandle(), // physical device |
| queue_family_index, // queue family |
| surface.Handle(), // surface to test |
| &supported)) != VK_SUCCESS) { |
| FML_DLOG(INFO) << "Could not get physical device surface support."; |
| return; |
| } |
| |
| if (supported != VK_TRUE) { |
| FML_DLOG(INFO) << "Surface was not supported by the physical device."; |
| return; |
| } |
| |
| // Construct the Swapchain |
| |
| VkSwapchainKHR old_swapchain_handle = VK_NULL_HANDLE; |
| |
| if (old_swapchain != nullptr && old_swapchain->IsValid()) { |
| old_swapchain_handle = old_swapchain->swapchain_; |
| // The unique pointer to the swapchain will go out of scope here |
| // and its handle collected after the appropriate device wait. |
| } |
| |
| VkSurfaceKHR surface_handle = surface.Handle(); |
| |
| VkImageUsageFlags usage_flags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | |
| VK_IMAGE_USAGE_TRANSFER_SRC_BIT | |
| VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| |
| const VkSwapchainCreateInfoKHR create_info = { |
| .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, |
| .pNext = nullptr, |
| .flags = 0, |
| .surface = surface_handle, |
| .minImageCount = capabilities_.minImageCount, |
| .imageFormat = surface_format_.format, |
| .imageColorSpace = surface_format_.colorSpace, |
| .imageExtent = capabilities_.currentExtent, |
| .imageArrayLayers = 1, |
| .imageUsage = usage_flags, |
| .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE, |
| .queueFamilyIndexCount = 0, // Because of the exclusive sharing mode. |
| .pQueueFamilyIndices = nullptr, |
| .preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, |
| .compositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR, |
| .presentMode = present_mode, |
| .clipped = VK_FALSE, |
| .oldSwapchain = old_swapchain_handle, |
| }; |
| |
| VkSwapchainKHR swapchain = VK_NULL_HANDLE; |
| |
| if (VK_CALL_LOG_ERROR(vk.CreateSwapchainKHR(device_.GetHandle(), &create_info, |
| nullptr, &swapchain)) != |
| VK_SUCCESS) { |
| FML_DLOG(INFO) << "Could not create the swapchain."; |
| return; |
| } |
| |
| swapchain_ = VulkanHandle<VkSwapchainKHR>{ |
| swapchain, [this](VkSwapchainKHR swapchain) { |
| FML_ALLOW_UNUSED_LOCAL(device_.WaitIdle()); |
| vk.DestroySwapchainKHR(device_.GetHandle(), swapchain, nullptr); |
| }}; |
| |
| if (!CreateSwapchainImages( |
| skia_context, format_infos[format_index].color_type_, |
| format_infos[format_index].color_space_, usage_flags)) { |
| FML_DLOG(INFO) << "Could not create swapchain images."; |
| return; |
| } |
| |
| valid_ = true; |
| } |
| |
| VulkanSwapchain::~VulkanSwapchain() = default; |
| |
| bool VulkanSwapchain::IsValid() const { |
| return valid_; |
| } |
| |
| std::vector<VkImage> VulkanSwapchain::GetImages() const { |
| uint32_t count = 0; |
| if (VK_CALL_LOG_ERROR(vk.GetSwapchainImagesKHR( |
| device_.GetHandle(), swapchain_, &count, nullptr)) != VK_SUCCESS) { |
| return {}; |
| } |
| |
| if (count == 0) { |
| return {}; |
| } |
| |
| std::vector<VkImage> images; |
| |
| images.resize(count); |
| |
| if (VK_CALL_LOG_ERROR(vk.GetSwapchainImagesKHR( |
| device_.GetHandle(), swapchain_, &count, images.data())) != |
| VK_SUCCESS) { |
| return {}; |
| } |
| |
| return images; |
| } |
| |
| SkISize VulkanSwapchain::GetSize() const { |
| VkExtent2D extents = capabilities_.currentExtent; |
| |
| if (extents.width < capabilities_.minImageExtent.width) { |
| extents.width = capabilities_.minImageExtent.width; |
| } else if (extents.width > capabilities_.maxImageExtent.width) { |
| extents.width = capabilities_.maxImageExtent.width; |
| } |
| |
| if (extents.height < capabilities_.minImageExtent.height) { |
| extents.height = capabilities_.minImageExtent.height; |
| } else if (extents.height > capabilities_.maxImageExtent.height) { |
| extents.height = capabilities_.maxImageExtent.height; |
| } |
| |
| return SkISize::Make(extents.width, extents.height); |
| } |
| |
| sk_sp<SkSurface> VulkanSwapchain::CreateSkiaSurface( |
| GrDirectContext* gr_context, |
| VkImage image, |
| VkImageUsageFlags usage_flags, |
| const SkISize& size, |
| SkColorType color_type, |
| sk_sp<SkColorSpace> color_space) const { |
| if (gr_context == nullptr) { |
| return nullptr; |
| } |
| |
| if (color_type == kUnknown_SkColorType) { |
| // Unexpected Vulkan format. |
| return nullptr; |
| } |
| |
| GrVkImageInfo image_info; |
| image_info.fImage = image; |
| image_info.fImageTiling = VK_IMAGE_TILING_OPTIMAL; |
| image_info.fImageLayout = VK_IMAGE_LAYOUT_UNDEFINED; |
| image_info.fFormat = surface_format_.format; |
| image_info.fImageUsageFlags = usage_flags; |
| image_info.fSampleCount = 1; |
| image_info.fLevelCount = 1; |
| |
| // TODO(chinmaygarde): Setup the stencil buffer and the sampleCnt. |
| GrBackendRenderTarget backend_render_target(size.fWidth, size.fHeight, 0, |
| image_info); |
| SkSurfaceProps props(0, kUnknown_SkPixelGeometry); |
| |
| return SkSurface::MakeFromBackendRenderTarget( |
| gr_context, // context |
| backend_render_target, // backend render target |
| kTopLeft_GrSurfaceOrigin, // origin |
| color_type, // color type |
| std::move(color_space), // color space |
| &props // surface properties |
| ); |
| } |
| |
| bool VulkanSwapchain::CreateSwapchainImages( |
| GrDirectContext* skia_context, |
| SkColorType color_type, |
| const sk_sp<SkColorSpace>& color_space, |
| VkImageUsageFlags usage_flags) { |
| std::vector<VkImage> images = GetImages(); |
| |
| if (images.empty()) { |
| return false; |
| } |
| |
| const SkISize surface_size = GetSize(); |
| |
| for (const VkImage& image : images) { |
| // Populate the backbuffer. |
| auto backbuffer = std::make_unique<VulkanBackbuffer>( |
| vk, device_.GetHandle(), device_.GetCommandPool()); |
| |
| if (!backbuffer->IsValid()) { |
| return false; |
| } |
| |
| backbuffers_.emplace_back(std::move(backbuffer)); |
| |
| // Populate the image. |
| VulkanHandle<VkImage> image_handle = VulkanHandle<VkImage>{ |
| image, [this](VkImage image) { |
| vk.DestroyImage(device_.GetHandle(), image, nullptr); |
| }}; |
| auto vulkan_image = std::make_unique<VulkanImage>(std::move(image_handle)); |
| |
| if (!vulkan_image->IsValid()) { |
| return false; |
| } |
| |
| images_.emplace_back(std::move(vulkan_image)); |
| |
| // Populate the surface. |
| auto surface = CreateSkiaSurface(skia_context, image, usage_flags, |
| surface_size, color_type, color_space); |
| |
| if (surface == nullptr) { |
| return false; |
| } |
| |
| surfaces_.emplace_back(std::move(surface)); |
| } |
| |
| FML_DCHECK(backbuffers_.size() == images_.size()); |
| FML_DCHECK(images_.size() == surfaces_.size()); |
| |
| return true; |
| } |
| |
| VulkanBackbuffer* VulkanSwapchain::GetNextBackbuffer() { |
| auto available_backbuffers = backbuffers_.size(); |
| |
| if (available_backbuffers == 0) { |
| return nullptr; |
| } |
| |
| auto next_backbuffer_index = |
| (current_backbuffer_index_ + 1) % backbuffers_.size(); |
| |
| auto& backbuffer = backbuffers_[next_backbuffer_index]; |
| |
| if (!backbuffer->IsValid()) { |
| return nullptr; |
| } |
| |
| current_backbuffer_index_ = next_backbuffer_index; |
| return backbuffer.get(); |
| } |
| |
| VulkanSwapchain::AcquireResult VulkanSwapchain::AcquireSurface() { |
| AcquireResult error = {AcquireStatus::ErrorSurfaceLost, nullptr}; |
| |
| if (!IsValid()) { |
| FML_DLOG(INFO) << "Swapchain was invalid."; |
| return error; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Step 0: |
| // Acquire the next available backbuffer. |
| // --------------------------------------------------------------------------- |
| auto backbuffer = GetNextBackbuffer(); |
| |
| if (backbuffer == nullptr) { |
| FML_DLOG(INFO) << "Could not get the next backbuffer."; |
| return error; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Step 1: |
| // Wait for use readiness. |
| // --------------------------------------------------------------------------- |
| if (!backbuffer->WaitFences()) { |
| FML_DLOG(INFO) << "Failed waiting on fences."; |
| return error; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Step 2: |
| // Put fences in an unsignaled state. |
| // --------------------------------------------------------------------------- |
| if (!backbuffer->ResetFences()) { |
| FML_DLOG(INFO) << "Could not reset fences."; |
| return error; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Step 3: |
| // Acquire the next image index. |
| // --------------------------------------------------------------------------- |
| uint32_t next_image_index = 0; |
| |
| VkResult acquire_result = VK_CALL_LOG_ERROR( |
| vk.AcquireNextImageKHR(device_.GetHandle(), // |
| swapchain_, // |
| std::numeric_limits<uint64_t>::max(), // |
| backbuffer->GetUsageSemaphore(), // |
| VK_NULL_HANDLE, // |
| &next_image_index)); |
| |
| switch (acquire_result) { |
| case VK_SUCCESS: |
| break; |
| case VK_ERROR_OUT_OF_DATE_KHR: |
| return {AcquireStatus::ErrorSurfaceOutOfDate, nullptr}; |
| case VK_ERROR_SURFACE_LOST_KHR: |
| return {AcquireStatus::ErrorSurfaceLost, nullptr}; |
| default: |
| FML_LOG(INFO) << "Unexpected result from AcquireNextImageKHR: " |
| << acquire_result; |
| return {AcquireStatus::ErrorSurfaceLost, nullptr}; |
| } |
| |
| // Simple sanity checking of image index. |
| if (next_image_index >= images_.size()) { |
| FML_DLOG(INFO) << "Image index returned was out-of-bounds."; |
| return error; |
| } |
| |
| auto& image = images_[next_image_index]; |
| if (!image->IsValid()) { |
| FML_DLOG(INFO) << "Image at index was invalid."; |
| return error; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Step 4: |
| // Start recording to the command buffer. |
| // --------------------------------------------------------------------------- |
| if (!backbuffer->GetUsageCommandBuffer().Begin()) { |
| FML_DLOG(INFO) << "Could not begin recording to the command buffer."; |
| return error; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Step 5: |
| // Set image layout to color attachment mode. |
| // --------------------------------------------------------------------------- |
| VkPipelineStageFlagBits destination_pipeline_stage = |
| VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; |
| VkImageLayout destination_image_layout = |
| VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; |
| |
| if (!image->InsertImageMemoryBarrier( |
| backbuffer->GetUsageCommandBuffer(), // command buffer |
| current_pipeline_stage_, // src_pipeline_bits |
| destination_pipeline_stage, // dest_pipeline_bits |
| VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // dest_access_flags |
| destination_image_layout // dest_layout |
| )) { |
| FML_DLOG(INFO) << "Could not insert image memory barrier."; |
| return error; |
| } else { |
| current_pipeline_stage_ = destination_pipeline_stage; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Step 6: |
| // End recording to the command buffer. |
| // --------------------------------------------------------------------------- |
| if (!backbuffer->GetUsageCommandBuffer().End()) { |
| FML_DLOG(INFO) << "Could not end recording to the command buffer."; |
| return error; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Step 7: |
| // Submit the command buffer to the device queue. |
| // --------------------------------------------------------------------------- |
| std::vector<VkSemaphore> wait_semaphores = {backbuffer->GetUsageSemaphore()}; |
| std::vector<VkSemaphore> signal_semaphores = {}; |
| std::vector<VkCommandBuffer> command_buffers = { |
| backbuffer->GetUsageCommandBuffer().Handle()}; |
| |
| if (!device_.QueueSubmit( |
| {destination_pipeline_stage}, // wait_dest_pipeline_stages |
| wait_semaphores, // wait_semaphores |
| signal_semaphores, // signal_semaphores |
| command_buffers, // command_buffers |
| backbuffer->GetUsageFence() // fence |
| )) { |
| FML_DLOG(INFO) << "Could not submit to the device queue."; |
| return error; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Step 8: |
| // Tell Skia about the updated image layout. |
| // --------------------------------------------------------------------------- |
| sk_sp<SkSurface> surface = surfaces_[next_image_index]; |
| |
| if (surface == nullptr) { |
| FML_DLOG(INFO) << "Could not access surface at the image index."; |
| return error; |
| } |
| |
| GrBackendRenderTarget backendRT = surface->getBackendRenderTarget( |
| SkSurface::kFlushRead_BackendHandleAccess); |
| if (!backendRT.isValid()) { |
| FML_DLOG(INFO) << "Could not get backend render target."; |
| return error; |
| } |
| backendRT.setVkImageLayout(destination_image_layout); |
| |
| current_image_index_ = next_image_index; |
| |
| return {AcquireStatus::Success, surface}; |
| } |
| |
| bool VulkanSwapchain::Submit() { |
| if (!IsValid()) { |
| FML_DLOG(INFO) << "Swapchain was invalid."; |
| return false; |
| } |
| |
| sk_sp<SkSurface> surface = surfaces_[current_image_index_]; |
| const std::unique_ptr<VulkanImage>& image = images_[current_image_index_]; |
| auto backbuffer = backbuffers_[current_backbuffer_index_].get(); |
| |
| // --------------------------------------------------------------------------- |
| // Step 0: |
| // Make sure Skia has flushed all work for the surface to the gpu. |
| // --------------------------------------------------------------------------- |
| surface->flushAndSubmit(); |
| |
| // --------------------------------------------------------------------------- |
| // Step 1: |
| // Start recording to the command buffer. |
| // --------------------------------------------------------------------------- |
| if (!backbuffer->GetRenderCommandBuffer().Begin()) { |
| FML_DLOG(INFO) << "Could not start recording to the command buffer."; |
| return false; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Step 2: |
| // Set image layout to present mode. |
| // --------------------------------------------------------------------------- |
| VkPipelineStageFlagBits destination_pipeline_stage = |
| VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT; |
| VkImageLayout destination_image_layout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; |
| |
| if (!image->InsertImageMemoryBarrier( |
| backbuffer->GetRenderCommandBuffer(), // command buffer |
| current_pipeline_stage_, // src_pipeline_bits |
| destination_pipeline_stage, // dest_pipeline_bits |
| VK_ACCESS_MEMORY_READ_BIT, // dest_access_flags |
| destination_image_layout // dest_layout |
| )) { |
| FML_DLOG(INFO) << "Could not insert memory barrier."; |
| return false; |
| } else { |
| current_pipeline_stage_ = destination_pipeline_stage; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Step 3: |
| // End recording to the command buffer. |
| // --------------------------------------------------------------------------- |
| if (!backbuffer->GetRenderCommandBuffer().End()) { |
| FML_DLOG(INFO) << "Could not end recording to the command buffer."; |
| return false; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Step 4: |
| // Submit the command buffer to the device queue. Tell it to signal the render |
| // semaphore. |
| // --------------------------------------------------------------------------- |
| std::vector<VkSemaphore> wait_semaphores = {}; |
| std::vector<VkSemaphore> queue_signal_semaphores = { |
| backbuffer->GetRenderSemaphore()}; |
| std::vector<VkCommandBuffer> command_buffers = { |
| backbuffer->GetRenderCommandBuffer().Handle()}; |
| |
| if (!device_.QueueSubmit( |
| {/* Empty. No wait semaphores. */}, // wait_dest_pipeline_stages |
| wait_semaphores, // wait_semaphores |
| queue_signal_semaphores, // signal_semaphores |
| command_buffers, // command_buffers |
| backbuffer->GetRenderFence() // fence |
| )) { |
| FML_DLOG(INFO) << "Could not submit to the device queue."; |
| return false; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Step 5: |
| // Submit the present operation and wait on the render semaphore. |
| // --------------------------------------------------------------------------- |
| VkSwapchainKHR swapchain = swapchain_; |
| uint32_t present_image_index = static_cast<uint32_t>(current_image_index_); |
| const VkPresentInfoKHR present_info = { |
| .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, |
| .pNext = nullptr, |
| .waitSemaphoreCount = |
| static_cast<uint32_t>(queue_signal_semaphores.size()), |
| .pWaitSemaphores = queue_signal_semaphores.data(), |
| .swapchainCount = 1, |
| .pSwapchains = &swapchain, |
| .pImageIndices = &present_image_index, |
| .pResults = nullptr, |
| }; |
| |
| if (VK_CALL_LOG_ERROR(vk.QueuePresentKHR(device_.GetQueueHandle(), |
| &present_info)) != VK_SUCCESS) { |
| FML_DLOG(INFO) << "Could not submit the present operation."; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| } // namespace vulkan |