1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef VULKANMANAGER_H
18#define VULKANMANAGER_H
19
20#include <SkSurface.h>
21#include <vk/GrVkBackendContext.h>
22
23#include <vulkan/vulkan.h>
24
25namespace android {
26namespace uirenderer {
27namespace renderthread {
28
29class RenderThread;
30
31class VulkanSurface {
32public:
33    VulkanSurface() {}
34
35    sk_sp<SkSurface> getBackBufferSurface() { return mBackbuffer; }
36
37private:
38    friend class VulkanManager;
39    struct BackbufferInfo {
40        uint32_t        mImageIndex;          // image this is associated with
41        VkSemaphore     mAcquireSemaphore;    // we signal on this for acquisition of image
42        VkSemaphore     mRenderSemaphore;     // we wait on this for rendering to be done
43        VkCommandBuffer mTransitionCmdBuffers[2]; // to transition layout between present and render
44        // We use these fences to make sure the above Command buffers have finished their work
45        // before attempting to reuse them or destroy them.
46        VkFence         mUsageFences[2];
47    };
48
49    struct ImageInfo {
50        VkImageLayout mImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
51        sk_sp<SkSurface> mSurface;
52        uint16_t mLastUsed = 0;
53        bool mInvalid = true;
54    };
55
56    sk_sp<SkSurface> mBackbuffer;
57
58    VkSurfaceKHR mVkSurface = VK_NULL_HANDLE;
59    VkSwapchainKHR mSwapchain = VK_NULL_HANDLE;
60
61    BackbufferInfo* mBackbuffers;
62    uint32_t mCurrentBackbufferIndex;
63
64    uint32_t mImageCount;
65    VkImage* mImages;
66    ImageInfo* mImageInfos;
67    uint16_t mCurrentTime = 0;
68};
69
70// This class contains the shared global Vulkan objects, such as VkInstance, VkDevice and VkQueue,
71// which are re-used by CanvasContext. This class is created once and should be used by all vulkan
72// windowing contexts. The VulkanManager must be initialized before use.
73class VulkanManager {
74public:
75    // Sets up the vulkan context that is shared amonst all clients of the VulkanManager. This must
76    // be call once before use of the VulkanManager. Multiple calls after the first will simiply
77    // return.
78    void initialize();
79
80    // Quick check to see if the VulkanManager has been initialized.
81    bool hasVkContext() { return mBackendContext.get() != nullptr; }
82
83    // Given a window this creates a new VkSurfaceKHR and VkSwapchain and stores them inside a new
84    // VulkanSurface object which is returned.
85    VulkanSurface* createSurface(ANativeWindow* window);
86
87    // Destroy the VulkanSurface and all associated vulkan objects.
88    void destroySurface(VulkanSurface* surface);
89
90    // Cleans up all the global state in the VulkanManger.
91    void destroy();
92
93    // No work is needed to make a VulkanSurface current, and all functions require that a
94    // VulkanSurface is passed into them so we just return true here.
95    bool isCurrent(VulkanSurface* surface) { return true; }
96
97    int getAge(VulkanSurface* surface);
98
99    // Returns an SkSurface which wraps the next image returned from vkAcquireNextImageKHR. It also
100    // will transition the VkImage from a present layout to color attachment so that it can be used
101    // by the client for drawing.
102    SkSurface* getBackbufferSurface(VulkanSurface* surface);
103
104    // Presents the current VkImage.
105    void swapBuffers(VulkanSurface* surface);
106
107private:
108    friend class RenderThread;
109
110    explicit VulkanManager(RenderThread& thread);
111    ~VulkanManager() { destroy(); }
112
113    void destroyBuffers(VulkanSurface* surface);
114
115    bool createSwapchain(VulkanSurface* surface);
116    void createBuffers(VulkanSurface* surface, VkFormat format, VkExtent2D extent);
117
118    VulkanSurface::BackbufferInfo* getAvailableBackbuffer(VulkanSurface* surface);
119
120    // simple wrapper class that exists only to initialize a pointer to NULL
121    template <typename FNPTR_TYPE> class VkPtr {
122    public:
123        VkPtr() : fPtr(NULL) {}
124        VkPtr operator=(FNPTR_TYPE ptr) { fPtr = ptr; return *this; }
125        operator FNPTR_TYPE() const { return fPtr; }
126    private:
127        FNPTR_TYPE fPtr;
128    };
129
130    // WSI interface functions
131    VkPtr<PFN_vkCreateAndroidSurfaceKHR> mCreateAndroidSurfaceKHR;
132    VkPtr<PFN_vkDestroySurfaceKHR> mDestroySurfaceKHR;
133    VkPtr<PFN_vkGetPhysicalDeviceSurfaceSupportKHR> mGetPhysicalDeviceSurfaceSupportKHR;
134    VkPtr<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR> mGetPhysicalDeviceSurfaceCapabilitiesKHR;
135    VkPtr<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR> mGetPhysicalDeviceSurfaceFormatsKHR;
136    VkPtr<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR> mGetPhysicalDeviceSurfacePresentModesKHR;
137
138    VkPtr<PFN_vkCreateSwapchainKHR> mCreateSwapchainKHR;
139    VkPtr<PFN_vkDestroySwapchainKHR> mDestroySwapchainKHR;
140    VkPtr<PFN_vkGetSwapchainImagesKHR> mGetSwapchainImagesKHR;
141    VkPtr<PFN_vkAcquireNextImageKHR> mAcquireNextImageKHR;
142    VkPtr<PFN_vkQueuePresentKHR> mQueuePresentKHR;
143    VkPtr<PFN_vkCreateSharedSwapchainsKHR> mCreateSharedSwapchainsKHR;
144
145    // Additional vulkan functions
146    VkPtr<PFN_vkCreateCommandPool> mCreateCommandPool;
147    VkPtr<PFN_vkDestroyCommandPool> mDestroyCommandPool;
148    VkPtr<PFN_vkAllocateCommandBuffers> mAllocateCommandBuffers;
149    VkPtr<PFN_vkFreeCommandBuffers> mFreeCommandBuffers;
150    VkPtr<PFN_vkResetCommandBuffer> mResetCommandBuffer;
151    VkPtr<PFN_vkBeginCommandBuffer> mBeginCommandBuffer;
152    VkPtr<PFN_vkEndCommandBuffer> mEndCommandBuffer;
153    VkPtr<PFN_vkCmdPipelineBarrier> mCmdPipelineBarrier;
154
155    VkPtr<PFN_vkGetDeviceQueue> mGetDeviceQueue;
156    VkPtr<PFN_vkQueueSubmit> mQueueSubmit;
157    VkPtr<PFN_vkQueueWaitIdle> mQueueWaitIdle;
158    VkPtr<PFN_vkDeviceWaitIdle> mDeviceWaitIdle;
159
160    VkPtr<PFN_vkCreateSemaphore> mCreateSemaphore;
161    VkPtr<PFN_vkDestroySemaphore> mDestroySemaphore;
162    VkPtr<PFN_vkCreateFence> mCreateFence;
163    VkPtr<PFN_vkDestroyFence> mDestroyFence;
164    VkPtr<PFN_vkWaitForFences> mWaitForFences;
165    VkPtr<PFN_vkResetFences> mResetFences;
166
167    RenderThread& mRenderThread;
168
169    sk_sp<const GrVkBackendContext> mBackendContext;
170    uint32_t mPresentQueueIndex;
171    VkQueue mPresentQueue = VK_NULL_HANDLE;
172    VkCommandPool mCommandPool = VK_NULL_HANDLE;
173
174    enum class SwapBehavior {
175        Discard,
176        BufferAge,
177    };
178    SwapBehavior mSwapBehavior = SwapBehavior::Discard;
179};
180
181} /* namespace renderthread */
182} /* namespace uirenderer */
183} /* namespace android */
184
185#endif /* VULKANMANAGER_H */
186
187