1 /*
2 * Copyright 2015 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "src/gpu/GrGpuResourcePriv.h"
9 #include "src/gpu/vk/GrVkGpu.h"
10 #include "src/gpu/vk/GrVkImage.h"
11 #include "src/gpu/vk/GrVkMemory.h"
12 #include "src/gpu/vk/GrVkTexture.h"
13 #include "src/gpu/vk/GrVkUtil.h"
14
15 #define VK_CALL(GPU, X) GR_VK_CALL(GPU->vkInterface(), X)
16
LayoutToPipelineSrcStageFlags(const VkImageLayout layout)17 VkPipelineStageFlags GrVkImage::LayoutToPipelineSrcStageFlags(const VkImageLayout layout) {
18 if (VK_IMAGE_LAYOUT_GENERAL == layout) {
19 return VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
20 } else if (VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == layout ||
21 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL == layout) {
22 return VK_PIPELINE_STAGE_TRANSFER_BIT;
23 } else if (VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL == layout) {
24 return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
25 } else if (VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL == layout ||
26 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL == layout) {
27 return VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
28 } else if (VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == layout) {
29 return VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
30 } else if (VK_IMAGE_LAYOUT_PREINITIALIZED == layout) {
31 return VK_PIPELINE_STAGE_HOST_BIT;
32 } else if (VK_IMAGE_LAYOUT_PRESENT_SRC_KHR == layout) {
33 return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
34 }
35
36 SkASSERT(VK_IMAGE_LAYOUT_UNDEFINED == layout);
37 return VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
38 }
39
LayoutToSrcAccessMask(const VkImageLayout layout)40 VkAccessFlags GrVkImage::LayoutToSrcAccessMask(const VkImageLayout layout) {
41 // Currently we assume we will never being doing any explict shader writes (this doesn't include
42 // color attachment or depth/stencil writes). So we will ignore the
43 // VK_MEMORY_OUTPUT_SHADER_WRITE_BIT.
44
45 // We can only directly access the host memory if we are in preinitialized or general layout,
46 // and the image is linear.
47 // TODO: Add check for linear here so we are not always adding host to general, and we should
48 // only be in preinitialized if we are linear
49 VkAccessFlags flags = 0;
50 if (VK_IMAGE_LAYOUT_GENERAL == layout) {
51 flags = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
52 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
53 VK_ACCESS_TRANSFER_WRITE_BIT |
54 VK_ACCESS_TRANSFER_READ_BIT |
55 VK_ACCESS_SHADER_READ_BIT |
56 VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_HOST_READ_BIT;
57 } else if (VK_IMAGE_LAYOUT_PREINITIALIZED == layout) {
58 flags = VK_ACCESS_HOST_WRITE_BIT;
59 } else if (VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL == layout) {
60 flags = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
61 } else if (VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL == layout) {
62 flags = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
63 } else if (VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL == layout) {
64 flags = VK_ACCESS_TRANSFER_WRITE_BIT;
65 } else if (VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == layout ||
66 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == layout ||
67 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR == layout) {
68 // There are no writes that need to be made available
69 flags = 0;
70 }
71 return flags;
72 }
73
vk_format_to_aspect_flags(VkFormat format)74 VkImageAspectFlags vk_format_to_aspect_flags(VkFormat format) {
75 switch (format) {
76 case VK_FORMAT_S8_UINT:
77 return VK_IMAGE_ASPECT_STENCIL_BIT;
78 case VK_FORMAT_D24_UNORM_S8_UINT: // fallthrough
79 case VK_FORMAT_D32_SFLOAT_S8_UINT:
80 return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
81 default:
82 return VK_IMAGE_ASPECT_COLOR_BIT;
83 }
84 }
85
setImageLayout(const GrVkGpu * gpu,VkImageLayout newLayout,VkAccessFlags dstAccessMask,VkPipelineStageFlags dstStageMask,bool byRegion,bool releaseFamilyQueue)86 void GrVkImage::setImageLayout(const GrVkGpu* gpu, VkImageLayout newLayout,
87 VkAccessFlags dstAccessMask,
88 VkPipelineStageFlags dstStageMask,
89 bool byRegion, bool releaseFamilyQueue) {
90 SkASSERT(VK_IMAGE_LAYOUT_UNDEFINED != newLayout &&
91 VK_IMAGE_LAYOUT_PREINITIALIZED != newLayout);
92 VkImageLayout currentLayout = this->currentLayout();
93
94 if (releaseFamilyQueue && fInfo.fCurrentQueueFamily == fInitialQueueFamily &&
95 newLayout == currentLayout) {
96 // We never transfered the image to this queue and we are releasing it so don't do anything.
97 return;
98 }
99
100 // If the old and new layout are the same and the layout is a read only layout, there is no need
101 // to put in a barrier unless we also need to switch queues.
102 if (newLayout == currentLayout && !releaseFamilyQueue &&
103 (fInfo.fCurrentQueueFamily == VK_QUEUE_FAMILY_IGNORED ||
104 fInfo.fCurrentQueueFamily == gpu->queueIndex()) &&
105 (VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL == currentLayout ||
106 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == currentLayout ||
107 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == currentLayout)) {
108 return;
109 }
110
111 VkAccessFlags srcAccessMask = GrVkImage::LayoutToSrcAccessMask(currentLayout);
112 VkPipelineStageFlags srcStageMask = GrVkImage::LayoutToPipelineSrcStageFlags(currentLayout);
113
114 VkImageAspectFlags aspectFlags = vk_format_to_aspect_flags(fInfo.fFormat);
115
116 uint32_t srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
117 uint32_t dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
118 if (fInfo.fCurrentQueueFamily != VK_QUEUE_FAMILY_IGNORED &&
119 gpu->queueIndex() != fInfo.fCurrentQueueFamily) {
120 // The image still is owned by its original queue family and we need to transfer it into
121 // ours.
122 SkASSERT(!releaseFamilyQueue);
123 SkASSERT(fInfo.fCurrentQueueFamily == fInitialQueueFamily);
124
125 srcQueueFamilyIndex = fInfo.fCurrentQueueFamily;
126 dstQueueFamilyIndex = gpu->queueIndex();
127 fInfo.fCurrentQueueFamily = gpu->queueIndex();
128 } else if (releaseFamilyQueue) {
129 // We are releasing the image so we must transfer the image back to its original queue
130 // family.
131 srcQueueFamilyIndex = fInfo.fCurrentQueueFamily;
132 dstQueueFamilyIndex = fInitialQueueFamily;
133 fInfo.fCurrentQueueFamily = fInitialQueueFamily;
134 }
135
136 VkImageMemoryBarrier imageMemoryBarrier = {
137 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
138 nullptr, // pNext
139 srcAccessMask, // srcAccessMask
140 dstAccessMask, // dstAccessMask
141 currentLayout, // oldLayout
142 newLayout, // newLayout
143 srcQueueFamilyIndex, // srcQueueFamilyIndex
144 dstQueueFamilyIndex, // dstQueueFamilyIndex
145 fInfo.fImage, // image
146 { aspectFlags, 0, fInfo.fLevelCount, 0, 1 } // subresourceRange
147 };
148
149 gpu->addImageMemoryBarrier(this->resource(), srcStageMask, dstStageMask, byRegion,
150 &imageMemoryBarrier);
151
152 this->updateImageLayout(newLayout);
153 }
154
InitImageInfo(const GrVkGpu * gpu,const ImageDesc & imageDesc,GrVkImageInfo * info)155 bool GrVkImage::InitImageInfo(const GrVkGpu* gpu, const ImageDesc& imageDesc, GrVkImageInfo* info) {
156 if (0 == imageDesc.fWidth || 0 == imageDesc.fHeight) {
157 return false;
158 }
159 if ((imageDesc.fIsProtected == GrProtected::kYes) && !gpu->vkCaps().supportsProtectedMemory()) {
160 return false;
161 }
162 VkImage image = VK_NULL_HANDLE;
163 GrVkAlloc alloc;
164
165 bool isLinear = VK_IMAGE_TILING_LINEAR == imageDesc.fImageTiling;
166 VkImageLayout initialLayout = isLinear ? VK_IMAGE_LAYOUT_PREINITIALIZED
167 : VK_IMAGE_LAYOUT_UNDEFINED;
168
169 // Create Image
170 VkSampleCountFlagBits vkSamples;
171 if (!GrSampleCountToVkSampleCount(imageDesc.fSamples, &vkSamples)) {
172 return false;
173 }
174
175 SkASSERT(VK_IMAGE_TILING_OPTIMAL == imageDesc.fImageTiling ||
176 VK_SAMPLE_COUNT_1_BIT == vkSamples);
177
178 VkImageCreateFlags createflags = 0;
179 if (imageDesc.fIsProtected == GrProtected::kYes || gpu->protectedContext()) {
180 createflags |= VK_IMAGE_CREATE_PROTECTED_BIT;
181 }
182 const VkImageCreateInfo imageCreateInfo = {
183 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // sType
184 nullptr, // pNext
185 createflags, // VkImageCreateFlags
186 imageDesc.fImageType, // VkImageType
187 imageDesc.fFormat, // VkFormat
188 { imageDesc.fWidth, imageDesc.fHeight, 1 }, // VkExtent3D
189 imageDesc.fLevels, // mipLevels
190 1, // arrayLayers
191 vkSamples, // samples
192 imageDesc.fImageTiling, // VkImageTiling
193 imageDesc.fUsageFlags, // VkImageUsageFlags
194 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode
195 0, // queueFamilyCount
196 0, // pQueueFamilyIndices
197 initialLayout // initialLayout
198 };
199
200 GR_VK_CALL_ERRCHECK(gpu->vkInterface(), CreateImage(gpu->device(), &imageCreateInfo, nullptr,
201 &image));
202
203 if (!GrVkMemory::AllocAndBindImageMemory(gpu, image, isLinear, &alloc)) {
204 VK_CALL(gpu, DestroyImage(gpu->device(), image, nullptr));
205 return false;
206 }
207
208 info->fImage = image;
209 info->fAlloc = alloc;
210 info->fImageTiling = imageDesc.fImageTiling;
211 info->fImageLayout = initialLayout;
212 info->fFormat = imageDesc.fFormat;
213 info->fLevelCount = imageDesc.fLevels;
214 info->fCurrentQueueFamily = VK_QUEUE_FAMILY_IGNORED;
215 info->fProtected =
216 (createflags & VK_IMAGE_CREATE_PROTECTED_BIT) ? GrProtected::kYes : GrProtected::kNo;
217 return true;
218 }
219
DestroyImageInfo(const GrVkGpu * gpu,GrVkImageInfo * info)220 void GrVkImage::DestroyImageInfo(const GrVkGpu* gpu, GrVkImageInfo* info) {
221 VK_CALL(gpu, DestroyImage(gpu->device(), info->fImage, nullptr));
222 bool isLinear = VK_IMAGE_TILING_LINEAR == info->fImageTiling;
223 GrVkMemory::FreeImageMemory(gpu, isLinear, info->fAlloc);
224 }
225
~GrVkImage()226 GrVkImage::~GrVkImage() {
227 // should have been released or abandoned first
228 SkASSERT(!fResource);
229 }
230
prepareForPresent(GrVkGpu * gpu)231 void GrVkImage::prepareForPresent(GrVkGpu* gpu) {
232 VkImageLayout layout = this->currentLayout();
233 if (fInitialQueueFamily != VK_QUEUE_FAMILY_EXTERNAL &&
234 fInitialQueueFamily != VK_QUEUE_FAMILY_FOREIGN_EXT) {
235 if (gpu->vkCaps().supportsSwapchain()) {
236 layout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
237 }
238 }
239 this->setImageLayout(gpu, layout, 0, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, false, true);
240 }
241
prepareForExternal(GrVkGpu * gpu)242 void GrVkImage::prepareForExternal(GrVkGpu* gpu) {
243 this->setImageLayout(gpu, this->currentLayout(), 0, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, false,
244 true);
245 }
246
releaseImage(GrVkGpu * gpu)247 void GrVkImage::releaseImage(GrVkGpu* gpu) {
248 if (fInfo.fCurrentQueueFamily != fInitialQueueFamily) {
249 // The Vulkan spec is vague on what to put for the dstStageMask here. The spec for image
250 // memory barrier says the dstStageMask must not be zero. However, in the spec when it talks
251 // about family queue transfers it says the dstStageMask is ignored and should be set to
252 // zero. Assuming it really is ignored we set it to VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT here
253 // since it makes the Vulkan validation layers happy.
254 this->setImageLayout(gpu, this->currentLayout(), 0, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
255 false, true);
256 }
257 if (fResource) {
258 fResource->removeOwningTexture();
259 fResource->unref(gpu);
260 fResource = nullptr;
261 }
262 }
263
abandonImage()264 void GrVkImage::abandonImage() {
265 if (fResource) {
266 fResource->removeOwningTexture();
267 fResource->unrefAndAbandon();
268 fResource = nullptr;
269 }
270 }
271
setResourceRelease(sk_sp<GrRefCntedCallback> releaseHelper)272 void GrVkImage::setResourceRelease(sk_sp<GrRefCntedCallback> releaseHelper) {
273 SkASSERT(fResource);
274 // Forward the release proc on to GrVkImage::Resource
275 fResource->setRelease(std::move(releaseHelper));
276 }
277
freeGPUData(GrVkGpu * gpu) const278 void GrVkImage::Resource::freeGPUData(GrVkGpu* gpu) const {
279 this->invokeReleaseProc();
280 VK_CALL(gpu, DestroyImage(gpu->device(), fImage, nullptr));
281 bool isLinear = (VK_IMAGE_TILING_LINEAR == fImageTiling);
282 GrVkMemory::FreeImageMemory(gpu, isLinear, fAlloc);
283 }
284
addIdleProc(GrVkTexture * owningTexture,sk_sp<GrRefCntedCallback> idleProc) const285 void GrVkImage::Resource::addIdleProc(GrVkTexture* owningTexture,
286 sk_sp<GrRefCntedCallback> idleProc) const {
287 SkASSERT(!fOwningTexture || fOwningTexture == owningTexture);
288 fOwningTexture = owningTexture;
289 fIdleProcs.push_back(std::move(idleProc));
290 }
291
idleProcCnt() const292 int GrVkImage::Resource::idleProcCnt() const { return fIdleProcs.count(); }
293
idleProc(int i) const294 sk_sp<GrRefCntedCallback> GrVkImage::Resource::idleProc(int i) const { return fIdleProcs[i]; }
295
resetIdleProcs() const296 void GrVkImage::Resource::resetIdleProcs() const { fIdleProcs.reset(); }
297
removeOwningTexture() const298 void GrVkImage::Resource::removeOwningTexture() const { fOwningTexture = nullptr; }
299
notifyAddedToCommandBuffer() const300 void GrVkImage::Resource::notifyAddedToCommandBuffer() const { ++fNumCommandBufferOwners; }
301
notifyRemovedFromCommandBuffer() const302 void GrVkImage::Resource::notifyRemovedFromCommandBuffer() const {
303 SkASSERT(fNumCommandBufferOwners);
304 if (--fNumCommandBufferOwners || !fIdleProcs.count()) {
305 return;
306 }
307 if (fOwningTexture) {
308 if (fOwningTexture->resourcePriv().hasRef()) {
309 // Wait for the texture to become idle in the cache to call the procs.
310 return;
311 }
312 fOwningTexture->callIdleProcsOnBehalfOfResource();
313 } else {
314 fIdleProcs.reset();
315 }
316 }
317
freeGPUData(GrVkGpu * gpu) const318 void GrVkImage::BorrowedResource::freeGPUData(GrVkGpu* gpu) const {
319 this->invokeReleaseProc();
320 }
321
abandonGPUData() const322 void GrVkImage::BorrowedResource::abandonGPUData() const {
323 this->invokeReleaseProc();
324 }
325
326 #if GR_TEST_UTILS
setCurrentQueueFamilyToGraphicsQueue(GrVkGpu * gpu)327 void GrVkImage::setCurrentQueueFamilyToGraphicsQueue(GrVkGpu* gpu) {
328 fInfo.fCurrentQueueFamily = gpu->queueIndex();
329 }
330 #endif
331
332