Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 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 "GrVkGpu.h" |
| 9 | #include "GrVkImage.h" |
| 10 | #include "GrVkMemory.h" |
| 11 | #include "GrVkUtil.h" |
| 12 | |
| 13 | #define VK_CALL(GPU, X) GR_VK_CALL(GPU->vkInterface(), X) |
| 14 | |
egdaniel | 58a8d92 | 2016-04-21 08:03:10 -0700 | [diff] [blame] | 15 | VkImageAspectFlags vk_format_to_aspect_flags(VkFormat format) { |
| 16 | switch (format) { |
| 17 | case VK_FORMAT_S8_UINT: |
| 18 | return VK_IMAGE_ASPECT_STENCIL_BIT; |
| 19 | case VK_FORMAT_D24_UNORM_S8_UINT: // fallthrough |
| 20 | case VK_FORMAT_D32_SFLOAT_S8_UINT: |
| 21 | return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; |
| 22 | default: |
Greg Daniel | 9440345 | 2017-04-18 15:52:36 -0400 | [diff] [blame] | 23 | SkASSERT(kUnknown_GrPixelConfig != GrVkFormatToPixelConfig(format)); |
egdaniel | 58a8d92 | 2016-04-21 08:03:10 -0700 | [diff] [blame] | 24 | return VK_IMAGE_ASPECT_COLOR_BIT; |
| 25 | } |
| 26 | } |
| 27 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 28 | void GrVkImage::setImageLayout(const GrVkGpu* gpu, VkImageLayout newLayout, |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 29 | VkAccessFlags dstAccessMask, |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 30 | VkPipelineStageFlags dstStageMask, |
| 31 | bool byRegion) { |
jvanverth | 2af0f1b | 2016-05-03 10:36:49 -0700 | [diff] [blame] | 32 | SkASSERT(VK_IMAGE_LAYOUT_UNDEFINED != newLayout && |
| 33 | VK_IMAGE_LAYOUT_PREINITIALIZED != newLayout); |
egdaniel | b2df0c2 | 2016-05-13 11:30:37 -0700 | [diff] [blame] | 34 | VkImageLayout currentLayout = this->currentLayout(); |
egdaniel | 19ff103 | 2016-08-31 10:13:08 -0700 | [diff] [blame] | 35 | |
Greg Daniel | a3b6a55 | 2017-03-21 09:48:44 -0400 | [diff] [blame] | 36 | // If the old and new layout are the same and the layout is a read only layout, there is no need |
| 37 | // to put in a barrier. |
| 38 | if (newLayout == currentLayout && |
| 39 | (VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL == currentLayout || |
| 40 | VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == currentLayout || |
| 41 | VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == currentLayout)) { |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 42 | return; |
| 43 | } |
jvanverth | 50c46c7 | 2016-05-06 12:31:28 -0700 | [diff] [blame] | 44 | |
egdaniel | b2df0c2 | 2016-05-13 11:30:37 -0700 | [diff] [blame] | 45 | VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(currentLayout); |
| 46 | VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(currentLayout); |
jvanverth | 50c46c7 | 2016-05-06 12:31:28 -0700 | [diff] [blame] | 47 | |
egdaniel | b2df0c2 | 2016-05-13 11:30:37 -0700 | [diff] [blame] | 48 | VkImageAspectFlags aspectFlags = vk_format_to_aspect_flags(fInfo.fFormat); |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 49 | VkImageMemoryBarrier imageMemoryBarrier = { |
jvanverth | 2af0f1b | 2016-05-03 10:36:49 -0700 | [diff] [blame] | 50 | VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType |
egdaniel | 3602d4f | 2016-08-12 11:58:53 -0700 | [diff] [blame] | 51 | nullptr, // pNext |
jvanverth | 2af0f1b | 2016-05-03 10:36:49 -0700 | [diff] [blame] | 52 | srcAccessMask, // outputMask |
| 53 | dstAccessMask, // inputMask |
egdaniel | b2df0c2 | 2016-05-13 11:30:37 -0700 | [diff] [blame] | 54 | currentLayout, // oldLayout |
jvanverth | 2af0f1b | 2016-05-03 10:36:49 -0700 | [diff] [blame] | 55 | newLayout, // newLayout |
| 56 | VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex |
| 57 | VK_QUEUE_FAMILY_IGNORED, // dstQueueFamilyIndex |
egdaniel | b2df0c2 | 2016-05-13 11:30:37 -0700 | [diff] [blame] | 58 | fInfo.fImage, // image |
| 59 | { aspectFlags, 0, fInfo.fLevelCount, 0, 1 } // subresourceRange |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 60 | }; |
| 61 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 62 | gpu->addImageMemoryBarrier(srcStageMask, dstStageMask, byRegion, &imageMemoryBarrier); |
| 63 | |
egdaniel | b2df0c2 | 2016-05-13 11:30:37 -0700 | [diff] [blame] | 64 | fInfo.fImageLayout = newLayout; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 65 | } |
| 66 | |
egdaniel | b2df0c2 | 2016-05-13 11:30:37 -0700 | [diff] [blame] | 67 | bool GrVkImage::InitImageInfo(const GrVkGpu* gpu, const ImageDesc& imageDesc, GrVkImageInfo* info) { |
egdaniel | ab527a5 | 2016-06-28 08:07:26 -0700 | [diff] [blame] | 68 | if (0 == imageDesc.fWidth || 0 == imageDesc.fHeight) { |
| 69 | return false; |
| 70 | } |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 71 | VkImage image = 0; |
jvanverth | 1e305ba | 2016-06-01 09:39:15 -0700 | [diff] [blame] | 72 | GrVkAlloc alloc; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 73 | |
jvanverth | 6b6ffc4 | 2016-06-13 14:28:07 -0700 | [diff] [blame] | 74 | bool isLinear = VK_IMAGE_TILING_LINEAR == imageDesc.fImageTiling; |
| 75 | VkImageLayout initialLayout = isLinear ? VK_IMAGE_LAYOUT_PREINITIALIZED |
| 76 | : VK_IMAGE_LAYOUT_UNDEFINED; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 77 | |
| 78 | // Create Image |
| 79 | VkSampleCountFlagBits vkSamples; |
| 80 | if (!GrSampleCountToVkSampleCount(imageDesc.fSamples, &vkSamples)) { |
egdaniel | b2df0c2 | 2016-05-13 11:30:37 -0700 | [diff] [blame] | 81 | return false; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 82 | } |
egdaniel | 8f1dcaa | 2016-04-01 10:10:45 -0700 | [diff] [blame] | 83 | |
| 84 | SkASSERT(VK_IMAGE_TILING_OPTIMAL == imageDesc.fImageTiling || |
| 85 | VK_SAMPLE_COUNT_1_BIT == vkSamples); |
| 86 | |
brianosman | 7888f78 | 2016-05-17 11:47:32 -0700 | [diff] [blame] | 87 | // sRGB format images may need to be aliased to linear for various reasons (legacy mode): |
| 88 | VkImageCreateFlags createFlags = GrVkFormatIsSRGB(imageDesc.fFormat, nullptr) |
| 89 | ? VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT : 0; |
| 90 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 91 | const VkImageCreateInfo imageCreateInfo = { |
| 92 | VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // sType |
| 93 | NULL, // pNext |
brianosman | 7888f78 | 2016-05-17 11:47:32 -0700 | [diff] [blame] | 94 | createFlags, // VkImageCreateFlags |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 95 | imageDesc.fImageType, // VkImageType |
| 96 | imageDesc.fFormat, // VkFormat |
| 97 | { imageDesc.fWidth, imageDesc.fHeight, 1 }, // VkExtent3D |
| 98 | imageDesc.fLevels, // mipLevels |
| 99 | 1, // arrayLayers |
| 100 | vkSamples, // samples |
| 101 | imageDesc.fImageTiling, // VkImageTiling |
| 102 | imageDesc.fUsageFlags, // VkImageUsageFlags |
| 103 | VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode |
| 104 | 0, // queueFamilyCount |
| 105 | 0, // pQueueFamilyIndices |
| 106 | initialLayout // initialLayout |
| 107 | }; |
| 108 | |
egdaniel | b2df0c2 | 2016-05-13 11:30:37 -0700 | [diff] [blame] | 109 | GR_VK_CALL_ERRCHECK(gpu->vkInterface(), CreateImage(gpu->device(), &imageCreateInfo, nullptr, |
| 110 | &image)); |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 111 | |
jvanverth | 6b6ffc4 | 2016-06-13 14:28:07 -0700 | [diff] [blame] | 112 | if (!GrVkMemory::AllocAndBindImageMemory(gpu, image, isLinear, &alloc)) { |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 113 | VK_CALL(gpu, DestroyImage(gpu->device(), image, nullptr)); |
egdaniel | b2df0c2 | 2016-05-13 11:30:37 -0700 | [diff] [blame] | 114 | return false; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 115 | } |
| 116 | |
egdaniel | b2df0c2 | 2016-05-13 11:30:37 -0700 | [diff] [blame] | 117 | info->fImage = image; |
| 118 | info->fAlloc = alloc; |
| 119 | info->fImageTiling = imageDesc.fImageTiling; |
| 120 | info->fImageLayout = initialLayout; |
| 121 | info->fFormat = imageDesc.fFormat; |
| 122 | info->fLevelCount = imageDesc.fLevels; |
| 123 | return true; |
| 124 | } |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 125 | |
egdaniel | b2df0c2 | 2016-05-13 11:30:37 -0700 | [diff] [blame] | 126 | void GrVkImage::DestroyImageInfo(const GrVkGpu* gpu, GrVkImageInfo* info) { |
| 127 | VK_CALL(gpu, DestroyImage(gpu->device(), info->fImage, nullptr)); |
jvanverth | 6b6ffc4 | 2016-06-13 14:28:07 -0700 | [diff] [blame] | 128 | bool isLinear = VK_IMAGE_TILING_LINEAR == info->fImageTiling; |
| 129 | GrVkMemory::FreeImageMemory(gpu, isLinear, info->fAlloc); |
egdaniel | b2df0c2 | 2016-05-13 11:30:37 -0700 | [diff] [blame] | 130 | } |
| 131 | |
jvanverth | 6b6ffc4 | 2016-06-13 14:28:07 -0700 | [diff] [blame] | 132 | void GrVkImage::setNewResource(VkImage image, const GrVkAlloc& alloc, VkImageTiling tiling) { |
| 133 | fResource = new Resource(image, alloc, tiling); |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 134 | } |
| 135 | |
| 136 | GrVkImage::~GrVkImage() { |
| 137 | // should have been released or abandoned first |
| 138 | SkASSERT(!fResource); |
| 139 | } |
| 140 | |
| 141 | void GrVkImage::releaseImage(const GrVkGpu* gpu) { |
| 142 | if (fResource) { |
| 143 | fResource->unref(gpu); |
| 144 | fResource = nullptr; |
| 145 | } |
| 146 | } |
| 147 | |
| 148 | void GrVkImage::abandonImage() { |
| 149 | if (fResource) { |
| 150 | fResource->unrefAndAbandon(); |
| 151 | fResource = nullptr; |
| 152 | } |
| 153 | } |
| 154 | |
Greg Daniel | cef213c | 2017-04-21 11:52:27 -0400 | [diff] [blame] | 155 | void GrVkImage::setResourceRelease(ReleaseProc proc, ReleaseCtx ctx) { |
| 156 | // Forward the release proc on to GrVkImage::Resource |
| 157 | fResource->setRelease(proc, ctx); |
| 158 | } |
| 159 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 160 | void GrVkImage::Resource::freeGPUData(const GrVkGpu* gpu) const { |
Greg Daniel | cef213c | 2017-04-21 11:52:27 -0400 | [diff] [blame] | 161 | SkASSERT(!fReleaseProc); |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 162 | VK_CALL(gpu, DestroyImage(gpu->device(), fImage, nullptr)); |
jvanverth | 6b6ffc4 | 2016-06-13 14:28:07 -0700 | [diff] [blame] | 163 | bool isLinear = (VK_IMAGE_TILING_LINEAR == fImageTiling); |
| 164 | GrVkMemory::FreeImageMemory(gpu, isLinear, fAlloc); |
jvanverth | 0fcfb75 | 2016-03-09 09:57:52 -0800 | [diff] [blame] | 165 | } |
jvanverth | fe170d2 | 2016-03-22 13:15:44 -0700 | [diff] [blame] | 166 | |
| 167 | void GrVkImage::BorrowedResource::freeGPUData(const GrVkGpu* gpu) const { |
Greg Daniel | cef213c | 2017-04-21 11:52:27 -0400 | [diff] [blame] | 168 | this->invokeReleaseProc(); |
jvanverth | fe170d2 | 2016-03-22 13:15:44 -0700 | [diff] [blame] | 169 | } |
Greg Daniel | cef213c | 2017-04-21 11:52:27 -0400 | [diff] [blame] | 170 | |
| 171 | void GrVkImage::BorrowedResource::abandonGPUData() const { |
| 172 | this->invokeReleaseProc(); |
| 173 | } |
| 174 | |