| Flutter Impeller |

ahb_swapchain_impl_vk.h
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef FLUTTER_IMPELLER_RENDERER_BACKEND_VULKAN_SWAPCHAIN_AHB_AHB_SWAPCHAIN_IMPL_VK_H_
6 #define FLUTTER_IMPELLER_RENDERER_BACKEND_VULKAN_SWAPCHAIN_AHB_AHB_SWAPCHAIN_IMPL_VK_H_
7
8 #include <memory>
9
10 #include "flutter/fml/closure.h"
11 #include "impeller/base/thread.h"
12 #include "impeller/renderer/backend/vulkan/android/ahb_texture_source_vk.h"
13 #include "impeller/renderer/backend/vulkan/swapchain/ahb/ahb_texture_pool_vk.h"
14 #include "impeller/renderer/backend/vulkan/swapchain/ahb/external_semaphore_vk.h"
15 #include "impeller/renderer/backend/vulkan/swapchain/swapchain_transients_vk.h"
16 #include "impeller/renderer/surface.h"
17 #include "impeller/toolkit/android/hardware_buffer.h"
18 #include "impeller/toolkit/android/surface_control.h"
19 #include "impeller/toolkit/android/surface_transaction.h"
20 #include "vulkan/vulkan_handles.hpp"
21
22 namespace impeller {
23
24 using CreateTransactionCB = std::function<android::SurfaceTransaction()>;
25
26 static constexpr const size_t kMaxPendingPresents = 2u;
27
28 struct AHBFrameSynchronizerVK {
29 vk::UniqueFence acquire;
30 vk::UniqueSemaphore render_ready = {};
31 std::shared_ptr<ExternalSemaphoreVK> present_ready;
32 std::shared_ptr<CommandBuffer> final_cmd_buffer;
33 bool is_valid = false;
34
35 explicit AHBFrameSynchronizerVK(const vk::Device& device);
36
37 ~AHBFrameSynchronizerVK();
38
39 bool IsValid() const;
40
41 bool WaitForFence(const vk::Device& device);
42 };
43
44 //------------------------------------------------------------------------------
45 /// @brief The implementation of a swapchain at a specific size. Resizes to
46 /// the surface will cause the instance of the swapchain impl at
47 /// that size to be discarded along with all its caches and
48 /// transients.
49 ///
50 class AHBSwapchainImplVK final
51 : public std::enable_shared_from_this<AHBSwapchainImplVK> {
52 public:
53 //----------------------------------------------------------------------------
54 /// @brief Create a swapchain of a specific size whose images will be
55 /// presented to the provided surface control.
56 ///
57 /// @param[in] context The context whose allocators will be used to
58 /// create swapchain image resources.
59 /// @param[in] surface_control The surface control to which the swapchain
60 /// images will be presented.
61 /// @param[in] size The size of the swapchain images. This is
62 /// constant for the lifecycle of the swapchain
63 /// impl.
64 /// @param[in] enable_msaa If the swapchain images will be presented
65 /// using a render target that enables MSAA. This
66 /// allows for additional caching of transients.
67 ///
68 /// @return A valid swapchain impl if one can be created. `nullptr`
69 /// otherwise.
70 ///
71 static std::shared_ptr<AHBSwapchainImplVK> Create(
72 const std::weak_ptr<Context>& context,
73 std::weak_ptr<android::SurfaceControl> surface_control,
74 const CreateTransactionCB& cb,
75 const ISize& size,
76 bool enable_msaa,
77 size_t swapchain_image_count);
78
79 ~AHBSwapchainImplVK();
80
81 AHBSwapchainImplVK(const AHBSwapchainImplVK&) = delete;
82
83 AHBSwapchainImplVK& operator=(const AHBSwapchainImplVK&) = delete;
84
85 //----------------------------------------------------------------------------
86 /// @return The size of the swapchain images that will be displayed on the
87 /// surface control.
88 ///
89 const ISize& GetSize() const;
90
91 //----------------------------------------------------------------------------
92 /// @return If the swapchain impl is valid. If it is not, the instance
93 /// must be discarded. There is no error recovery.
94 ///
95 bool IsValid() const;
96
97 //----------------------------------------------------------------------------
98 /// @brief Get the descriptor used to create the hardware buffers that
99 /// will be displayed on the surface control.
100 ///
101 /// @return The descriptor.
102 ///
103 const android::HardwareBufferDescriptor& GetDescriptor() const;
104
105 //----------------------------------------------------------------------------
106 /// @brief Acquire the next surface that can be used to present to the
107 /// swapchain.
108 ///
109 /// @return A surface if one can be created. If one cannot be created, it
110 /// is likely due to resource exhaustion.
111 ///
112 std::unique_ptr<Surface> AcquireNextDrawable();
113
114 void AddFinalCommandBuffer(std::shared_ptr<CommandBuffer> cmd_buffer);
115
116 private:
117 using AutoSemaSignaler = std::shared_ptr<fml::ScopedCleanupClosure>;
118
119 std::weak_ptr<android::SurfaceControl> surface_control_;
120 android::HardwareBufferDescriptor desc_;
121 std::shared_ptr<AHBTexturePoolVK> pool_;
122 std::shared_ptr<SwapchainTransientsVK> transients_;
123
124 // In C++20, this mutex can be replaced by the shared pointer specialization
125 // of std::atomic.
126 Mutex currently_displayed_texture_mutex_;
127 std::shared_ptr<AHBTextureSourceVK> currently_displayed_texture_
128 IPLR_GUARDED_BY(currently_displayed_texture_mutex_);
129
130 std::vector<std::unique_ptr<AHBFrameSynchronizerVK>> frame_data_;
131 size_t frame_index_ = 0;
132 CreateTransactionCB cb_;
133 bool is_valid_ = false;
134
135 explicit AHBSwapchainImplVK(
136 const std::weak_ptr<Context>& context,
137 std::weak_ptr<android::SurfaceControl> surface_control,
138 const CreateTransactionCB& cb,
139 const ISize& size,
140 bool enable_msaa,
141 size_t swapchain_image_count);
142
143 bool Present(const std::shared_ptr<AHBTextureSourceVK>& texture);
144
145 vk::UniqueSemaphore CreateRenderReadySemaphore(
146 const std::shared_ptr<fml::UniqueFD>& fd) const;
147
148 bool ImportRenderReady(
149 const std::shared_ptr<fml::UniqueFD>& render_ready_fence,
150 const std::shared_ptr<AHBTextureSourceVK>& texture);
151
152 std::shared_ptr<ExternalSemaphoreVK> SubmitSignalForPresentReady(
153 const std::shared_ptr<AHBTextureSourceVK>& texture) const;
154
155 void OnTextureUpdatedOnSurfaceControl(
156 std::shared_ptr<AHBTextureSourceVK> texture,
157 ASurfaceTransactionStats* stats);
158 };
159
160 } // namespace impeller
161
162 #endif // FLUTTER_IMPELLER_RENDERER_BACKEND_VULKAN_SWAPCHAIN_AHB_AHB_SWAPCHAIN_IMPL_VK_H_
ahb_texture_pool_vk.h
ahb_texture_source_vk.h
impeller::AHBSwapchainImplVK
The implementation of a swapchain at a specific size. Resizes to the surface will cause the instance ...
Definition: ahb_swapchain_impl_vk.h:51
impeller::AHBSwapchainImplVK::IsValid
bool IsValid() const
Definition: ahb_swapchain_impl_vk.cc:115
impeller::AHBSwapchainImplVK::AHBSwapchainImplVK
AHBSwapchainImplVK(const AHBSwapchainImplVK &)=delete
impeller::AHBSwapchainImplVK::operator=
AHBSwapchainImplVK & operator=(const AHBSwapchainImplVK &)=delete
impeller::AHBSwapchainImplVK::AcquireNextDrawable
std::unique_ptr< Surface > AcquireNextDrawable()
Acquire the next surface that can be used to present to the swapchain.
Definition: ahb_swapchain_impl_vk.cc:124
impeller::AHBSwapchainImplVK::GetDescriptor
const android::HardwareBufferDescriptor & GetDescriptor() const
Get the descriptor used to create the hardware buffers that will be displayed on the surface control.
Definition: ahb_swapchain_impl_vk.cc:119
impeller::AHBSwapchainImplVK::AddFinalCommandBuffer
void AddFinalCommandBuffer(std::shared_ptr< CommandBuffer > cmd_buffer)
Definition: ahb_swapchain_impl_vk.cc:225
impeller::AHBSwapchainImplVK::Create
static std::shared_ptr< AHBSwapchainImplVK > Create(const std::weak_ptr< Context > &context, std::weak_ptr< android::SurfaceControl > surface_control, const CreateTransactionCB &cb, const ISize &size, bool enable_msaa, size_t swapchain_image_count)
Create a swapchain of a specific size whose images will be presented to the provided surface control.
Definition: ahb_swapchain_impl_vk.cc:66
impeller::AHBSwapchainImplVK::~AHBSwapchainImplVK
~AHBSwapchainImplVK()
impeller::AHBSwapchainImplVK::GetSize
const ISize & GetSize() const
Definition: ahb_swapchain_impl_vk.cc:111
impeller::android::SurfaceTransaction
A wrapper for ASurfaceTransaction. https://developer.android.com/ndk/reference/group/native-activity#...
Definition: surface_transaction.h:54
external_semaphore_vk.h
hardware_buffer.h
impeller
Definition: allocation.cc:12
impeller::CreateTransactionCB
std::function< android::SurfaceTransaction()> CreateTransactionCB
Definition: ahb_swapchain_impl_vk.h:24
impeller::kMaxPendingPresents
static constexpr const size_t kMaxPendingPresents
Definition: ahb_swapchain_impl_vk.h:26
surface.h
impeller::AHBFrameSynchronizerVK
Definition: ahb_swapchain_impl_vk.h:28
impeller::AHBFrameSynchronizerVK::~AHBFrameSynchronizerVK
~AHBFrameSynchronizerVK()
impeller::AHBFrameSynchronizerVK::is_valid
bool is_valid
Definition: ahb_swapchain_impl_vk.h:33
impeller::AHBFrameSynchronizerVK::final_cmd_buffer
std::shared_ptr< CommandBuffer > final_cmd_buffer
Definition: ahb_swapchain_impl_vk.h:32
impeller::AHBFrameSynchronizerVK::IsValid
bool IsValid() const
Definition: ahb_swapchain_impl_vk.cc:44
impeller::AHBFrameSynchronizerVK::AHBFrameSynchronizerVK
AHBFrameSynchronizerVK(const vk::Device &device)
Definition: ahb_swapchain_impl_vk.cc:31
impeller::AHBFrameSynchronizerVK::render_ready
vk::UniqueSemaphore render_ready
Definition: ahb_swapchain_impl_vk.h:30
impeller::AHBFrameSynchronizerVK::WaitForFence
bool WaitForFence(const vk::Device &device)
Definition: ahb_swapchain_impl_vk.cc:48
impeller::AHBFrameSynchronizerVK::acquire
vk::UniqueFence acquire
Definition: ahb_swapchain_impl_vk.h:29
impeller::AHBFrameSynchronizerVK::present_ready
std::shared_ptr< ExternalSemaphoreVK > present_ready
Definition: ahb_swapchain_impl_vk.h:31
impeller::TSize
Definition: size.h:25
impeller::android::HardwareBufferDescriptor
A descriptor use to specify hardware buffer allocations.
Definition: hardware_buffer.h:47
surface_control.h
surface_transaction.h
swapchain_transients_vk.h
thread.h