blob: a04242a5db066e4c9e4e3f33f587a4e817d0f7ea [file] [log] [blame]
Jeff Bolz87697532019-01-11 22:54:00 -06001/* Copyright (c) 2015-2019 The Khronos Group Inc.
2 * Copyright (c) 2015-2019 Valve Corporation
3 * Copyright (c) 2015-2019 LunarG, Inc.
4 * Copyright (C) 2015-2019 Google Inc.
Mark Lobodzinskid42e4d22017-01-17 14:14:22 -07005 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 * Author: Mark Lobodzinski <mark@lunarg.com>
Dave Houlton4eaaf3a2017-03-14 11:31:20 -060019 * Author: Dave Houlton <daveh@lunarg.com>
Shannon McPherson3ea65132018-12-05 10:37:39 -070020 * Shannon McPherson <shannon@lunarg.com>
Mark Lobodzinskid42e4d22017-01-17 14:14:22 -070021 */
22
23// Allow use of STL min and max functions in Windows
24#define NOMINMAX
25
Dave Houlton0d4ad6f2018-09-05 14:53:34 -060026#include <cmath>
27#include <set>
Mark Lobodzinski90224de2017-01-26 15:23:11 -070028#include <sstream>
Petr Kraus4d718682017-05-18 03:38:41 +020029#include <string>
Mark Lobodzinski90224de2017-01-26 15:23:11 -070030
31#include "vk_enum_string_helper.h"
32#include "vk_layer_data.h"
33#include "vk_layer_utils.h"
34#include "vk_layer_logging.h"
Dave Houltonbd2e2622018-04-10 16:41:14 -060035#include "vk_typemap_helper.h"
Mark Lobodzinski90224de2017-01-26 15:23:11 -070036
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -070037#include "chassis.h"
Mark Lobodzinski76d76662019-02-14 14:38:21 -070038#include "core_validation.h"
39#include "shader_validation.h"
40#include "descriptor_sets.h"
Mark Lobodzinskid42e4d22017-01-17 14:14:22 -070041#include "buffer_validation.h"
Mark Lobodzinski42fe5f72017-01-11 11:36:16 -070042
Dave Houltond9611312018-11-19 17:03:36 -070043uint32_t FullMipChainLevels(uint32_t height, uint32_t width, uint32_t depth) {
44 // uint cast applies floor()
45 return 1u + (uint32_t)log2(std::max({height, width, depth}));
46}
47
48uint32_t FullMipChainLevels(VkExtent3D extent) { return FullMipChainLevels(extent.height, extent.width, extent.depth); }
49
50uint32_t FullMipChainLevels(VkExtent2D extent) { return FullMipChainLevels(extent.height, extent.width); }
51
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -070052void CoreChecks::SetLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair,
53 const VkImageLayout &layout) {
Dave Houltonb3f4b282018-02-22 16:25:16 -070054 auto it = pCB->imageLayoutMap.find(imgpair);
55 if (it != pCB->imageLayoutMap.end()) {
56 it->second.layout = layout;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -070057 } else {
58 assert(imgpair.hasSubresource);
59 IMAGE_CMD_BUF_LAYOUT_NODE node;
60 if (!FindCmdBufLayout(device_data, pCB, imgpair.image, imgpair.subresource, node)) {
61 node.initialLayout = layout;
62 }
63 SetLayout(device_data, pCB, imgpair, {node.initialLayout, layout});
64 }
65}
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -070066
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -070067template <class OBJECT, class LAYOUT>
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -070068void CoreChecks::SetLayout(layer_data *device_data, OBJECT *pObject, VkImage image, VkImageSubresource range,
69 const LAYOUT &layout) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -070070 ImageSubresourcePair imgpair = {image, true, range};
71 SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_COLOR_BIT);
72 SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_DEPTH_BIT);
73 SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_STENCIL_BIT);
74 SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_METADATA_BIT);
Mark Lobodzinski60e79032019-03-07 10:22:31 -070075 if (GetDeviceExtensions()->vk_khr_sampler_ycbcr_conversion) {
Dave Houltonb3f4b282018-02-22 16:25:16 -070076 SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR);
77 SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR);
78 SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
79 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -070080}
81
82template <class OBJECT, class LAYOUT>
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -070083void CoreChecks::SetLayout(layer_data *device_data, OBJECT *pObject, ImageSubresourcePair imgpair, const LAYOUT &layout,
84 VkImageAspectFlags aspectMask) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -070085 if (imgpair.subresource.aspectMask & aspectMask) {
86 imgpair.subresource.aspectMask = aspectMask;
87 SetLayout(device_data, pObject, imgpair, layout);
88 }
89}
90
Tony Barbourdf013b92017-01-25 12:53:48 -070091// Set the layout in supplied map
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -070092void CoreChecks::SetLayout(std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_NODE> &imageLayoutMap,
93 ImageSubresourcePair imgpair, VkImageLayout layout) {
Dave Houltonb3f4b282018-02-22 16:25:16 -070094 auto it = imageLayoutMap.find(imgpair);
95 if (it != imageLayoutMap.end()) {
96 it->second.layout = layout; // Update
97 } else {
98 imageLayoutMap[imgpair].layout = layout; // Insert
99 }
Tony Barbourdf013b92017-01-25 12:53:48 -0700100}
101
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700102bool CoreChecks::FindLayoutVerifyNode(layer_data const *device_data, GLOBAL_CB_NODE const *pCB, ImageSubresourcePair imgpair,
103 IMAGE_CMD_BUF_LAYOUT_NODE &node, const VkImageAspectFlags aspectMask) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700104 if (!(imgpair.subresource.aspectMask & aspectMask)) {
105 return false;
106 }
107 VkImageAspectFlags oldAspectMask = imgpair.subresource.aspectMask;
108 imgpair.subresource.aspectMask = aspectMask;
109 auto imgsubIt = pCB->imageLayoutMap.find(imgpair);
110 if (imgsubIt == pCB->imageLayoutMap.end()) {
111 return false;
112 }
113 if (node.layout != VK_IMAGE_LAYOUT_MAX_ENUM && node.layout != imgsubIt->second.layout) {
Petr Krausbc7f5442017-05-14 23:43:38 +0200114 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(imgpair.image),
Dave Houlton51653902018-06-22 17:32:13 -0600115 kVUID_Core_DrawState_InvalidLayout,
Lockee9aeebf2019-03-03 23:50:08 -0700116 "Cannot query for VkImage %s layout when combined aspect mask %d has multiple layout types: %s and %s",
117 report_data->FormatHandle(imgpair.image).c_str(), oldAspectMask, string_VkImageLayout(node.layout),
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700118 string_VkImageLayout(imgsubIt->second.layout));
119 }
120 if (node.initialLayout != VK_IMAGE_LAYOUT_MAX_ENUM && node.initialLayout != imgsubIt->second.initialLayout) {
Petr Krausbc7f5442017-05-14 23:43:38 +0200121 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(imgpair.image),
Dave Houlton51653902018-06-22 17:32:13 -0600122 kVUID_Core_DrawState_InvalidLayout,
Lockee9aeebf2019-03-03 23:50:08 -0700123 "Cannot query for VkImage %s"
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700124 " layout when combined aspect mask %d has multiple initial layout types: %s and %s",
Lockee9aeebf2019-03-03 23:50:08 -0700125 report_data->FormatHandle(imgpair.image).c_str(), oldAspectMask, string_VkImageLayout(node.initialLayout),
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700126 string_VkImageLayout(imgsubIt->second.initialLayout));
127 }
128 node = imgsubIt->second;
129 return true;
130}
131
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700132bool CoreChecks::FindLayoutVerifyLayout(layer_data const *device_data, ImageSubresourcePair imgpair, VkImageLayout &layout,
133 const VkImageAspectFlags aspectMask) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700134 if (!(imgpair.subresource.aspectMask & aspectMask)) {
135 return false;
136 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700137 VkImageAspectFlags oldAspectMask = imgpair.subresource.aspectMask;
138 imgpair.subresource.aspectMask = aspectMask;
Mark Lobodzinski44d46d52019-03-07 11:04:06 -0700139 auto imgsubIt = (*GetImageLayoutMap()).find(imgpair);
140 if (imgsubIt == (*GetImageLayoutMap()).end()) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700141 return false;
142 }
143 if (layout != VK_IMAGE_LAYOUT_MAX_ENUM && layout != imgsubIt->second.layout) {
Petr Krausbc7f5442017-05-14 23:43:38 +0200144 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(imgpair.image),
Dave Houlton51653902018-06-22 17:32:13 -0600145 kVUID_Core_DrawState_InvalidLayout,
Lockee9aeebf2019-03-03 23:50:08 -0700146 "Cannot query for VkImage %s layout when combined aspect mask %d has multiple layout types: %s and %s",
147 report_data->FormatHandle(imgpair.image).c_str(), oldAspectMask, string_VkImageLayout(layout),
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700148 string_VkImageLayout(imgsubIt->second.layout));
149 }
150 layout = imgsubIt->second.layout;
151 return true;
152}
153
154// Find layout(s) on the command buffer level
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700155bool CoreChecks::FindCmdBufLayout(layer_data const *device_data, GLOBAL_CB_NODE const *pCB, VkImage image, VkImageSubresource range,
156 IMAGE_CMD_BUF_LAYOUT_NODE &node) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700157 ImageSubresourcePair imgpair = {image, true, range};
158 node = IMAGE_CMD_BUF_LAYOUT_NODE(VK_IMAGE_LAYOUT_MAX_ENUM, VK_IMAGE_LAYOUT_MAX_ENUM);
159 FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_COLOR_BIT);
160 FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_DEPTH_BIT);
161 FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_STENCIL_BIT);
162 FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_METADATA_BIT);
Mark Lobodzinski60e79032019-03-07 10:22:31 -0700163 if (GetDeviceExtensions()->vk_khr_sampler_ycbcr_conversion) {
Dave Houltonb3f4b282018-02-22 16:25:16 -0700164 FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR);
165 FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR);
166 FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
167 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700168 if (node.layout == VK_IMAGE_LAYOUT_MAX_ENUM) {
169 imgpair = {image, false, VkImageSubresource()};
170 auto imgsubIt = pCB->imageLayoutMap.find(imgpair);
171 if (imgsubIt == pCB->imageLayoutMap.end()) return false;
172 // TODO: This is ostensibly a find function but it changes state here
173 node = imgsubIt->second;
174 }
175 return true;
176}
177
178// Find layout(s) on the global level
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700179bool CoreChecks::FindGlobalLayout(layer_data *device_data, ImageSubresourcePair imgpair, VkImageLayout &layout) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700180 layout = VK_IMAGE_LAYOUT_MAX_ENUM;
181 FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_COLOR_BIT);
182 FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_DEPTH_BIT);
183 FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_STENCIL_BIT);
184 FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_METADATA_BIT);
Mark Lobodzinski60e79032019-03-07 10:22:31 -0700185 if (GetDeviceExtensions()->vk_khr_sampler_ycbcr_conversion) {
Dave Houltonb3f4b282018-02-22 16:25:16 -0700186 FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR);
187 FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR);
188 FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
189 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700190 if (layout == VK_IMAGE_LAYOUT_MAX_ENUM) {
191 imgpair = {imgpair.image, false, VkImageSubresource()};
Mark Lobodzinski44d46d52019-03-07 11:04:06 -0700192 auto imgsubIt = (*GetImageLayoutMap()).find(imgpair);
193 if (imgsubIt == (*GetImageLayoutMap()).end()) return false;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700194 layout = imgsubIt->second.layout;
195 }
196 return true;
197}
198
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700199bool CoreChecks::FindLayouts(layer_data *device_data, VkImage image, std::vector<VkImageLayout> &layouts) {
Mark Lobodzinski44d46d52019-03-07 11:04:06 -0700200 auto sub_data = (*GetImageSubresourceMap()).find(image);
201 if (sub_data == (*GetImageSubresourceMap()).end()) return false;
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -0700202 auto image_state = GetImageState(image);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700203 if (!image_state) return false;
204 bool ignoreGlobal = false;
205 // TODO: Make this robust for >1 aspect mask. Now it will just say ignore potential errors in this case.
206 if (sub_data->second.size() >= (image_state->createInfo.arrayLayers * image_state->createInfo.mipLevels + 1)) {
207 ignoreGlobal = true;
208 }
209 for (auto imgsubpair : sub_data->second) {
210 if (ignoreGlobal && !imgsubpair.hasSubresource) continue;
Mark Lobodzinski44d46d52019-03-07 11:04:06 -0700211 auto img_data = (*GetImageLayoutMap()).find(imgsubpair);
212 if (img_data != (*GetImageLayoutMap()).end()) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700213 layouts.push_back(img_data->second.layout);
214 }
215 }
216 return true;
217}
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700218
219bool CoreChecks::FindLayout(const std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_NODE> &imageLayoutMap,
220 ImageSubresourcePair imgpair, VkImageLayout &layout, const VkImageAspectFlags aspectMask) {
Tony Barbourdf013b92017-01-25 12:53:48 -0700221 if (!(imgpair.subresource.aspectMask & aspectMask)) {
222 return false;
223 }
224 imgpair.subresource.aspectMask = aspectMask;
225 auto imgsubIt = imageLayoutMap.find(imgpair);
226 if (imgsubIt == imageLayoutMap.end()) {
227 return false;
228 }
229 layout = imgsubIt->second.layout;
230 return true;
Tony Barboure0c5cc92017-02-08 13:53:39 -0700231}
Tony Barbourdf013b92017-01-25 12:53:48 -0700232
233// find layout in supplied map
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700234bool CoreChecks::FindLayout(layer_data *device_data,
235 const std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_NODE> &imageLayoutMap,
236 ImageSubresourcePair imgpair, VkImageLayout &layout) {
Tony Barbourdf013b92017-01-25 12:53:48 -0700237 layout = VK_IMAGE_LAYOUT_MAX_ENUM;
238 FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_COLOR_BIT);
239 FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_DEPTH_BIT);
240 FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_STENCIL_BIT);
241 FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_METADATA_BIT);
Mark Lobodzinski60e79032019-03-07 10:22:31 -0700242 if (GetDeviceExtensions()->vk_khr_sampler_ycbcr_conversion) {
Dave Houltonb3f4b282018-02-22 16:25:16 -0700243 FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR);
244 FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR);
245 FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
246 }
247 // Image+subresource not found, look for image handle w/o subresource
Tony Barbourdf013b92017-01-25 12:53:48 -0700248 if (layout == VK_IMAGE_LAYOUT_MAX_ENUM) {
249 imgpair = {imgpair.image, false, VkImageSubresource()};
250 auto imgsubIt = imageLayoutMap.find(imgpair);
251 if (imgsubIt == imageLayoutMap.end()) return false;
252 layout = imgsubIt->second.layout;
253 }
254 return true;
255}
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700256
257// Set the layout on the global level
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700258void CoreChecks::SetGlobalLayout(layer_data *device_data, ImageSubresourcePair imgpair, const VkImageLayout &layout) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700259 VkImage &image = imgpair.image;
Mark Lobodzinski44d46d52019-03-07 11:04:06 -0700260 auto &lmap = (*GetImageLayoutMap());
Dave Houltonb3f4b282018-02-22 16:25:16 -0700261 auto data = lmap.find(imgpair);
262 if (data != lmap.end()) {
263 data->second.layout = layout; // Update
264 } else {
265 lmap[imgpair].layout = layout; // Insert
266 }
Mark Lobodzinski44d46d52019-03-07 11:04:06 -0700267 auto &image_subresources = (*GetImageSubresourceMap())[image];
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700268 auto subresource = std::find(image_subresources.begin(), image_subresources.end(), imgpair);
269 if (subresource == image_subresources.end()) {
270 image_subresources.push_back(imgpair);
271 }
272}
273
274// Set the layout on the cmdbuf level
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700275void CoreChecks::SetLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair,
276 const IMAGE_CMD_BUF_LAYOUT_NODE &node) {
Dave Houltonb3f4b282018-02-22 16:25:16 -0700277 auto it = pCB->imageLayoutMap.find(imgpair);
278 if (it != pCB->imageLayoutMap.end()) {
279 it->second = node; // Update
280 } else {
281 pCB->imageLayoutMap[imgpair] = node; // Insert
282 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700283}
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600284// Set image layout for given VkImageSubresourceRange struct
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700285void CoreChecks::SetImageLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, const IMAGE_STATE *image_state,
286 VkImageSubresourceRange image_subresource_range, const VkImageLayout &layout) {
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600287 assert(image_state);
John Zulauf48a6a702017-12-22 17:14:54 -0700288 cb_node->image_layout_change_count++; // Change the version of this data to force revalidation
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600289 for (uint32_t level_index = 0; level_index < image_subresource_range.levelCount; ++level_index) {
290 uint32_t level = image_subresource_range.baseMipLevel + level_index;
291 for (uint32_t layer_index = 0; layer_index < image_subresource_range.layerCount; layer_index++) {
292 uint32_t layer = image_subresource_range.baseArrayLayer + layer_index;
293 VkImageSubresource sub = {image_subresource_range.aspectMask, level, layer};
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700294 // TODO: If ImageView was created with depth or stencil, transition both layouts as the aspectMask is ignored and both
295 // are used. Verify that the extra implicit layout is OK for descriptor set layout validation
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600296 if (image_subresource_range.aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
Dave Houlton1d2022c2017-03-29 11:43:58 -0600297 if (FormatIsDepthAndStencil(image_state->createInfo.format)) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700298 sub.aspectMask |= (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
299 }
300 }
Tony-LunarG119b38a2018-12-18 09:49:16 -0700301 // For multiplane images, IMAGE_ASPECT_COLOR is an alias for all of the plane bits
Mark Lobodzinski60e79032019-03-07 10:22:31 -0700302 if (GetDeviceExtensions()->vk_khr_sampler_ycbcr_conversion) {
Tony-LunarG119b38a2018-12-18 09:49:16 -0700303 if (FormatIsMultiplane(image_state->createInfo.format)) {
304 if (sub.aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) {
305 sub.aspectMask &= ~VK_IMAGE_ASPECT_COLOR_BIT;
306 sub.aspectMask |= VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR;
307 if (FormatPlaneCount(image_state->createInfo.format) > 2) {
308 sub.aspectMask |= VK_IMAGE_ASPECT_PLANE_2_BIT_KHR;
309 }
310 }
311 }
312 }
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600313 SetLayout(device_data, cb_node, image_state->image, sub, layout);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700314 }
315 }
316}
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600317// Set image layout for given VkImageSubresourceLayers struct
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700318void CoreChecks::SetImageLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, const IMAGE_STATE *image_state,
319 VkImageSubresourceLayers image_subresource_layers, const VkImageLayout &layout) {
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600320 // Transfer VkImageSubresourceLayers into VkImageSubresourceRange struct
321 VkImageSubresourceRange image_subresource_range;
322 image_subresource_range.aspectMask = image_subresource_layers.aspectMask;
323 image_subresource_range.baseArrayLayer = image_subresource_layers.baseArrayLayer;
324 image_subresource_range.layerCount = image_subresource_layers.layerCount;
325 image_subresource_range.baseMipLevel = image_subresource_layers.mipLevel;
326 image_subresource_range.levelCount = 1;
327 SetImageLayout(device_data, cb_node, image_state, image_subresource_range, layout);
328}
Dave Houltonddd65c52018-05-08 14:58:01 -0600329
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600330// Set image layout for all slices of an image view
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700331void CoreChecks::SetImageViewLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_VIEW_STATE *view_state,
332 const VkImageLayout &layout) {
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600333 assert(view_state);
334
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -0700335 IMAGE_STATE *image_state = GetImageState(view_state->create_info.image);
Dave Houltonddd65c52018-05-08 14:58:01 -0600336 VkImageSubresourceRange sub_range = view_state->create_info.subresourceRange;
337
338 // When changing the layout of a 3D image subresource via a 2D or 2D_ARRRAY image view, all depth slices of
339 // the subresource mip level(s) are transitioned, ignoring any layers restriction in the subresource info.
340 if ((image_state->createInfo.imageType == VK_IMAGE_TYPE_3D) && (view_state->create_info.viewType != VK_IMAGE_VIEW_TYPE_3D)) {
341 sub_range.baseArrayLayer = 0;
342 sub_range.layerCount = image_state->createInfo.extent.depth;
343 }
344
345 SetImageLayout(device_data, cb_node, image_state, sub_range, layout);
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600346}
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700347
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700348void CoreChecks::SetImageViewLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, VkImageView imageView,
349 const VkImageLayout &layout) {
Mark Lobodzinskia3a230b2019-03-06 15:35:13 -0700350 auto view_state = GetImageViewState(imageView);
John Zulauf4ccf5c02018-09-21 11:46:18 -0600351 SetImageViewLayout(device_data, cb_node, view_state, layout);
352}
353
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700354bool CoreChecks::ValidateRenderPassLayoutAgainstFramebufferImageUsage(layer_data *device_data, RenderPassCreateVersion rp_version,
355 VkImageLayout layout, VkImage image, VkImageView image_view,
356 VkFramebuffer framebuffer, VkRenderPass renderpass,
357 uint32_t attachment_index, const char *variable_name) {
Tobias Hectorbbb12282018-10-22 15:17:59 +0100358 bool skip = false;
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700359 const auto report_data = GetReportData(device_data);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -0700360 auto image_state = GetImageState(image);
Tobias Hectorbbb12282018-10-22 15:17:59 +0100361 const char *vuid;
362 const bool use_rp2 = (rp_version == RENDER_PASS_VERSION_2);
363
364 if (!image_state) {
365 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image),
366 "VUID-VkRenderPassBeginInfo-framebuffer-parameter",
Lockee9aeebf2019-03-03 23:50:08 -0700367 "Render Pass begin with renderpass %s uses framebuffer %s where pAttachments[%" PRIu32
368 "] = image view %s, which refers to an invalid image",
369 report_data->FormatHandle(renderpass).c_str(), report_data->FormatHandle(framebuffer).c_str(),
370 attachment_index, report_data->FormatHandle(image_view).c_str());
Tobias Hectorbbb12282018-10-22 15:17:59 +0100371 return skip;
372 }
373
374 auto image_usage = image_state->createInfo.usage;
375
376 // Check for layouts that mismatch image usages in the framebuffer
377 if (layout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL && !(image_usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)) {
378 vuid = use_rp2 ? "VUID-vkCmdBeginRenderPass2KHR-initialLayout-03094" : "VUID-vkCmdBeginRenderPass-initialLayout-00895";
379 skip |=
380 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image), vuid,
Lockee9aeebf2019-03-03 23:50:08 -0700381 "Layout/usage mismatch for attachment %u in render pass %s"
382 " - the %s is %s but the image attached to framebuffer %s via image view %s"
Tobias Hectorbbb12282018-10-22 15:17:59 +0100383 " was not created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT",
Lockee9aeebf2019-03-03 23:50:08 -0700384 attachment_index, report_data->FormatHandle(framebuffer).c_str(), variable_name, string_VkImageLayout(layout),
385 report_data->FormatHandle(renderpass).c_str(), report_data->FormatHandle(image_view).c_str());
Tobias Hectorbbb12282018-10-22 15:17:59 +0100386 }
387
388 if (layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL &&
389 !(image_usage & (VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT))) {
390 vuid = use_rp2 ? "VUID-vkCmdBeginRenderPass2KHR-initialLayout-03097" : "VUID-vkCmdBeginRenderPass-initialLayout-00897";
391 skip |=
392 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image), vuid,
Lockee9aeebf2019-03-03 23:50:08 -0700393 "Layout/usage mismatch for attachment %u in render pass %s"
394 " - the %s is %s but the image attached to framebuffer %s via image view %s"
Tobias Hectorbbb12282018-10-22 15:17:59 +0100395 " was not created with VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT or VK_IMAGE_USAGE_SAMPLED_BIT",
Lockee9aeebf2019-03-03 23:50:08 -0700396 attachment_index, report_data->FormatHandle(framebuffer).c_str(), variable_name, string_VkImageLayout(layout),
397 report_data->FormatHandle(renderpass).c_str(), report_data->FormatHandle(image_view).c_str());
Tobias Hectorbbb12282018-10-22 15:17:59 +0100398 }
399
400 if (layout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL && !(image_usage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT)) {
401 vuid = use_rp2 ? "VUID-vkCmdBeginRenderPass2KHR-initialLayout-03098" : "VUID-vkCmdBeginRenderPass-initialLayout-00898";
402 skip |=
403 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image), vuid,
Lockee9aeebf2019-03-03 23:50:08 -0700404 "Layout/usage mismatch for attachment %u in render pass %s"
405 " - the %s is %s but the image attached to framebuffer %s via image view %s"
Tobias Hectorbbb12282018-10-22 15:17:59 +0100406 " was not created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT",
Lockee9aeebf2019-03-03 23:50:08 -0700407 attachment_index, report_data->FormatHandle(framebuffer).c_str(), variable_name, string_VkImageLayout(layout),
408 report_data->FormatHandle(renderpass).c_str(), report_data->FormatHandle(image_view).c_str());
Tobias Hectorbbb12282018-10-22 15:17:59 +0100409 }
410
411 if (layout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && !(image_usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) {
412 vuid = use_rp2 ? "VUID-vkCmdBeginRenderPass2KHR-initialLayout-03099" : "VUID-vkCmdBeginRenderPass-initialLayout-00899";
413 skip |=
414 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image), vuid,
Lockee9aeebf2019-03-03 23:50:08 -0700415 "Layout/usage mismatch for attachment %u in render pass %s"
416 " - the %s is %s but the image attached to framebuffer %s via image view %s"
Tobias Hectorbbb12282018-10-22 15:17:59 +0100417 " was not created with VK_IMAGE_USAGE_TRANSFER_DST_BIT",
Lockee9aeebf2019-03-03 23:50:08 -0700418 attachment_index, report_data->FormatHandle(framebuffer).c_str(), variable_name, string_VkImageLayout(layout),
419 report_data->FormatHandle(renderpass).c_str(), report_data->FormatHandle(image_view).c_str());
Tobias Hectorbbb12282018-10-22 15:17:59 +0100420 }
421
Mark Lobodzinski60e79032019-03-07 10:22:31 -0700422 if (GetDeviceExtensions()->vk_khr_maintenance2) {
Tobias Hectorbbb12282018-10-22 15:17:59 +0100423 if ((layout == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL ||
424 layout == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL ||
425 layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL ||
426 layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL) &&
427 !(image_usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
428 vuid = use_rp2 ? "VUID-vkCmdBeginRenderPass2KHR-initialLayout-03096" : "VUID-vkCmdBeginRenderPass-initialLayout-01758";
Lockee9aeebf2019-03-03 23:50:08 -0700429 skip |= log_msg(
430 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image), vuid,
431 "Layout/usage mismatch for attachment %u in render pass %s"
432 " - the %s is %s but the image attached to framebuffer %s via image view %s"
433 " was not created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT",
434 attachment_index, report_data->FormatHandle(framebuffer).c_str(), variable_name, string_VkImageLayout(layout),
435 report_data->FormatHandle(renderpass).c_str(), report_data->FormatHandle(image_view).c_str());
Tobias Hectorbbb12282018-10-22 15:17:59 +0100436 }
437 } else {
438 // The create render pass 2 extension requires maintenance 2 (the previous branch), so no vuid switch needed here.
439 if ((layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL ||
440 layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL) &&
441 !(image_usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
442 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
443 HandleToUint64(image), "VUID-vkCmdBeginRenderPass-initialLayout-00896",
Lockee9aeebf2019-03-03 23:50:08 -0700444 "Layout/usage mismatch for attachment %u in render pass %s"
445 " - the %s is %s but the image attached to framebuffer %s via image view %s"
Tobias Hectorbbb12282018-10-22 15:17:59 +0100446 " was not created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT",
Lockee9aeebf2019-03-03 23:50:08 -0700447 attachment_index, report_data->FormatHandle(framebuffer).c_str(), variable_name,
448 string_VkImageLayout(layout), report_data->FormatHandle(renderpass).c_str(),
449 report_data->FormatHandle(image_view).c_str());
Tobias Hectorbbb12282018-10-22 15:17:59 +0100450 }
451 }
452 return skip;
453}
454
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700455bool CoreChecks::VerifyFramebufferAndRenderPassLayouts(layer_data *device_data, RenderPassCreateVersion rp_version,
456 GLOBAL_CB_NODE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin,
457 const FRAMEBUFFER_STATE *framebuffer_state) {
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600458 bool skip = false;
Mark Lobodzinski2e495882019-03-06 16:11:56 -0700459 auto const pRenderPassInfo = GetRenderPassState(pRenderPassBegin->renderPass)->createInfo.ptr();
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700460 auto const &framebufferInfo = framebuffer_state->createInfo;
Tobias Hectorbbb12282018-10-22 15:17:59 +0100461
Mark Lobodzinski2e495882019-03-06 16:11:56 -0700462 auto render_pass = GetRenderPassState(pRenderPassBegin->renderPass)->renderPass;
Tobias Hectorbbb12282018-10-22 15:17:59 +0100463 auto framebuffer = framebuffer_state->framebuffer;
464
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700465 if (pRenderPassInfo->attachmentCount != framebufferInfo.attachmentCount) {
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600466 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton51653902018-06-22 17:32:13 -0600467 HandleToUint64(pCB->commandBuffer), kVUID_Core_DrawState_InvalidRenderpass,
Dave Houltona9df0ce2018-02-07 10:51:23 -0700468 "You cannot start a render pass using a framebuffer with a different number of attachments.");
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700469 }
470 for (uint32_t i = 0; i < pRenderPassInfo->attachmentCount; ++i) {
471 const VkImageView &image_view = framebufferInfo.pAttachments[i];
Mark Lobodzinskia3a230b2019-03-06 15:35:13 -0700472 auto view_state = GetImageViewState(image_view);
John Zulauf8e308292018-09-21 11:34:37 -0600473
474 if (!view_state) {
Lockee9aeebf2019-03-03 23:50:08 -0700475 skip |=
476 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
477 HandleToUint64(pRenderPassBegin->renderPass), "VUID-VkRenderPassBeginInfo-framebuffer-parameter",
478 "vkCmdBeginRenderPass(): framebuffer %s pAttachments[%" PRIu32 "] = %s is not a valid VkImageView handle",
479 report_data->FormatHandle(framebuffer_state->framebuffer).c_str(), i,
480 report_data->FormatHandle(image_view).c_str());
John Zulauf8e308292018-09-21 11:34:37 -0600481 continue;
482 }
483
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700484 const VkImage &image = view_state->create_info.image;
485 const VkImageSubresourceRange &subRange = view_state->create_info.subresourceRange;
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700486 auto initial_layout = pRenderPassInfo->pAttachments[i].initialLayout;
Tobias Hectorbbb12282018-10-22 15:17:59 +0100487 auto final_layout = pRenderPassInfo->pAttachments[i].finalLayout;
488
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700489 // TODO: Do not iterate over every possibility - consolidate where possible
490 for (uint32_t j = 0; j < subRange.levelCount; j++) {
491 uint32_t level = subRange.baseMipLevel + j;
492 for (uint32_t k = 0; k < subRange.layerCount; k++) {
493 uint32_t layer = subRange.baseArrayLayer + k;
494 VkImageSubresource sub = {subRange.aspectMask, level, layer};
495 IMAGE_CMD_BUF_LAYOUT_NODE node;
496 if (!FindCmdBufLayout(device_data, pCB, image, sub, node)) {
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700497 // Missing layouts will be added during state update
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700498 continue;
499 }
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700500 if (initial_layout != VK_IMAGE_LAYOUT_UNDEFINED && initial_layout != node.layout) {
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600501 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton51653902018-06-22 17:32:13 -0600502 kVUID_Core_DrawState_InvalidRenderpass,
Dave Houltona9df0ce2018-02-07 10:51:23 -0700503 "You cannot start a render pass using attachment %u where the render pass initial layout is %s "
504 "and the previous known layout of the attachment is %s. The layouts must match, or the render "
505 "pass initial layout for the attachment must be VK_IMAGE_LAYOUT_UNDEFINED",
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600506 i, string_VkImageLayout(initial_layout), string_VkImageLayout(node.layout));
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700507 }
508 }
509 }
Tobias Hectorbbb12282018-10-22 15:17:59 +0100510
511 ValidateRenderPassLayoutAgainstFramebufferImageUsage(device_data, rp_version, initial_layout, image, image_view,
512 framebuffer, render_pass, i, "initial layout");
513
514 ValidateRenderPassLayoutAgainstFramebufferImageUsage(device_data, rp_version, final_layout, image, image_view, framebuffer,
515 render_pass, i, "final layout");
516 }
517
518 for (uint32_t j = 0; j < pRenderPassInfo->subpassCount; ++j) {
519 auto &subpass = pRenderPassInfo->pSubpasses[j];
520 for (uint32_t k = 0; k < pRenderPassInfo->pSubpasses[j].inputAttachmentCount; ++k) {
521 auto &attachment_ref = subpass.pInputAttachments[k];
522 if (attachment_ref.attachment != VK_ATTACHMENT_UNUSED) {
523 auto image_view = framebufferInfo.pAttachments[attachment_ref.attachment];
Mark Lobodzinskia3a230b2019-03-06 15:35:13 -0700524 auto view_state = GetImageViewState(image_view);
Tobias Hectorbbb12282018-10-22 15:17:59 +0100525
526 if (view_state) {
527 auto image = view_state->create_info.image;
528 ValidateRenderPassLayoutAgainstFramebufferImageUsage(device_data, rp_version, attachment_ref.layout, image,
529 image_view, framebuffer, render_pass,
530 attachment_ref.attachment, "input attachment layout");
531 }
532 }
533 }
534
535 for (uint32_t k = 0; k < pRenderPassInfo->pSubpasses[j].colorAttachmentCount; ++k) {
536 auto &attachment_ref = subpass.pColorAttachments[k];
537 if (attachment_ref.attachment != VK_ATTACHMENT_UNUSED) {
538 auto image_view = framebufferInfo.pAttachments[attachment_ref.attachment];
Mark Lobodzinskia3a230b2019-03-06 15:35:13 -0700539 auto view_state = GetImageViewState(image_view);
Tobias Hectorbbb12282018-10-22 15:17:59 +0100540
541 if (view_state) {
542 auto image = view_state->create_info.image;
543 ValidateRenderPassLayoutAgainstFramebufferImageUsage(device_data, rp_version, attachment_ref.layout, image,
544 image_view, framebuffer, render_pass,
545 attachment_ref.attachment, "color attachment layout");
546 if (subpass.pResolveAttachments) {
547 ValidateRenderPassLayoutAgainstFramebufferImageUsage(
548 device_data, rp_version, attachment_ref.layout, image, image_view, framebuffer, render_pass,
549 attachment_ref.attachment, "resolve attachment layout");
550 }
551 }
552 }
553 }
554
555 if (pRenderPassInfo->pSubpasses[j].pDepthStencilAttachment) {
556 auto &attachment_ref = *subpass.pDepthStencilAttachment;
557 if (attachment_ref.attachment != VK_ATTACHMENT_UNUSED) {
558 auto image_view = framebufferInfo.pAttachments[attachment_ref.attachment];
Mark Lobodzinskia3a230b2019-03-06 15:35:13 -0700559 auto view_state = GetImageViewState(image_view);
Tobias Hectorbbb12282018-10-22 15:17:59 +0100560
561 if (view_state) {
562 auto image = view_state->create_info.image;
563 ValidateRenderPassLayoutAgainstFramebufferImageUsage(device_data, rp_version, attachment_ref.layout, image,
564 image_view, framebuffer, render_pass,
565 attachment_ref.attachment, "input attachment layout");
566 }
567 }
568 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700569 }
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600570 return skip;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700571}
572
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700573void CoreChecks::TransitionAttachmentRefLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, FRAMEBUFFER_STATE *pFramebuffer,
574 const safe_VkAttachmentReference2KHR &ref) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700575 if (ref.attachment != VK_ATTACHMENT_UNUSED) {
Mark Lobodzinskia3a230b2019-03-06 15:35:13 -0700576 auto image_view = GetAttachmentImageViewState(pFramebuffer, ref.attachment);
John Zulauf8e308292018-09-21 11:34:37 -0600577 if (image_view) {
578 SetImageViewLayout(device_data, pCB, image_view, ref.layout);
579 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700580 }
581}
582
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700583void CoreChecks::TransitionSubpassLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB, const RENDER_PASS_STATE *render_pass_state,
584 const int subpass_index, FRAMEBUFFER_STATE *framebuffer_state) {
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700585 assert(render_pass_state);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700586
587 if (framebuffer_state) {
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700588 auto const &subpass = render_pass_state->createInfo.pSubpasses[subpass_index];
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700589 for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) {
590 TransitionAttachmentRefLayout(device_data, pCB, framebuffer_state, subpass.pInputAttachments[j]);
591 }
592 for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) {
593 TransitionAttachmentRefLayout(device_data, pCB, framebuffer_state, subpass.pColorAttachments[j]);
594 }
595 if (subpass.pDepthStencilAttachment) {
596 TransitionAttachmentRefLayout(device_data, pCB, framebuffer_state, *subpass.pDepthStencilAttachment);
597 }
598 }
599}
600
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700601bool CoreChecks::ValidateImageAspectLayout(layer_data *device_data, GLOBAL_CB_NODE const *pCB,
602 const VkImageMemoryBarrier *mem_barrier, uint32_t level, uint32_t layer,
603 VkImageAspectFlags aspect) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700604 if (!(mem_barrier->subresourceRange.aspectMask & aspect)) {
605 return false;
606 }
607 VkImageSubresource sub = {aspect, level, layer};
608 IMAGE_CMD_BUF_LAYOUT_NODE node;
609 if (!FindCmdBufLayout(device_data, pCB, mem_barrier->image, sub, node)) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700610 return false;
611 }
612 bool skip = false;
613 if (mem_barrier->oldLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
614 // TODO: Set memory invalid which is in mem_tracker currently
615 } else if (node.layout != mem_barrier->oldLayout) {
Lockee9aeebf2019-03-03 23:50:08 -0700616 skip = log_msg(
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700617 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
618 HandleToUint64(pCB->commandBuffer), "VUID-VkImageMemoryBarrier-oldLayout-01197",
Lockee9aeebf2019-03-03 23:50:08 -0700619 "For image %s you cannot transition the layout of aspect=%d level=%d layer=%d from %s when current layout is %s.",
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700620 report_data->FormatHandle(mem_barrier->image).c_str(), aspect, level, layer,
Lockee9aeebf2019-03-03 23:50:08 -0700621 string_VkImageLayout(mem_barrier->oldLayout), string_VkImageLayout(node.layout));
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700622 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700623 return skip;
624}
625
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700626// Transition the layout state for renderpass attachments based on the BeginRenderPass() call. This includes:
627// 1. Transition into initialLayout state
628// 2. Transition from initialLayout to layout used in subpass 0
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700629void CoreChecks::TransitionBeginRenderPassLayouts(layer_data *device_data, GLOBAL_CB_NODE *cb_state,
630 const RENDER_PASS_STATE *render_pass_state,
631 FRAMEBUFFER_STATE *framebuffer_state) {
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700632 // First transition into initialLayout
633 auto const rpci = render_pass_state->createInfo.ptr();
634 for (uint32_t i = 0; i < rpci->attachmentCount; ++i) {
Mark Lobodzinskia3a230b2019-03-06 15:35:13 -0700635 auto view_state = GetAttachmentImageViewState(framebuffer_state, i);
John Zulauf8e308292018-09-21 11:34:37 -0600636 if (view_state) {
637 SetImageViewLayout(device_data, cb_state, view_state, rpci->pAttachments[i].initialLayout);
638 }
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700639 }
640 // Now transition for first subpass (index 0)
641 TransitionSubpassLayouts(device_data, cb_state, render_pass_state, 0, framebuffer_state);
642}
643
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700644void CoreChecks::TransitionImageAspectLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, const VkImageMemoryBarrier *mem_barrier,
645 uint32_t level, uint32_t layer, VkImageAspectFlags aspect_mask,
646 VkImageAspectFlags aspect) {
Tony-LunarG0d27b302018-10-08 09:26:21 -0600647 if (!(aspect_mask & aspect)) {
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -0700648 return;
649 }
650 VkImageSubresource sub = {aspect, level, layer};
651 IMAGE_CMD_BUF_LAYOUT_NODE node;
652 if (!FindCmdBufLayout(device_data, pCB, mem_barrier->image, sub, node)) {
John Zulauf48a6a702017-12-22 17:14:54 -0700653 pCB->image_layout_change_count++; // Change the version of this data to force revalidation
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -0700654 SetLayout(device_data, pCB, mem_barrier->image, sub,
655 IMAGE_CMD_BUF_LAYOUT_NODE(mem_barrier->oldLayout, mem_barrier->newLayout));
656 return;
657 }
658 if (mem_barrier->oldLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
659 // TODO: Set memory invalid
660 }
661 SetLayout(device_data, pCB, mem_barrier->image, sub, mem_barrier->newLayout);
662}
663
Dave Houlton10b39482017-03-16 13:18:15 -0600664bool VerifyAspectsPresent(VkImageAspectFlags aspect_mask, VkFormat format) {
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600665 if ((aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != 0) {
Dave Houltone2fca552018-04-05 16:20:33 -0600666 if (!(FormatIsColor(format) || FormatIsMultiplane(format))) return false;
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600667 }
668 if ((aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) != 0) {
Dave Houlton1d2022c2017-03-29 11:43:58 -0600669 if (!FormatHasDepth(format)) return false;
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600670 }
671 if ((aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) != 0) {
Dave Houlton1d2022c2017-03-29 11:43:58 -0600672 if (!FormatHasStencil(format)) return false;
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600673 }
Dave Houltonb3f4b282018-02-22 16:25:16 -0700674 if (0 !=
675 (aspect_mask & (VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR | VK_IMAGE_ASPECT_PLANE_2_BIT_KHR))) {
676 if (FormatPlaneCount(format) == 1) return false;
677 }
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600678 return true;
679}
680
Mike Weiblen62d08a32017-03-07 22:18:27 -0700681// Verify an ImageMemoryBarrier's old/new ImageLayouts are compatible with the Image's ImageUsageFlags.
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700682bool CoreChecks::ValidateBarrierLayoutToImageUsage(layer_data *device_data, const VkImageMemoryBarrier *img_barrier,
683 bool new_not_old, VkImageUsageFlags usage_flags, const char *func_name) {
Mike Weiblen62d08a32017-03-07 22:18:27 -0700684 bool skip = false;
685 const VkImageLayout layout = (new_not_old) ? img_barrier->newLayout : img_barrier->oldLayout;
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600686 const char *msg_code = kVUIDUndefined; // sentinel value meaning "no error"
Mike Weiblen62d08a32017-03-07 22:18:27 -0700687
688 switch (layout) {
689 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
690 if ((usage_flags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -0600691 msg_code = "VUID-VkImageMemoryBarrier-oldLayout-01208";
Mike Weiblen62d08a32017-03-07 22:18:27 -0700692 }
693 break;
694 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
695 if ((usage_flags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -0600696 msg_code = "VUID-VkImageMemoryBarrier-oldLayout-01209";
Mike Weiblen62d08a32017-03-07 22:18:27 -0700697 }
698 break;
699 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
700 if ((usage_flags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -0600701 msg_code = "VUID-VkImageMemoryBarrier-oldLayout-01210";
Mike Weiblen62d08a32017-03-07 22:18:27 -0700702 }
703 break;
704 case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
705 if ((usage_flags & (VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)) == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -0600706 msg_code = "VUID-VkImageMemoryBarrier-oldLayout-01211";
Mike Weiblen62d08a32017-03-07 22:18:27 -0700707 }
708 break;
709 case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
710 if ((usage_flags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -0600711 msg_code = "VUID-VkImageMemoryBarrier-oldLayout-01212";
Mike Weiblen62d08a32017-03-07 22:18:27 -0700712 }
713 break;
714 case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
715 if ((usage_flags & VK_IMAGE_USAGE_TRANSFER_DST_BIT) == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -0600716 msg_code = "VUID-VkImageMemoryBarrier-oldLayout-01213";
Mike Weiblen62d08a32017-03-07 22:18:27 -0700717 }
718 break;
Dave Houlton142c4cb2018-10-17 15:04:41 -0600719 case VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV:
Jeff Bolz9af91c52018-09-01 21:53:57 -0500720 if ((usage_flags & VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV) == 0) {
721 msg_code = "VUID-VkImageMemoryBarrier-oldLayout-02088";
722 }
723 break;
Mike Weiblen62d08a32017-03-07 22:18:27 -0700724 default:
725 // Other VkImageLayout values do not have VUs defined in this context.
726 break;
727 }
728
Dave Houlton8e9f6542018-05-18 12:18:22 -0600729 if (msg_code != kVUIDUndefined) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600730 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -0600731 HandleToUint64(img_barrier->image), msg_code,
Lockee9aeebf2019-03-03 23:50:08 -0700732 "%s: Image barrier 0x%p %sLayout=%s is not compatible with image %s usage flags 0x%" PRIx32 ".", func_name,
733 static_cast<const void *>(img_barrier), ((new_not_old) ? "new" : "old"), string_VkImageLayout(layout),
734 report_data->FormatHandle(img_barrier->image).c_str(), usage_flags);
Mike Weiblen62d08a32017-03-07 22:18:27 -0700735 }
736 return skip;
737}
738
John Zulauf463c51e2018-05-31 13:29:20 -0600739// Scoreboard for checking for duplicate and inconsistent barriers to images
740struct ImageBarrierScoreboardEntry {
741 uint32_t index;
742 // This is designed for temporary storage within the scope of the API call. If retained storage of the barriers is
743 // required, copies should be made and smart or unique pointers used in some other stucture (or this one refactored)
744 const VkImageMemoryBarrier *barrier;
745};
746using ImageBarrierScoreboardSubresMap = std::unordered_map<VkImageSubresourceRange, ImageBarrierScoreboardEntry>;
747using ImageBarrierScoreboardImageMap = std::unordered_map<VkImage, ImageBarrierScoreboardSubresMap>;
748
Mike Weiblen62d08a32017-03-07 22:18:27 -0700749// Verify image barriers are compatible with the images they reference.
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700750bool CoreChecks::ValidateBarriersToImages(layer_data *device_data, GLOBAL_CB_NODE const *cb_state, uint32_t imageMemoryBarrierCount,
751 const VkImageMemoryBarrier *pImageMemoryBarriers, const char *func_name) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700752 bool skip = false;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700753
John Zulauf463c51e2018-05-31 13:29:20 -0600754 // Scoreboard for duplicate layout transition barriers within the list
755 // Pointers retained in the scoreboard only have the lifetime of *this* call (i.e. within the scope of the API call)
756 ImageBarrierScoreboardImageMap layout_transitions;
757
Mike Weiblen62d08a32017-03-07 22:18:27 -0700758 for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
759 auto img_barrier = &pImageMemoryBarriers[i];
760 if (!img_barrier) continue;
761
John Zulauf463c51e2018-05-31 13:29:20 -0600762 // Update the scoreboard of layout transitions and check for barriers affecting the same image and subresource
763 // TODO: a higher precision could be gained by adapting the command_buffer image_layout_map logic looking for conflicts
764 // at a per sub-resource level
765 if (img_barrier->oldLayout != img_barrier->newLayout) {
766 ImageBarrierScoreboardEntry new_entry{i, img_barrier};
767 auto image_it = layout_transitions.find(img_barrier->image);
768 if (image_it != layout_transitions.end()) {
769 auto &subres_map = image_it->second;
770 auto subres_it = subres_map.find(img_barrier->subresourceRange);
771 if (subres_it != subres_map.end()) {
772 auto &entry = subres_it->second;
773 if ((entry.barrier->newLayout != img_barrier->oldLayout) &&
774 (img_barrier->oldLayout != VK_IMAGE_LAYOUT_UNDEFINED)) {
775 const VkImageSubresourceRange &range = img_barrier->subresourceRange;
776 skip = log_msg(
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700777 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
778 HandleToUint64(cb_state->commandBuffer), "VUID-VkImageMemoryBarrier-oldLayout-01197",
Lockee9aeebf2019-03-03 23:50:08 -0700779 "%s: pImageMemoryBarrier[%u] conflicts with earlier entry pImageMemoryBarrier[%u]. Image %s"
John Zulauf463c51e2018-05-31 13:29:20 -0600780 " subresourceRange: aspectMask=%u baseMipLevel=%u levelCount=%u, baseArrayLayer=%u, layerCount=%u; "
781 "conflicting barrier transitions image layout from %s when earlier barrier transitioned to layout %s.",
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700782 func_name, i, entry.index, report_data->FormatHandle(img_barrier->image).c_str(), range.aspectMask,
Lockee9aeebf2019-03-03 23:50:08 -0700783 range.baseMipLevel, range.levelCount, range.baseArrayLayer, range.layerCount,
784 string_VkImageLayout(img_barrier->oldLayout), string_VkImageLayout(entry.barrier->newLayout));
John Zulauf463c51e2018-05-31 13:29:20 -0600785 }
786 entry = new_entry;
787 } else {
788 subres_map[img_barrier->subresourceRange] = new_entry;
789 }
790 } else {
791 layout_transitions[img_barrier->image][img_barrier->subresourceRange] = new_entry;
792 }
793 }
794
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -0700795 auto image_state = GetImageState(img_barrier->image);
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -0600796 if (image_state) {
797 VkImageUsageFlags usage_flags = image_state->createInfo.usage;
798 skip |= ValidateBarrierLayoutToImageUsage(device_data, img_barrier, false, usage_flags, func_name);
799 skip |= ValidateBarrierLayoutToImageUsage(device_data, img_barrier, true, usage_flags, func_name);
800
801 // Make sure layout is able to be transitioned, currently only presented shared presentable images are locked
802 if (image_state->layout_locked) {
803 // TODO: Add unique id for error when available
Dave Houlton33c2d252017-06-09 17:08:32 -0600804 skip |= log_msg(
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700805 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
806 HandleToUint64(img_barrier->image), 0,
Lockee9aeebf2019-03-03 23:50:08 -0700807 "Attempting to transition shared presentable image %s"
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -0600808 " from layout %s to layout %s, but image has already been presented and cannot have its layout transitioned.",
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700809 report_data->FormatHandle(img_barrier->image).c_str(), string_VkImageLayout(img_barrier->oldLayout),
810 string_VkImageLayout(img_barrier->newLayout));
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -0600811 }
812 }
813
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -0700814 VkImageCreateInfo *image_create_info = &(GetImageState(img_barrier->image)->createInfo);
Tobin Ehlis7ee9cbd2017-04-26 16:51:48 -0600815 // For a Depth/Stencil image both aspects MUST be set
816 if (FormatIsDepthAndStencil(image_create_info->format)) {
817 auto const aspect_mask = img_barrier->subresourceRange.aspectMask;
818 auto const ds_mask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
819 if ((aspect_mask & ds_mask) != (ds_mask)) {
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700820 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
821 HandleToUint64(img_barrier->image), "VUID-VkImageMemoryBarrier-image-01207",
Lockee9aeebf2019-03-03 23:50:08 -0700822 "%s: Image barrier 0x%p references image %s of format %s that must have the depth and stencil "
823 "aspects set, but its aspectMask is 0x%" PRIx32 ".",
824 func_name, static_cast<const void *>(img_barrier),
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700825 report_data->FormatHandle(img_barrier->image).c_str(), string_VkFormat(image_create_info->format),
826 aspect_mask);
Tobin Ehlis7ee9cbd2017-04-26 16:51:48 -0600827 }
828 }
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -0600829 uint32_t level_count = ResolveRemainingLevels(&img_barrier->subresourceRange, image_create_info->mipLevels);
830 uint32_t layer_count = ResolveRemainingLayers(&img_barrier->subresourceRange, image_create_info->arrayLayers);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700831
Mike Weiblen62d08a32017-03-07 22:18:27 -0700832 for (uint32_t j = 0; j < level_count; j++) {
833 uint32_t level = img_barrier->subresourceRange.baseMipLevel + j;
834 for (uint32_t k = 0; k < layer_count; k++) {
835 uint32_t layer = img_barrier->subresourceRange.baseArrayLayer + k;
Tobin Ehlis9c0df962017-07-17 10:14:27 -0600836 skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, VK_IMAGE_ASPECT_COLOR_BIT);
837 skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, VK_IMAGE_ASPECT_DEPTH_BIT);
838 skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, VK_IMAGE_ASPECT_STENCIL_BIT);
839 skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, VK_IMAGE_ASPECT_METADATA_BIT);
Mark Lobodzinski60e79032019-03-07 10:22:31 -0700840 if (GetDeviceExtensions()->vk_khr_sampler_ycbcr_conversion) {
Dave Houltonb3f4b282018-02-22 16:25:16 -0700841 skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer,
842 VK_IMAGE_ASPECT_PLANE_0_BIT_KHR);
843 skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer,
844 VK_IMAGE_ASPECT_PLANE_1_BIT_KHR);
845 skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer,
846 VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
847 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700848 }
849 }
850 }
851 return skip;
852}
853
Mark Lobodzinski8deebf12019-03-07 11:38:38 -0700854bool CoreChecks::IsReleaseOp(GLOBAL_CB_NODE *cb_state, VkImageMemoryBarrier const *barrier) {
John Zulauf1b33d5a2018-03-24 19:52:19 -0600855 if (!IsTransferOp(barrier)) return false;
Chris Forbes4de4b132017-08-21 11:27:08 -0700856
Mark Lobodzinski8b0a7b82019-03-06 16:17:45 -0700857 auto pool = GetCommandPoolNode(cb_state->createInfo.commandPool);
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700858 return pool && TempIsReleaseOp<VkImageMemoryBarrier, true>(pool, barrier);
Chris Forbes4de4b132017-08-21 11:27:08 -0700859}
860
John Zulauf6b4aae82018-05-09 13:03:36 -0600861template <typename Barrier>
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700862bool CoreChecks::ValidateQFOTransferBarrierUniqueness(layer_data *device_data, const char *func_name, GLOBAL_CB_NODE *cb_state,
863 uint32_t barrier_count, const Barrier *barriers) {
John Zulauf6b4aae82018-05-09 13:03:36 -0600864 using BarrierRecord = QFOTransferBarrier<Barrier>;
865 bool skip = false;
Mark Lobodzinski8b0a7b82019-03-06 16:17:45 -0700866 auto pool = GetCommandPoolNode(cb_state->createInfo.commandPool);
John Zulauf6b4aae82018-05-09 13:03:36 -0600867 auto &barrier_sets = GetQFOBarrierSets(cb_state, typename BarrierRecord::Tag());
868 const char *barrier_name = BarrierRecord::BarrierName();
869 const char *handle_name = BarrierRecord::HandleName();
870 const char *transfer_type = nullptr;
871 for (uint32_t b = 0; b < barrier_count; b++) {
872 if (!IsTransferOp(&barriers[b])) continue;
873 const BarrierRecord *barrier_record = nullptr;
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700874 if (TempIsReleaseOp<Barrier, true /* Assume IsTransfer */>(pool, &barriers[b]) &&
875 !IsSpecial(barriers[b].dstQueueFamilyIndex)) {
John Zulauf6b4aae82018-05-09 13:03:36 -0600876 const auto found = barrier_sets.release.find(barriers[b]);
877 if (found != barrier_sets.release.cend()) {
878 barrier_record = &(*found);
879 transfer_type = "releasing";
880 }
Shannon McPhersoned2f0092018-08-30 17:18:04 -0600881 } else if (IsAcquireOp<Barrier, true /*Assume IsTransfer */>(pool, &barriers[b]) &&
882 !IsSpecial(barriers[b].srcQueueFamilyIndex)) {
John Zulauf6b4aae82018-05-09 13:03:36 -0600883 const auto found = barrier_sets.acquire.find(barriers[b]);
884 if (found != barrier_sets.acquire.cend()) {
885 barrier_record = &(*found);
886 transfer_type = "acquiring";
887 }
888 }
889 if (barrier_record != nullptr) {
Lockee9aeebf2019-03-03 23:50:08 -0700890 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
891 HandleToUint64(cb_state->commandBuffer), BarrierRecord::ErrMsgDuplicateQFOInCB(),
892 "%s: %s at index %" PRIu32 " %s queue ownership of %s (%s), from srcQueueFamilyIndex %" PRIu32
893 " to dstQueueFamilyIndex %" PRIu32 " duplicates existing barrier recorded in this command buffer.",
894 func_name, barrier_name, b, transfer_type, handle_name,
895 report_data->FormatHandle(barrier_record->handle).c_str(), barrier_record->srcQueueFamilyIndex,
896 barrier_record->dstQueueFamilyIndex);
John Zulauf6b4aae82018-05-09 13:03:36 -0600897 }
898 }
899 return skip;
900}
901
902template <typename Barrier>
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700903void CoreChecks::RecordQFOTransferBarriers(layer_data *device_data, GLOBAL_CB_NODE *cb_state, uint32_t barrier_count,
904 const Barrier *barriers) {
Mark Lobodzinski8b0a7b82019-03-06 16:17:45 -0700905 auto pool = GetCommandPoolNode(cb_state->createInfo.commandPool);
John Zulauf6b4aae82018-05-09 13:03:36 -0600906 auto &barrier_sets = GetQFOBarrierSets(cb_state, typename QFOTransferBarrier<Barrier>::Tag());
907 for (uint32_t b = 0; b < barrier_count; b++) {
908 if (!IsTransferOp(&barriers[b])) continue;
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700909 if (TempIsReleaseOp<Barrier, true /* Assume IsTransfer*/>(pool, &barriers[b]) &&
910 !IsSpecial(barriers[b].dstQueueFamilyIndex)) {
John Zulauf6b4aae82018-05-09 13:03:36 -0600911 barrier_sets.release.emplace(barriers[b]);
Shannon McPhersoned2f0092018-08-30 17:18:04 -0600912 } else if (IsAcquireOp<Barrier, true /*Assume IsTransfer */>(pool, &barriers[b]) &&
913 !IsSpecial(barriers[b].srcQueueFamilyIndex)) {
John Zulauf6b4aae82018-05-09 13:03:36 -0600914 barrier_sets.acquire.emplace(barriers[b]);
915 }
916 }
917}
918
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700919bool CoreChecks::ValidateBarriersQFOTransferUniqueness(layer_data *device_data, const char *func_name, GLOBAL_CB_NODE *cb_state,
920 uint32_t bufferBarrierCount, const VkBufferMemoryBarrier *pBufferMemBarriers,
921 uint32_t imageMemBarrierCount,
922 const VkImageMemoryBarrier *pImageMemBarriers) {
John Zulauf6b4aae82018-05-09 13:03:36 -0600923 bool skip = false;
924 skip |= ValidateQFOTransferBarrierUniqueness(device_data, func_name, cb_state, bufferBarrierCount, pBufferMemBarriers);
925 skip |= ValidateQFOTransferBarrierUniqueness(device_data, func_name, cb_state, imageMemBarrierCount, pImageMemBarriers);
926 return skip;
927}
928
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700929void CoreChecks::RecordBarriersQFOTransfers(layer_data *device_data, GLOBAL_CB_NODE *cb_state, uint32_t bufferBarrierCount,
930 const VkBufferMemoryBarrier *pBufferMemBarriers, uint32_t imageMemBarrierCount,
931 const VkImageMemoryBarrier *pImageMemBarriers) {
John Zulauf6b4aae82018-05-09 13:03:36 -0600932 RecordQFOTransferBarriers(device_data, cb_state, bufferBarrierCount, pBufferMemBarriers);
933 RecordQFOTransferBarriers(device_data, cb_state, imageMemBarrierCount, pImageMemBarriers);
934}
935
936template <typename BarrierRecord, typename Scoreboard>
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700937bool CoreChecks::ValidateAndUpdateQFOScoreboard(const debug_report_data *report_data, const GLOBAL_CB_NODE *cb_state,
938 const char *operation, const BarrierRecord &barrier, Scoreboard *scoreboard) {
John Zulauf6b4aae82018-05-09 13:03:36 -0600939 // Record to the scoreboard or report that we have a duplication
940 bool skip = false;
941 auto inserted = scoreboard->insert(std::make_pair(barrier, cb_state));
942 if (!inserted.second && inserted.first->second != cb_state) {
943 // This is a duplication (but don't report duplicates from the same CB, as we do that at record time
Lockee9aeebf2019-03-03 23:50:08 -0700944 skip = log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
945 HandleToUint64(cb_state->commandBuffer), BarrierRecord::ErrMsgDuplicateQFOInSubmit(),
946 "%s: %s %s queue ownership of %s (%s), from srcQueueFamilyIndex %" PRIu32 " to dstQueueFamilyIndex %" PRIu32
947 " duplicates existing barrier submitted in this batch from command buffer %s.",
948 "vkQueueSubmit()", BarrierRecord::BarrierName(), operation, BarrierRecord::HandleName(),
949 report_data->FormatHandle(barrier.handle).c_str(), barrier.srcQueueFamilyIndex, barrier.dstQueueFamilyIndex,
950 report_data->FormatHandle(inserted.first->second).c_str());
John Zulauf6b4aae82018-05-09 13:03:36 -0600951 }
952 return skip;
953}
954
955template <typename Barrier>
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700956bool CoreChecks::ValidateQueuedQFOTransferBarriers(layer_data *device_data, GLOBAL_CB_NODE *cb_state,
957 QFOTransferCBScoreboards<Barrier> *scoreboards) {
John Zulauf6b4aae82018-05-09 13:03:36 -0600958 using BarrierRecord = QFOTransferBarrier<Barrier>;
959 using TypeTag = typename BarrierRecord::Tag;
960 bool skip = false;
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700961 const auto report_data = device_data->GetReportData(device_data);
John Zulauf6b4aae82018-05-09 13:03:36 -0600962 const auto &cb_barriers = GetQFOBarrierSets(cb_state, TypeTag());
Mark Lobodzinski8deebf12019-03-07 11:38:38 -0700963 const GlobalQFOTransferBarrierMap<Barrier> &global_release_barriers = GetGlobalQFOReleaseBarrierMap(TypeTag());
John Zulauf6b4aae82018-05-09 13:03:36 -0600964 const char *barrier_name = BarrierRecord::BarrierName();
965 const char *handle_name = BarrierRecord::HandleName();
966 // No release should have an extant duplicate (WARNING)
967 for (const auto &release : cb_barriers.release) {
968 // Check the global pending release barriers
969 const auto set_it = global_release_barriers.find(release.handle);
970 if (set_it != global_release_barriers.cend()) {
971 const QFOTransferBarrierSet<Barrier> &set_for_handle = set_it->second;
972 const auto found = set_for_handle.find(release);
973 if (found != set_for_handle.cend()) {
974 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
975 HandleToUint64(cb_state->commandBuffer), BarrierRecord::ErrMsgDuplicateQFOSubmitted(),
Lockee9aeebf2019-03-03 23:50:08 -0700976 "%s: %s releasing queue ownership of %s (%s), from srcQueueFamilyIndex %" PRIu32
John Zulauf6b4aae82018-05-09 13:03:36 -0600977 " to dstQueueFamilyIndex %" PRIu32
978 " duplicates existing barrier queued for execution, without intervening acquire operation.",
Lockee9aeebf2019-03-03 23:50:08 -0700979 "vkQueueSubmit()", barrier_name, handle_name, report_data->FormatHandle(found->handle).c_str(),
John Zulauf6b4aae82018-05-09 13:03:36 -0600980 found->srcQueueFamilyIndex, found->dstQueueFamilyIndex);
981 }
982 }
983 skip |= ValidateAndUpdateQFOScoreboard(report_data, cb_state, "releasing", release, &scoreboards->release);
984 }
985 // Each acquire must have a matching release (ERROR)
986 for (const auto &acquire : cb_barriers.acquire) {
987 const auto set_it = global_release_barriers.find(acquire.handle);
988 bool matching_release_found = false;
989 if (set_it != global_release_barriers.cend()) {
990 const QFOTransferBarrierSet<Barrier> &set_for_handle = set_it->second;
991 matching_release_found = set_for_handle.find(acquire) != set_for_handle.cend();
992 }
993 if (!matching_release_found) {
994 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
995 HandleToUint64(cb_state->commandBuffer), BarrierRecord::ErrMsgMissingQFOReleaseInSubmit(),
Lockee9aeebf2019-03-03 23:50:08 -0700996 "%s: in submitted command buffer %s acquiring ownership of %s (%s), from srcQueueFamilyIndex %" PRIu32
997 " to dstQueueFamilyIndex %" PRIu32 " has no matching release barrier queued for execution.",
998 "vkQueueSubmit()", barrier_name, handle_name, report_data->FormatHandle(acquire.handle).c_str(),
John Zulauf6b4aae82018-05-09 13:03:36 -0600999 acquire.srcQueueFamilyIndex, acquire.dstQueueFamilyIndex);
1000 }
1001 skip |= ValidateAndUpdateQFOScoreboard(report_data, cb_state, "acquiring", acquire, &scoreboards->acquire);
1002 }
1003 return skip;
1004}
1005
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001006bool CoreChecks::ValidateQueuedQFOTransfers(layer_data *device_data, GLOBAL_CB_NODE *cb_state,
1007 QFOTransferCBScoreboards<VkImageMemoryBarrier> *qfo_image_scoreboards,
1008 QFOTransferCBScoreboards<VkBufferMemoryBarrier> *qfo_buffer_scoreboards) {
John Zulauf6b4aae82018-05-09 13:03:36 -06001009 bool skip = false;
1010 skip |= ValidateQueuedQFOTransferBarriers<VkImageMemoryBarrier>(device_data, cb_state, qfo_image_scoreboards);
1011 skip |= ValidateQueuedQFOTransferBarriers<VkBufferMemoryBarrier>(device_data, cb_state, qfo_buffer_scoreboards);
1012 return skip;
1013}
1014
1015template <typename Barrier>
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001016void CoreChecks::RecordQueuedQFOTransferBarriers(layer_data *device_data, GLOBAL_CB_NODE *cb_state) {
John Zulauf6b4aae82018-05-09 13:03:36 -06001017 using BarrierRecord = QFOTransferBarrier<Barrier>;
1018 using TypeTag = typename BarrierRecord::Tag;
1019 const auto &cb_barriers = GetQFOBarrierSets(cb_state, TypeTag());
Mark Lobodzinski8deebf12019-03-07 11:38:38 -07001020 GlobalQFOTransferBarrierMap<Barrier> &global_release_barriers = GetGlobalQFOReleaseBarrierMap(TypeTag());
John Zulauf6b4aae82018-05-09 13:03:36 -06001021
1022 // Add release barriers from this submit to the global map
1023 for (const auto &release : cb_barriers.release) {
1024 // the global barrier list is mapped by resource handle to allow cleanup on resource destruction
1025 // NOTE: We're using [] because creation of a Set is a needed side effect for new handles
1026 global_release_barriers[release.handle].insert(release);
1027 }
1028
1029 // Erase acquired barriers from this submit from the global map -- essentially marking releases as consumed
1030 for (const auto &acquire : cb_barriers.acquire) {
1031 // NOTE: We're not using [] because we don't want to create entries for missing releases
1032 auto set_it = global_release_barriers.find(acquire.handle);
1033 if (set_it != global_release_barriers.end()) {
1034 QFOTransferBarrierSet<Barrier> &set_for_handle = set_it->second;
1035 set_for_handle.erase(acquire);
1036 if (set_for_handle.size() == 0) { // Clean up empty sets
1037 global_release_barriers.erase(set_it);
1038 }
1039 }
1040 }
1041}
1042
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001043void CoreChecks::RecordQueuedQFOTransfers(layer_data *device_data, GLOBAL_CB_NODE *cb_state) {
John Zulauf6b4aae82018-05-09 13:03:36 -06001044 RecordQueuedQFOTransferBarriers<VkImageMemoryBarrier>(device_data, cb_state);
1045 RecordQueuedQFOTransferBarriers<VkBufferMemoryBarrier>(device_data, cb_state);
1046}
1047
John Zulauf6b4aae82018-05-09 13:03:36 -06001048// Avoid making the template globally visible by exporting the one instance of it we need.
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001049void CoreChecks::EraseQFOImageRelaseBarriers(layer_data *device_data, const VkImage &image) {
John Zulauf6b4aae82018-05-09 13:03:36 -06001050 EraseQFOReleaseBarriers<VkImageMemoryBarrier>(device_data, image);
1051}
1052
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001053void CoreChecks::TransitionImageLayouts(layer_data *device_data, GLOBAL_CB_NODE *cb_state, uint32_t memBarrierCount,
1054 const VkImageMemoryBarrier *pImgMemBarriers) {
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -07001055 for (uint32_t i = 0; i < memBarrierCount; ++i) {
1056 auto mem_barrier = &pImgMemBarriers[i];
1057 if (!mem_barrier) continue;
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -07001058
Chris Forbes4de4b132017-08-21 11:27:08 -07001059 // For ownership transfers, the barrier is specified twice; as a release
1060 // operation on the yielding queue family, and as an acquire operation
1061 // on the acquiring queue family. This barrier may also include a layout
1062 // transition, which occurs 'between' the two operations. For validation
1063 // purposes it doesn't seem important which side performs the layout
1064 // transition, but it must not be performed twice. We'll arbitrarily
1065 // choose to perform it as part of the acquire operation.
Mark Lobodzinski8deebf12019-03-07 11:38:38 -07001066 if (IsReleaseOp(cb_state, mem_barrier)) {
Chris Forbes4de4b132017-08-21 11:27:08 -07001067 continue;
1068 }
1069
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07001070 VkImageCreateInfo *image_create_info = &(GetImageState(mem_barrier->image)->createInfo);
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001071 uint32_t level_count = ResolveRemainingLevels(&mem_barrier->subresourceRange, image_create_info->mipLevels);
1072 uint32_t layer_count = ResolveRemainingLayers(&mem_barrier->subresourceRange, image_create_info->arrayLayers);
1073
Dave Houltonb3f4b282018-02-22 16:25:16 -07001074 // Special case for 3D images with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR flag bit, where <extent.depth> and
1075 // <arrayLayers> can potentially alias. When recording layout for the entire image, pre-emptively record layouts
1076 // for all (potential) layer sub_resources.
1077 if ((0 != (image_create_info->flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR)) &&
1078 (mem_barrier->subresourceRange.baseArrayLayer == 0) && (layer_count == 1)) {
1079 layer_count = image_create_info->extent.depth; // Treat each depth slice as a layer subresource
1080 }
1081
Tony-LunarG0d27b302018-10-08 09:26:21 -06001082 // For multiplanar formats, IMAGE_ASPECT_COLOR is equivalent to adding the aspect of the individual planes
1083 VkImageAspectFlags aspect_mask = mem_barrier->subresourceRange.aspectMask;
Mark Lobodzinski60e79032019-03-07 10:22:31 -07001084 if (GetDeviceExtensions()->vk_khr_sampler_ycbcr_conversion) {
Tony-LunarG0d27b302018-10-08 09:26:21 -06001085 if (FormatIsMultiplane(image_create_info->format)) {
1086 if (aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) {
1087 aspect_mask &= ~VK_IMAGE_ASPECT_COLOR_BIT;
1088 aspect_mask |= (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT);
1089 if (FormatPlaneCount(image_create_info->format) > 2) {
1090 aspect_mask |= VK_IMAGE_ASPECT_PLANE_2_BIT;
1091 }
1092 }
1093 }
1094 }
1095
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001096 for (uint32_t j = 0; j < level_count; j++) {
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -07001097 uint32_t level = mem_barrier->subresourceRange.baseMipLevel + j;
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001098 for (uint32_t k = 0; k < layer_count; k++) {
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -07001099 uint32_t layer = mem_barrier->subresourceRange.baseArrayLayer + k;
Tony-LunarG0d27b302018-10-08 09:26:21 -06001100 TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, aspect_mask,
1101 VK_IMAGE_ASPECT_COLOR_BIT);
1102 TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, aspect_mask,
1103 VK_IMAGE_ASPECT_DEPTH_BIT);
1104 TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, aspect_mask,
1105 VK_IMAGE_ASPECT_STENCIL_BIT);
1106 TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, aspect_mask,
1107 VK_IMAGE_ASPECT_METADATA_BIT);
Mark Lobodzinski60e79032019-03-07 10:22:31 -07001108 if (GetDeviceExtensions()->vk_khr_sampler_ycbcr_conversion) {
Tony-LunarG0d27b302018-10-08 09:26:21 -06001109 TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, aspect_mask,
1110 VK_IMAGE_ASPECT_PLANE_0_BIT_KHR);
1111 TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, aspect_mask,
1112 VK_IMAGE_ASPECT_PLANE_1_BIT_KHR);
1113 TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, aspect_mask,
1114 VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
Dave Houltonb3f4b282018-02-22 16:25:16 -07001115 }
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -07001116 }
1117 }
1118 }
1119}
1120
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001121bool CoreChecks::VerifyImageLayout(layer_data const *device_data, GLOBAL_CB_NODE const *cb_node, IMAGE_STATE *image_state,
1122 VkImageSubresourceLayers subLayers, VkImageLayout explicit_layout, VkImageLayout optimal_layout,
1123 const char *caller, const char *layout_invalid_msg_code, const char *layout_mismatch_msg_code,
1124 bool *error) {
Tobin Ehlis2d85ec62017-03-14 15:38:48 -06001125 const auto image = image_state->image;
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -06001126 bool skip = false;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001127
1128 for (uint32_t i = 0; i < subLayers.layerCount; ++i) {
1129 uint32_t layer = i + subLayers.baseArrayLayer;
1130 VkImageSubresource sub = {subLayers.aspectMask, subLayers.mipLevel, layer};
1131 IMAGE_CMD_BUF_LAYOUT_NODE node;
Tobin Ehlise35b66a2017-03-15 12:18:31 -06001132 if (FindCmdBufLayout(device_data, cb_node, image, sub, node)) {
1133 if (node.layout != explicit_layout) {
Tobin Ehlisc8266452017-04-07 12:20:30 -06001134 *error = true;
Cort Stratton7df30962018-05-17 19:45:57 -07001135 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
1136 HandleToUint64(cb_node->commandBuffer), layout_mismatch_msg_code,
Lockee9aeebf2019-03-03 23:50:08 -07001137 "%s: Cannot use image %s (layer=%u mip=%u) with specific layout %s that doesn't match the actual "
1138 "current layout %s.",
1139 caller, report_data->FormatHandle(image).c_str(), layer, subLayers.mipLevel,
1140 string_VkImageLayout(explicit_layout), string_VkImageLayout(node.layout));
Tobin Ehlise35b66a2017-03-15 12:18:31 -06001141 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001142 }
1143 }
Tobin Ehlis2d85ec62017-03-14 15:38:48 -06001144 // If optimal_layout is not UNDEFINED, check that layout matches optimal for this case
1145 if ((VK_IMAGE_LAYOUT_UNDEFINED != optimal_layout) && (explicit_layout != optimal_layout)) {
1146 if (VK_IMAGE_LAYOUT_GENERAL == explicit_layout) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001147 if (image_state->createInfo.tiling != VK_IMAGE_TILING_LINEAR) {
1148 // LAYOUT_GENERAL is allowed, but may not be performance optimal, flag as perf warning.
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -06001149 skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06001150 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(cb_node->commandBuffer),
Dave Houlton51653902018-06-22 17:32:13 -06001151 kVUID_Core_DrawState_InvalidImageLayout,
Lockee9aeebf2019-03-03 23:50:08 -07001152 "%s: For optimal performance image %s layout should be %s instead of GENERAL.", caller,
1153 report_data->FormatHandle(image).c_str(), string_VkImageLayout(optimal_layout));
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001154 }
Mark Lobodzinski60e79032019-03-07 10:22:31 -07001155 } else if (GetDeviceExtensions()->vk_khr_shared_presentable_image) {
Mark Lobodzinski087380c2017-05-16 14:42:25 -06001156 if (image_state->shared_presentable) {
1157 if (VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR != explicit_layout) {
Cort Stratton7df30962018-05-17 19:45:57 -07001158 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1159 layout_invalid_msg_code,
1160 "Layout for shared presentable image is %s but must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR.",
1161 string_VkImageLayout(optimal_layout));
Mark Lobodzinski087380c2017-05-16 14:42:25 -06001162 }
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -06001163 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001164 } else {
Tobin Ehlisc8266452017-04-07 12:20:30 -06001165 *error = true;
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -06001166 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Cort Stratton7df30962018-05-17 19:45:57 -07001167 HandleToUint64(cb_node->commandBuffer), layout_invalid_msg_code,
Lockee9aeebf2019-03-03 23:50:08 -07001168 "%s: Layout for image %s is %s but can only be %s or VK_IMAGE_LAYOUT_GENERAL.", caller,
1169 report_data->FormatHandle(image).c_str(), string_VkImageLayout(explicit_layout),
1170 string_VkImageLayout(optimal_layout));
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001171 }
1172 }
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -06001173 return skip;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001174}
1175
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001176void CoreChecks::TransitionFinalSubpassLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB,
1177 const VkRenderPassBeginInfo *pRenderPassBegin,
1178 FRAMEBUFFER_STATE *framebuffer_state) {
Mark Lobodzinski2e495882019-03-06 16:11:56 -07001179 auto renderPass = GetRenderPassState(pRenderPassBegin->renderPass);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001180 if (!renderPass) return;
1181
Tobias Hectorbbb12282018-10-22 15:17:59 +01001182 const VkRenderPassCreateInfo2KHR *pRenderPassInfo = renderPass->createInfo.ptr();
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001183 if (framebuffer_state) {
1184 for (uint32_t i = 0; i < pRenderPassInfo->attachmentCount; ++i) {
Mark Lobodzinskia3a230b2019-03-06 15:35:13 -07001185 auto view_state = GetAttachmentImageViewState(framebuffer_state, i);
John Zulauf8e308292018-09-21 11:34:37 -06001186 if (view_state) {
1187 SetImageViewLayout(device_data, pCB, view_state, pRenderPassInfo->pAttachments[i].finalLayout);
1188 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001189 }
1190 }
1191}
Dave Houltone19e20d2018-02-02 16:32:41 -07001192
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001193#ifdef VK_USE_PLATFORM_ANDROID_KHR
1194// Android-specific validation that uses types defined only with VK_USE_PLATFORM_ANDROID_KHR
1195// This could also move into a seperate core_validation_android.cpp file... ?
1196
1197//
1198// AHB-specific validation within non-AHB APIs
1199//
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001200bool CoreChecks::ValidateCreateImageANDROID(layer_data *device_data, const debug_report_data *report_data,
1201 const VkImageCreateInfo *create_info) {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001202 bool skip = false;
1203
1204 const VkExternalFormatANDROID *ext_fmt_android = lvl_find_in_chain<VkExternalFormatANDROID>(create_info->pNext);
1205 if (ext_fmt_android) {
Dave Houltond9611312018-11-19 17:03:36 -07001206 if (0 != ext_fmt_android->externalFormat) {
1207 if (VK_FORMAT_UNDEFINED != create_info->format) {
1208 skip |=
1209 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1210 "VUID-VkImageCreateInfo-pNext-01974",
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001211 "vkCreateImage(): VkImageCreateInfo struct has a chained VkExternalFormatANDROID struct with non-zero "
Dave Houltond9611312018-11-19 17:03:36 -07001212 "externalFormat, but the VkImageCreateInfo's format is not VK_FORMAT_UNDEFINED.");
1213 }
1214
1215 if (0 != (VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT & create_info->flags)) {
1216 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1217 "VUID-VkImageCreateInfo-pNext-02396",
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001218 "vkCreateImage(): VkImageCreateInfo struct has a chained VkExternalFormatANDROID struct with "
Dave Houltond9611312018-11-19 17:03:36 -07001219 "non-zero externalFormat, but flags include VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT.");
1220 }
1221
1222 if (0 != (~VK_IMAGE_USAGE_SAMPLED_BIT & create_info->usage)) {
1223 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1224 "VUID-VkImageCreateInfo-pNext-02397",
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001225 "vkCreateImage(): VkImageCreateInfo struct has a chained VkExternalFormatANDROID struct with "
Dave Houltond9611312018-11-19 17:03:36 -07001226 "non-zero externalFormat, but usage includes bits other than VK_IMAGE_USAGE_SAMPLED_BIT.");
1227 }
1228
1229 if (VK_IMAGE_TILING_OPTIMAL != create_info->tiling) {
1230 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1231 "VUID-VkImageCreateInfo-pNext-02398",
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001232 "vkCreateImage(): VkImageCreateInfo struct has a chained VkExternalFormatANDROID struct with "
Dave Houltond9611312018-11-19 17:03:36 -07001233 "non-zero externalFormat, but layout is not VK_IMAGE_TILING_OPTIMAL.");
1234 }
1235 }
1236
Mark Lobodzinskieb8654d2019-03-07 11:14:47 -07001237 auto ahb_formats = GetAHBExternalFormatsSet();
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001238 if ((0 != ext_fmt_android->externalFormat) && (0 == ahb_formats->count(ext_fmt_android->externalFormat))) {
1239 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1240 "VUID-VkExternalFormatANDROID-externalFormat-01894",
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001241 "vkCreateImage(): Chained VkExternalFormatANDROID struct contains a non-zero externalFormat which has "
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001242 "not been previously retrieved by vkGetAndroidHardwareBufferPropertiesANDROID().");
1243 }
1244 }
1245
Dave Houltond9611312018-11-19 17:03:36 -07001246 if ((nullptr == ext_fmt_android) || (0 == ext_fmt_android->externalFormat)) {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001247 if (VK_FORMAT_UNDEFINED == create_info->format) {
1248 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1249 "VUID-VkImageCreateInfo-pNext-01975",
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001250 "vkCreateImage(): VkImageCreateInfo struct's format is VK_FORMAT_UNDEFINED, but either does not have a "
Dave Houltond9611312018-11-19 17:03:36 -07001251 "chained VkExternalFormatANDROID struct or the struct exists but has an externalFormat of 0.");
1252 }
1253 }
1254
1255 const VkExternalMemoryImageCreateInfo *emici = lvl_find_in_chain<VkExternalMemoryImageCreateInfo>(create_info->pNext);
1256 if (emici && (emici->handleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)) {
1257 if (create_info->imageType != VK_IMAGE_TYPE_2D) {
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001258 skip |=
1259 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1260 "VUID-VkImageCreateInfo-pNext-02393",
1261 "vkCreateImage(): VkImageCreateInfo struct with imageType %s has chained VkExternalMemoryImageCreateInfo "
1262 "struct with handleType VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID.",
1263 string_VkImageType(create_info->imageType));
Dave Houltond9611312018-11-19 17:03:36 -07001264 }
1265
1266 if ((create_info->mipLevels != 1) && (create_info->mipLevels != FullMipChainLevels(create_info->extent))) {
1267 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1268 "VUID-VkImageCreateInfo-pNext-02394",
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001269 "vkCreateImage(): VkImageCreateInfo struct with chained VkExternalMemoryImageCreateInfo struct of "
Dave Houltond9611312018-11-19 17:03:36 -07001270 "handleType VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID "
1271 "specifies mipLevels = %" PRId32 " (full chain mipLevels are %" PRId32 ").",
1272 create_info->mipLevels, FullMipChainLevels(create_info->extent));
1273 }
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001274 }
1275
1276 return skip;
1277}
1278
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001279void CoreChecks::RecordCreateImageANDROID(const VkImageCreateInfo *create_info, IMAGE_STATE *is_node) {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001280 const VkExternalMemoryImageCreateInfo *emici = lvl_find_in_chain<VkExternalMemoryImageCreateInfo>(create_info->pNext);
1281 if (emici && (emici->handleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)) {
1282 is_node->imported_ahb = true;
1283 }
Dave Houltond3e046d2018-11-28 13:08:09 -07001284 const VkExternalFormatANDROID *ext_fmt_android = lvl_find_in_chain<VkExternalFormatANDROID>(create_info->pNext);
egdaniel1f4d2a42019-02-04 10:25:38 -05001285 if (ext_fmt_android && (0 != ext_fmt_android->externalFormat)) {
Dave Houltond3e046d2018-11-28 13:08:09 -07001286 is_node->has_ahb_format = true;
1287 is_node->ahb_format = ext_fmt_android->externalFormat;
1288 }
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001289}
1290
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001291bool CoreChecks::ValidateCreateImageViewANDROID(layer_data *device_data, const VkImageViewCreateInfo *create_info) {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001292 bool skip = false;
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07001293 IMAGE_STATE *image_state = GetImageState(create_info->image);
Dave Houltond3e046d2018-11-28 13:08:09 -07001294
1295 if (image_state->has_ahb_format) {
Dave Houltond9611312018-11-19 17:03:36 -07001296 if (VK_FORMAT_UNDEFINED != create_info->format) {
1297 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
1298 HandleToUint64(create_info->image), "VUID-VkImageViewCreateInfo-image-02399",
1299 "vkCreateImageView(): VkImageViewCreateInfo struct has a chained VkExternalFormatANDROID struct, but "
1300 "format member is %s.",
1301 string_VkFormat(create_info->format));
1302 }
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001303
Dave Houltond9611312018-11-19 17:03:36 -07001304 // Chain must include a compatible ycbcr conversion
1305 bool conv_found = false;
1306 uint64_t external_format = 0;
1307 const VkSamplerYcbcrConversionInfo *ycbcr_conv_info = lvl_find_in_chain<VkSamplerYcbcrConversionInfo>(create_info->pNext);
1308 if (ycbcr_conv_info != nullptr) {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001309 VkSamplerYcbcrConversion conv_handle = ycbcr_conv_info->conversion;
Mark Lobodzinskieb8654d2019-03-07 11:14:47 -07001310 auto fmap = GetYcbcrConversionFormatMap();
Dave Houltond9611312018-11-19 17:03:36 -07001311 if (fmap->find(conv_handle) != fmap->end()) {
1312 conv_found = true;
1313 external_format = fmap->at(conv_handle);
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001314 }
Dave Houltond9611312018-11-19 17:03:36 -07001315 }
Dave Houltond3e046d2018-11-28 13:08:09 -07001316 if ((!conv_found) || (external_format != image_state->ahb_format)) {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001317 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond9611312018-11-19 17:03:36 -07001318 HandleToUint64(create_info->image), "VUID-VkImageViewCreateInfo-image-02400",
1319 "vkCreateImageView(): VkImageViewCreateInfo struct has a chained VkExternalFormatANDROID struct, but "
1320 "without a chained VkSamplerYcbcrConversionInfo struct with the same external format.");
1321 }
1322
1323 // Errors in create_info swizzles
1324 if ((create_info->components.r != VK_COMPONENT_SWIZZLE_IDENTITY) ||
1325 (create_info->components.g != VK_COMPONENT_SWIZZLE_IDENTITY) ||
1326 (create_info->components.b != VK_COMPONENT_SWIZZLE_IDENTITY) ||
1327 (create_info->components.a != VK_COMPONENT_SWIZZLE_IDENTITY)) {
1328 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
1329 HandleToUint64(create_info->image), "VUID-VkImageViewCreateInfo-image-02401",
1330 "vkCreateImageView(): VkImageViewCreateInfo struct has a chained VkExternalFormatANDROID struct, but "
1331 "includes one or more non-identity component swizzles.");
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001332 }
1333 }
Dave Houltond9611312018-11-19 17:03:36 -07001334
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001335 return skip;
1336}
1337
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001338bool CoreChecks::ValidateGetImageSubresourceLayoutANDROID(layer_data *device_data, const VkImage image) {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001339 bool skip = false;
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001340
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07001341 IMAGE_STATE *image_state = GetImageState(image);
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001342 if (image_state->imported_ahb && (0 == image_state->GetBoundMemory().size())) {
1343 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image),
1344 "VUID-vkGetImageSubresourceLayout-image-01895",
Graeme Leese79b60cb2018-11-28 11:51:20 +00001345 "vkGetImageSubresourceLayout(): Attempt to query layout from an image created with "
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001346 "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID handleType which has not yet been "
1347 "bound to memory.");
1348 }
1349 return skip;
1350}
1351
1352#else
1353
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001354bool CoreChecks::ValidateCreateImageANDROID(layer_data *device_data, const debug_report_data *report_data,
1355 const VkImageCreateInfo *create_info) {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001356 return false;
1357}
1358
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001359void CoreChecks::RecordCreateImageANDROID(const VkImageCreateInfo *create_info, IMAGE_STATE *is_node) {}
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001360
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001361bool CoreChecks::ValidateCreateImageViewANDROID(layer_data *device_data, const VkImageViewCreateInfo *create_info) { return false; }
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001362
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001363bool CoreChecks::ValidateGetImageSubresourceLayoutANDROID(layer_data *device_data, const VkImage image) { return false; }
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001364
1365#endif // VK_USE_PLATFORM_ANDROID_KHR
1366
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001367bool CoreChecks::PreCallValidateCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
1368 const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
1369 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -06001370 bool skip = false;
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001371
Mark Lobodzinski60e79032019-03-07 10:22:31 -07001372 if (GetDeviceExtensions()->vk_android_external_memory_android_hardware_buffer) {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001373 skip |= ValidateCreateImageANDROID(device_data, report_data, pCreateInfo);
1374 } else { // These checks are omitted or replaced when Android HW Buffer extension is active
1375 if (pCreateInfo->format == VK_FORMAT_UNDEFINED) {
1376 return log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1377 "VUID-VkImageCreateInfo-format-00943",
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001378 "vkCreateImage(): VkFormat for image must not be VK_FORMAT_UNDEFINED.");
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001379 }
Jeremy Hayes96dcd812017-03-14 14:04:19 -06001380 }
1381
Dave Houlton130c0212018-01-29 13:39:56 -07001382 if ((pCreateInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) && (VK_IMAGE_TYPE_2D != pCreateInfo->imageType)) {
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001383 skip |= log_msg(
1384 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1385 "VUID-VkImageCreateInfo-flags-00949",
1386 "vkCreateImage(): Image type must be VK_IMAGE_TYPE_2D when VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT flag bit is set");
Dave Houlton130c0212018-01-29 13:39:56 -07001387 }
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001388
Mark Lobodzinski5c048802019-03-07 10:47:31 -07001389 const VkPhysicalDeviceLimits *device_limits = &(GetPDProperties()->limits);
Dave Houlton130c0212018-01-29 13:39:56 -07001390 VkImageUsageFlags attach_flags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
1391 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
1392 if ((pCreateInfo->usage & attach_flags) && (pCreateInfo->extent.width > device_limits->maxFramebufferWidth)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06001393 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001394 "VUID-VkImageCreateInfo-usage-00964",
1395 "vkCreateImage(): Image usage flags include a frame buffer attachment bit and image width exceeds device "
1396 "maxFramebufferWidth.");
Dave Houlton130c0212018-01-29 13:39:56 -07001397 }
1398
1399 if ((pCreateInfo->usage & attach_flags) && (pCreateInfo->extent.height > device_limits->maxFramebufferHeight)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06001400 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001401 "VUID-VkImageCreateInfo-usage-00965",
1402 "vkCreateImage(): Image usage flags include a frame buffer attachment bit and image height exceeds device "
1403 "maxFramebufferHeight");
Dave Houlton130c0212018-01-29 13:39:56 -07001404 }
1405
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001406 VkImageFormatProperties format_limits = {};
Mark Lobodzinski5c048802019-03-07 10:47:31 -07001407 VkResult res = GetPDImageFormatProperties(pCreateInfo, &format_limits);
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001408 if (res == VK_ERROR_FORMAT_NOT_SUPPORTED) {
1409 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUIDUndefined,
1410 "vkCreateImage(): Format %s is not supported for this combination of parameters.",
1411 string_VkFormat(pCreateInfo->format));
1412 } else {
1413 if (pCreateInfo->mipLevels > format_limits.maxMipLevels) {
1414 const char *format_string = string_VkFormat(pCreateInfo->format);
1415 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1416 "VUID-VkImageCreateInfo-mipLevels-02255",
1417 "vkCreateImage(): Image mip levels=%d exceed image format maxMipLevels=%d for format %s.",
1418 pCreateInfo->mipLevels, format_limits.maxMipLevels, format_string);
1419 }
Dave Houlton130c0212018-01-29 13:39:56 -07001420
Dave Houltona585d132019-01-18 13:05:42 -07001421 uint64_t texel_count = (uint64_t)pCreateInfo->extent.width * (uint64_t)pCreateInfo->extent.height *
1422 (uint64_t)pCreateInfo->extent.depth * (uint64_t)pCreateInfo->arrayLayers *
1423 (uint64_t)pCreateInfo->samples;
1424 uint64_t total_size = (uint64_t)std::ceil(FormatTexelSize(pCreateInfo->format) * texel_count);
Dave Houlton130c0212018-01-29 13:39:56 -07001425
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001426 // Round up to imageGranularity boundary
Mark Lobodzinski5c048802019-03-07 10:47:31 -07001427 VkDeviceSize imageGranularity = GetPDProperties()->limits.bufferImageGranularity;
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001428 uint64_t ig_mask = imageGranularity - 1;
1429 total_size = (total_size + ig_mask) & ~ig_mask;
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001430
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001431 if (total_size > format_limits.maxResourceSize) {
1432 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
1433 kVUID_Core_Image_InvalidFormatLimitsViolation,
1434 "vkCreateImage(): resource size exceeds allowable maximum Image resource size = 0x%" PRIxLEAST64
1435 ", maximum resource size = 0x%" PRIxLEAST64 " ",
1436 total_size, format_limits.maxResourceSize);
1437 }
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001438
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001439 if (pCreateInfo->arrayLayers > format_limits.maxArrayLayers) {
1440 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
1441 "VUID-VkImageCreateInfo-arrayLayers-02256",
1442 "vkCreateImage(): arrayLayers=%d exceeds allowable maximum supported by format of %d.",
1443 pCreateInfo->arrayLayers, format_limits.maxArrayLayers);
1444 }
1445
1446 if ((pCreateInfo->samples & format_limits.sampleCounts) == 0) {
1447 skip |=
1448 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
1449 "VUID-VkImageCreateInfo-samples-02258", "vkCreateImage(): samples %s is not supported by format 0x%.8X.",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001450 string_VkSampleCountFlagBits(pCreateInfo->samples), format_limits.sampleCounts);
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001451 }
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001452 }
1453
Mark Lobodzinski60e79032019-03-07 10:22:31 -07001454 if ((pCreateInfo->flags & VK_IMAGE_CREATE_SPARSE_ALIASED_BIT) && (!GetEnabledFeatures()->core.sparseResidencyAliased)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06001455 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton12befb92018-06-26 17:16:46 -06001456 "VUID-VkImageCreateInfo-flags-01924",
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -06001457 "vkCreateImage(): the sparseResidencyAliased device feature is disabled: Images cannot be created with the "
1458 "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT set.");
Mark Lobodzinski035a4cf2017-03-13 09:45:07 -06001459 }
1460
Mark Lobodzinski60e79032019-03-07 10:22:31 -07001461 if (GetDeviceExtensions()->vk_khr_maintenance2) {
Lenny Komowb79f04a2017-09-18 17:07:00 -06001462 if (pCreateInfo->flags & VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR) {
1463 if (!(FormatIsCompressed_BC(pCreateInfo->format) || FormatIsCompressed_ASTC_LDR(pCreateInfo->format) ||
1464 FormatIsCompressed_ETC2_EAC(pCreateInfo->format))) {
1465 // TODO: Add Maintenance2 VUID
Dave Houlton8e9f6542018-05-18 12:18:22 -06001466 skip |=
1467 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUIDUndefined,
1468 "vkCreateImage(): If pCreateInfo->flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR, "
1469 "format must be block, ETC or ASTC compressed, but is %s",
1470 string_VkFormat(pCreateInfo->format));
Lenny Komowb79f04a2017-09-18 17:07:00 -06001471 }
1472 if (!(pCreateInfo->flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT)) {
1473 // TODO: Add Maintenance2 VUID
Dave Houlton8e9f6542018-05-18 12:18:22 -06001474 skip |=
1475 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUIDUndefined,
1476 "vkCreateImage(): If pCreateInfo->flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR, "
1477 "flags must also contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT.");
Lenny Komowb79f04a2017-09-18 17:07:00 -06001478 }
1479 }
1480 }
1481
Mark Lobodzinski08ee03c2019-02-04 10:57:47 -07001482 if (pCreateInfo->sharingMode == VK_SHARING_MODE_CONCURRENT && pCreateInfo->pQueueFamilyIndices) {
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001483 skip |=
1484 ValidateQueueFamilies(device_data, pCreateInfo->queueFamilyIndexCount, pCreateInfo->pQueueFamilyIndices,
1485 "vkCreateImage", "pCreateInfo->pQueueFamilyIndices", "VUID-VkImageCreateInfo-sharingMode-01420",
1486 "VUID-VkImageCreateInfo-sharingMode-01420", false);
Mark Lobodzinski08ee03c2019-02-04 10:57:47 -07001487 }
1488
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -06001489 return skip;
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001490}
1491
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001492void CoreChecks::PostCallRecordCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
1493 const VkAllocationCallbacks *pAllocator, VkImage *pImage, VkResult result) {
Mark Lobodzinski701507e2019-01-18 14:31:53 -07001494 if (VK_SUCCESS != result) return;
Mark Lobodzinski42fe5f72017-01-11 11:36:16 -07001495 IMAGE_LAYOUT_NODE image_state;
1496 image_state.layout = pCreateInfo->initialLayout;
1497 image_state.format = pCreateInfo->format;
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001498 IMAGE_STATE *is_node = new IMAGE_STATE(*pImage, pCreateInfo);
Mark Lobodzinski60e79032019-03-07 10:22:31 -07001499 if (GetDeviceExtensions()->vk_android_external_memory_android_hardware_buffer) {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001500 RecordCreateImageANDROID(pCreateInfo, is_node);
1501 }
Mark Lobodzinski44d46d52019-03-07 11:04:06 -07001502 GetImageMap()->insert(std::make_pair(*pImage, std::unique_ptr<IMAGE_STATE>(is_node)));
Mark Lobodzinski42fe5f72017-01-11 11:36:16 -07001503 ImageSubresourcePair subpair{*pImage, false, VkImageSubresource()};
Mark Lobodzinski44d46d52019-03-07 11:04:06 -07001504 (*GetImageSubresourceMap())[*pImage].push_back(subpair);
1505 (*GetImageLayoutMap())[subpair] = image_state;
Mark Lobodzinski42fe5f72017-01-11 11:36:16 -07001506}
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001507
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001508bool CoreChecks::PreCallValidateDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
Mark Lobodzinski6b35c8a2019-01-10 10:57:27 -07001509 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07001510 IMAGE_STATE *image_state = GetImageState(image);
Mark Lobodzinski6b35c8a2019-01-10 10:57:27 -07001511 const VK_OBJECT obj_struct = {HandleToUint64(image), kVulkanObjectTypeImage};
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001512 bool skip = false;
Mark Lobodzinski6b35c8a2019-01-10 10:57:27 -07001513 if (image_state) {
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001514 skip |= ValidateObjectNotInUse(device_data, image_state, obj_struct, "vkDestroyImage", "VUID-vkDestroyImage-image-01000");
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001515 }
1516 return skip;
1517}
1518
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001519void CoreChecks::PreCallRecordDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
Mark Lobodzinski6b35c8a2019-01-10 10:57:27 -07001520 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
Mark Lobodzinskidfa64112019-03-04 12:17:24 -07001521 if (!image) return;
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07001522 IMAGE_STATE *image_state = GetImageState(image);
Mark Lobodzinski6b35c8a2019-01-10 10:57:27 -07001523 VK_OBJECT obj_struct = {HandleToUint64(image), kVulkanObjectTypeImage};
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001524 InvalidateCommandBuffers(device_data, image_state->cb_bindings, obj_struct);
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001525 // Clean up memory mapping, bindings and range references for image
1526 for (auto mem_binding : image_state->GetBoundMemory()) {
Mark Lobodzinski97f83f72019-03-07 10:01:52 -07001527 auto mem_info = GetMemObjInfo(mem_binding);
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001528 if (mem_info) {
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001529 RemoveImageMemoryRange(obj_struct.handle, mem_info);
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001530 }
1531 }
Mark Lobodzinski97f83f72019-03-07 10:01:52 -07001532 ClearMemoryObjectBindings(obj_struct.handle, kVulkanObjectTypeImage);
John Zulauf6b4aae82018-05-09 13:03:36 -06001533 EraseQFOReleaseBarriers<VkImageMemoryBarrier>(device_data, image);
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001534 // Remove image from imageMap
Mark Lobodzinski44d46d52019-03-07 11:04:06 -07001535 GetImageMap()->erase(image);
1536 std::unordered_map<VkImage, std::vector<ImageSubresourcePair>> *imageSubresourceMap = GetImageSubresourceMap();
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001537
1538 const auto &sub_entry = imageSubresourceMap->find(image);
1539 if (sub_entry != imageSubresourceMap->end()) {
1540 for (const auto &pair : sub_entry->second) {
Mark Lobodzinski44d46d52019-03-07 11:04:06 -07001541 GetImageLayoutMap()->erase(pair);
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001542 }
1543 imageSubresourceMap->erase(sub_entry);
1544 }
1545}
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001546
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001547bool CoreChecks::ValidateImageAttributes(layer_data *device_data, IMAGE_STATE *image_state, VkImageSubresourceRange range) {
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001548 bool skip = false;
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001549
1550 if (range.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) {
1551 char const str[] = "vkCmdClearColorImage aspectMasks for all subresource ranges must be set to VK_IMAGE_ASPECT_COLOR_BIT";
1552 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houlton51653902018-06-22 17:32:13 -06001553 HandleToUint64(image_state->image), kVUID_Core_DrawState_InvalidImageAspect, str);
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001554 }
1555
Dave Houlton1d2022c2017-03-29 11:43:58 -06001556 if (FormatIsDepthOrStencil(image_state->createInfo.format)) {
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001557 char const str[] = "vkCmdClearColorImage called with depth/stencil image.";
1558 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06001559 HandleToUint64(image_state->image), "VUID-vkCmdClearColorImage-image-00007", "%s.", str);
Dave Houlton1d2022c2017-03-29 11:43:58 -06001560 } else if (FormatIsCompressed(image_state->createInfo.format)) {
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001561 char const str[] = "vkCmdClearColorImage called with compressed image.";
1562 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06001563 HandleToUint64(image_state->image), "VUID-vkCmdClearColorImage-image-00007", "%s.", str);
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001564 }
1565
1566 if (!(image_state->createInfo.usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) {
1567 char const str[] = "vkCmdClearColorImage called with image created without VK_IMAGE_USAGE_TRANSFER_DST_BIT.";
1568 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06001569 HandleToUint64(image_state->image), "VUID-vkCmdClearColorImage-image-00002", "%s.", str);
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001570 }
1571 return skip;
1572}
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001573
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001574uint32_t ResolveRemainingLevels(const VkImageSubresourceRange *range, uint32_t mip_levels) {
1575 // Return correct number of mip levels taking into account VK_REMAINING_MIP_LEVELS
1576 uint32_t mip_level_count = range->levelCount;
Mark Lobodzinski9c93dbd2017-02-02 08:31:18 -07001577 if (range->levelCount == VK_REMAINING_MIP_LEVELS) {
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001578 mip_level_count = mip_levels - range->baseMipLevel;
Mark Lobodzinski9c93dbd2017-02-02 08:31:18 -07001579 }
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001580 return mip_level_count;
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001581}
1582
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001583uint32_t ResolveRemainingLayers(const VkImageSubresourceRange *range, uint32_t layers) {
1584 // Return correct number of layers taking into account VK_REMAINING_ARRAY_LAYERS
1585 uint32_t array_layer_count = range->layerCount;
1586 if (range->layerCount == VK_REMAINING_ARRAY_LAYERS) {
1587 array_layer_count = layers - range->baseArrayLayer;
Mark Lobodzinski9c93dbd2017-02-02 08:31:18 -07001588 }
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001589 return array_layer_count;
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001590}
1591
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001592bool CoreChecks::VerifyClearImageLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *image_state,
1593 VkImageSubresourceRange range, VkImageLayout dest_image_layout, const char *func_name) {
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001594 bool skip = false;
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001595
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001596 uint32_t level_count = ResolveRemainingLevels(&range, image_state->createInfo.mipLevels);
1597 uint32_t layer_count = ResolveRemainingLayers(&range, image_state->createInfo.arrayLayers);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001598
1599 if (dest_image_layout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
1600 if (dest_image_layout == VK_IMAGE_LAYOUT_GENERAL) {
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001601 if (image_state->createInfo.tiling != VK_IMAGE_TILING_LINEAR) {
1602 // LAYOUT_GENERAL is allowed, but may not be performance optimal, flag as perf warning.
Mark Lobodzinski0827aec2017-03-21 16:41:45 -06001603 skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houlton51653902018-06-22 17:32:13 -06001604 HandleToUint64(image_state->image), kVUID_Core_DrawState_InvalidImageLayout,
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001605 "%s: Layout for cleared image should be TRANSFER_DST_OPTIMAL instead of GENERAL.", func_name);
1606 }
Mark Lobodzinski087380c2017-05-16 14:42:25 -06001607 } else if (VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR == dest_image_layout) {
Mark Lobodzinski60e79032019-03-07 10:22:31 -07001608 if (!GetDeviceExtensions()->vk_khr_shared_presentable_image) {
Tobin Ehlisfb0661c2017-05-11 08:52:51 -06001609 // TODO: Add unique error id when available.
Mark Lobodzinski087380c2017-05-16 14:42:25 -06001610 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06001611 HandleToUint64(image_state->image), 0,
Dave Houlton33c2d252017-06-09 17:08:32 -06001612 "Must enable VK_KHR_shared_presentable_image extension before creating images with a layout type "
1613 "of VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR.");
Mark Lobodzinski087380c2017-05-16 14:42:25 -06001614
1615 } else {
1616 if (image_state->shared_presentable) {
1617 skip |= log_msg(
1618 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06001619 HandleToUint64(image_state->image), 0,
Mark Lobodzinski087380c2017-05-16 14:42:25 -06001620 "Layout for shared presentable cleared image is %s but can only be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR.",
1621 string_VkImageLayout(dest_image_layout));
1622 }
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -06001623 }
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001624 } else {
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06001625 const char *error_code = "VUID-vkCmdClearColorImage-imageLayout-00005";
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001626 if (strcmp(func_name, "vkCmdClearDepthStencilImage()") == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001627 error_code = "VUID-vkCmdClearDepthStencilImage-imageLayout-00012";
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001628 } else {
1629 assert(strcmp(func_name, "vkCmdClearColorImage()") == 0);
1630 }
Mark Lobodzinski0827aec2017-03-21 16:41:45 -06001631 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06001632 HandleToUint64(image_state->image), error_code,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001633 "%s: Layout for cleared image is %s but can only be TRANSFER_DST_OPTIMAL or GENERAL.", func_name,
1634 string_VkImageLayout(dest_image_layout));
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001635 }
1636 }
1637
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001638 for (uint32_t level_index = 0; level_index < level_count; ++level_index) {
1639 uint32_t level = level_index + range.baseMipLevel;
1640 for (uint32_t layer_index = 0; layer_index < layer_count; ++layer_index) {
1641 uint32_t layer = layer_index + range.baseArrayLayer;
1642 VkImageSubresource sub = {range.aspectMask, level, layer};
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001643 IMAGE_CMD_BUF_LAYOUT_NODE node;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001644 if (FindCmdBufLayout(device_data, cb_node, image_state->image, sub, node)) {
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001645 if (node.layout != dest_image_layout) {
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06001646 const char *error_code = "VUID-vkCmdClearColorImage-imageLayout-00004";
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001647 if (strcmp(func_name, "vkCmdClearDepthStencilImage()") == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001648 error_code = "VUID-vkCmdClearDepthStencilImage-imageLayout-00011";
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001649 } else {
1650 assert(strcmp(func_name, "vkCmdClearColorImage()") == 0);
1651 }
Mark Lobodzinski88529492018-04-01 10:38:15 -06001652 skip |=
1653 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
1654 error_code, "%s: Cannot clear an image whose layout is %s and doesn't match the current layout %s.",
1655 func_name, string_VkImageLayout(dest_image_layout), string_VkImageLayout(node.layout));
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001656 }
1657 }
1658 }
1659 }
1660
1661 return skip;
1662}
1663
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001664void CoreChecks::RecordClearImageLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, VkImage image,
1665 VkImageSubresourceRange range, VkImageLayout dest_image_layout) {
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07001666 VkImageCreateInfo *image_create_info = &(GetImageState(image)->createInfo);
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001667 uint32_t level_count = ResolveRemainingLevels(&range, image_create_info->mipLevels);
1668 uint32_t layer_count = ResolveRemainingLayers(&range, image_create_info->arrayLayers);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001669
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001670 for (uint32_t level_index = 0; level_index < level_count; ++level_index) {
1671 uint32_t level = level_index + range.baseMipLevel;
1672 for (uint32_t layer_index = 0; layer_index < layer_count; ++layer_index) {
1673 uint32_t layer = layer_index + range.baseArrayLayer;
1674 VkImageSubresource sub = {range.aspectMask, level, layer};
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001675 IMAGE_CMD_BUF_LAYOUT_NODE node;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001676 if (!FindCmdBufLayout(device_data, cb_node, image, sub, node)) {
1677 SetLayout(device_data, cb_node, image, sub, IMAGE_CMD_BUF_LAYOUT_NODE(dest_image_layout, dest_image_layout));
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001678 }
1679 }
1680 }
1681}
1682
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001683bool CoreChecks::PreCallValidateCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
1684 const VkClearColorValue *pColor, uint32_t rangeCount,
1685 const VkImageSubresourceRange *pRanges) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07001686 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
1687
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001688 bool skip = false;
1689 // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07001690 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07001691 auto image_state = GetImageState(image);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001692 if (cb_node && image_state) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07001693 skip |= ValidateMemoryIsBoundToImage(device_data, image_state, "vkCmdClearColorImage()",
1694 "VUID-vkCmdClearColorImage-image-00003");
1695 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdClearColorImage()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT,
Dave Houltond8ed0212018-05-16 17:18:24 -06001696 "VUID-vkCmdClearColorImage-commandBuffer-cmdpool");
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07001697 skip |= ValidateCmd(device_data, cb_node, CMD_CLEARCOLORIMAGE, "vkCmdClearColorImage()");
Mark Lobodzinski96d5c6e2019-03-07 11:28:21 -07001698 if (GetApiVersion() >= VK_API_VERSION_1_1 || GetDeviceExtensions()->vk_khr_maintenance1) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07001699 skip |= ValidateImageFormatFeatureFlags(device_data, image_state, VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
1700 "vkCmdClearColorImage", "VUID-vkCmdClearColorImage-image-01993",
1701 "VUID-vkCmdClearColorImage-image-01993");
Cort Stratton186b1a22018-05-01 20:18:06 -04001702 }
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07001703 skip |= InsideRenderPass(device_data, cb_node, "vkCmdClearColorImage()", "VUID-vkCmdClearColorImage-renderpass");
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001704 for (uint32_t i = 0; i < rangeCount; ++i) {
Petr Kraus4d718682017-05-18 03:38:41 +02001705 std::string param_name = "pRanges[" + std::to_string(i) + "]";
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07001706 skip |= ValidateCmdClearColorSubresourceRange(device_data, image_state, pRanges[i], param_name.c_str());
1707 skip |= ValidateImageAttributes(device_data, image_state, pRanges[i]);
1708 skip |= VerifyClearImageLayout(device_data, cb_node, image_state, pRanges[i], imageLayout, "vkCmdClearColorImage()");
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001709 }
1710 }
1711 return skip;
1712}
1713
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001714void CoreChecks::PreCallRecordCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
1715 const VkClearColorValue *pColor, uint32_t rangeCount,
1716 const VkImageSubresourceRange *pRanges) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07001717 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
1718
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07001719 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07001720 auto image_state = GetImageState(image);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001721 if (cb_node && image_state) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07001722 AddCommandBufferBindingImage(device_data, cb_node, image_state);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001723 for (uint32_t i = 0; i < rangeCount; ++i) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07001724 RecordClearImageLayout(device_data, cb_node, image, pRanges[i], imageLayout);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001725 }
1726 }
1727}
1728
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001729bool CoreChecks::PreCallValidateCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
1730 const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
1731 const VkImageSubresourceRange *pRanges) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07001732 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001733 bool skip = false;
Mark Lobodzinski1241a312017-02-01 10:57:21 -07001734
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001735 // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07001736 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07001737 auto image_state = GetImageState(image);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001738 if (cb_node && image_state) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001739 skip |= ValidateMemoryIsBoundToImage(device_data, image_state, "vkCmdClearDepthStencilImage()",
1740 "VUID-vkCmdClearDepthStencilImage-image-00010");
Mike Schuchardt9c582402017-02-23 15:57:37 -07001741 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdClearDepthStencilImage()", VK_QUEUE_GRAPHICS_BIT,
Dave Houltond8ed0212018-05-16 17:18:24 -06001742 "VUID-vkCmdClearDepthStencilImage-commandBuffer-cmdpool");
Mark Lobodzinski1241a312017-02-01 10:57:21 -07001743 skip |= ValidateCmd(device_data, cb_node, CMD_CLEARDEPTHSTENCILIMAGE, "vkCmdClearDepthStencilImage()");
Mark Lobodzinski96d5c6e2019-03-07 11:28:21 -07001744 if (GetApiVersion() >= VK_API_VERSION_1_1 || GetDeviceExtensions()->vk_khr_maintenance1) {
Cort Stratton186b1a22018-05-01 20:18:06 -04001745 skip |= ValidateImageFormatFeatureFlags(device_data, image_state, VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
Shannon McPherson40c0cba2018-08-07 13:39:13 -06001746 "vkCmdClearDepthStencilImage", "VUID-vkCmdClearDepthStencilImage-image-01994",
1747 "VUID-vkCmdClearDepthStencilImage-image-01994");
Cort Stratton186b1a22018-05-01 20:18:06 -04001748 }
Dave Houltond8ed0212018-05-16 17:18:24 -06001749 skip |=
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06001750 InsideRenderPass(device_data, cb_node, "vkCmdClearDepthStencilImage()", "VUID-vkCmdClearDepthStencilImage-renderpass");
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001751 for (uint32_t i = 0; i < rangeCount; ++i) {
Petr Kraus4d718682017-05-18 03:38:41 +02001752 std::string param_name = "pRanges[" + std::to_string(i) + "]";
Petr Krausffa94af2017-08-08 21:46:02 +02001753 skip |= ValidateCmdClearDepthSubresourceRange(device_data, image_state, pRanges[i], param_name.c_str());
Mark Lobodzinski9c93dbd2017-02-02 08:31:18 -07001754 skip |=
1755 VerifyClearImageLayout(device_data, cb_node, image_state, pRanges[i], imageLayout, "vkCmdClearDepthStencilImage()");
Mark Lobodzinski1241a312017-02-01 10:57:21 -07001756 // Image aspect must be depth or stencil or both
Dave Houlton12befb92018-06-26 17:16:46 -06001757 VkImageAspectFlags valid_aspects = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
1758 if (((pRanges[i].aspectMask & valid_aspects) == 0) || ((pRanges[i].aspectMask & ~valid_aspects) != 0)) {
Mark Lobodzinski1241a312017-02-01 10:57:21 -07001759 char const str[] =
Dave Houltona9df0ce2018-02-07 10:51:23 -07001760 "vkCmdClearDepthStencilImage aspectMasks for all subresource ranges must be set to VK_IMAGE_ASPECT_DEPTH_BIT "
1761 "and/or VK_IMAGE_ASPECT_STENCIL_BIT";
Mark Lobodzinski1241a312017-02-01 10:57:21 -07001762 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton51653902018-06-22 17:32:13 -06001763 HandleToUint64(commandBuffer), kVUID_Core_DrawState_InvalidImageAspect, str);
Mark Lobodzinski1241a312017-02-01 10:57:21 -07001764 }
1765 }
Dave Houlton1d2022c2017-03-29 11:43:58 -06001766 if (image_state && !FormatIsDepthOrStencil(image_state->createInfo.format)) {
Mark Lobodzinski1241a312017-02-01 10:57:21 -07001767 char const str[] = "vkCmdClearDepthStencilImage called without a depth/stencil image.";
Tobin Ehlis3c37fb32017-05-24 09:31:13 -06001768 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06001769 HandleToUint64(image), "VUID-vkCmdClearDepthStencilImage-image-00014", "%s.", str);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001770 }
Tobin Ehlis4af8c242017-11-30 13:47:11 -07001771 if (VK_IMAGE_USAGE_TRANSFER_DST_BIT != (VK_IMAGE_USAGE_TRANSFER_DST_BIT & image_state->createInfo.usage)) {
1772 char const str[] =
1773 "vkCmdClearDepthStencilImage() called with an image that was not created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT "
1774 "set.";
1775 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06001776 HandleToUint64(image), "VUID-vkCmdClearDepthStencilImage-image-00009", "%s.", str);
Tobin Ehlis4af8c242017-11-30 13:47:11 -07001777 }
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001778 }
1779 return skip;
1780}
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001781
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001782void CoreChecks::PreCallRecordCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
1783 const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
1784 const VkImageSubresourceRange *pRanges) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07001785 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
1786
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07001787 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07001788 auto image_state = GetImageState(image);
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07001789 if (cb_node && image_state) {
1790 AddCommandBufferBindingImage(device_data, cb_node, image_state);
1791 for (uint32_t i = 0; i < rangeCount; ++i) {
1792 RecordClearImageLayout(device_data, cb_node, image, pRanges[i], imageLayout);
1793 }
1794 }
1795}
1796
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001797// Returns true if [x, xoffset] and [y, yoffset] overlap
1798static bool RangesIntersect(int32_t start, uint32_t start_offset, int32_t end, uint32_t end_offset) {
1799 bool result = false;
1800 uint32_t intersection_min = std::max(static_cast<uint32_t>(start), static_cast<uint32_t>(end));
1801 uint32_t intersection_max = std::min(static_cast<uint32_t>(start) + start_offset, static_cast<uint32_t>(end) + end_offset);
1802
1803 if (intersection_max > intersection_min) {
1804 result = true;
1805 }
1806 return result;
1807}
1808
Dave Houltonc991cc92018-03-06 11:08:51 -07001809// Returns true if source area of first copy region intersects dest area of second region
1810// It is assumed that these are copy regions within a single image (otherwise no possibility of collision)
1811static bool RegionIntersects(const VkImageCopy *rgn0, const VkImageCopy *rgn1, VkImageType type, bool is_multiplane) {
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001812 bool result = false;
Dave Houltonf5217612018-02-02 16:18:52 -07001813
Dave Houltonc991cc92018-03-06 11:08:51 -07001814 // Separate planes within a multiplane image cannot intersect
1815 if (is_multiplane && (rgn0->srcSubresource.aspectMask != rgn1->dstSubresource.aspectMask)) {
Dave Houltonf5217612018-02-02 16:18:52 -07001816 return result;
1817 }
1818
Dave Houltonc991cc92018-03-06 11:08:51 -07001819 if ((rgn0->srcSubresource.mipLevel == rgn1->dstSubresource.mipLevel) &&
1820 (RangesIntersect(rgn0->srcSubresource.baseArrayLayer, rgn0->srcSubresource.layerCount, rgn1->dstSubresource.baseArrayLayer,
1821 rgn1->dstSubresource.layerCount))) {
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001822 result = true;
1823 switch (type) {
1824 case VK_IMAGE_TYPE_3D:
Dave Houltonc991cc92018-03-06 11:08:51 -07001825 result &= RangesIntersect(rgn0->srcOffset.z, rgn0->extent.depth, rgn1->dstOffset.z, rgn1->extent.depth);
Tobin Ehlis648b1cf2018-04-13 15:24:13 -06001826 // fall through
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001827 case VK_IMAGE_TYPE_2D:
Dave Houltonc991cc92018-03-06 11:08:51 -07001828 result &= RangesIntersect(rgn0->srcOffset.y, rgn0->extent.height, rgn1->dstOffset.y, rgn1->extent.height);
Tobin Ehlis648b1cf2018-04-13 15:24:13 -06001829 // fall through
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001830 case VK_IMAGE_TYPE_1D:
Dave Houltonc991cc92018-03-06 11:08:51 -07001831 result &= RangesIntersect(rgn0->srcOffset.x, rgn0->extent.width, rgn1->dstOffset.x, rgn1->extent.width);
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001832 break;
1833 default:
1834 // Unrecognized or new IMAGE_TYPE enums will be caught in parameter_validation
1835 assert(false);
1836 }
1837 }
1838 return result;
1839}
1840
Dave Houltonfc1a4052017-04-27 14:32:45 -06001841// Returns non-zero if offset and extent exceed image extents
1842static const uint32_t x_bit = 1;
1843static const uint32_t y_bit = 2;
1844static const uint32_t z_bit = 4;
Dave Houlton1150cf52017-04-27 14:38:11 -06001845static uint32_t ExceedsBounds(const VkOffset3D *offset, const VkExtent3D *extent, const VkExtent3D *image_extent) {
Dave Houltonfc1a4052017-04-27 14:32:45 -06001846 uint32_t result = 0;
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001847 // Extents/depths cannot be negative but checks left in for clarity
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001848 if ((offset->z + extent->depth > image_extent->depth) || (offset->z < 0) ||
1849 ((offset->z + static_cast<int32_t>(extent->depth)) < 0)) {
Dave Houltonfc1a4052017-04-27 14:32:45 -06001850 result |= z_bit;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001851 }
1852 if ((offset->y + extent->height > image_extent->height) || (offset->y < 0) ||
1853 ((offset->y + static_cast<int32_t>(extent->height)) < 0)) {
Dave Houltonfc1a4052017-04-27 14:32:45 -06001854 result |= y_bit;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001855 }
1856 if ((offset->x + extent->width > image_extent->width) || (offset->x < 0) ||
1857 ((offset->x + static_cast<int32_t>(extent->width)) < 0)) {
Dave Houltonfc1a4052017-04-27 14:32:45 -06001858 result |= x_bit;
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001859 }
1860 return result;
1861}
1862
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001863// Test if two VkExtent3D structs are equivalent
1864static inline bool IsExtentEqual(const VkExtent3D *extent, const VkExtent3D *other_extent) {
1865 bool result = true;
1866 if ((extent->width != other_extent->width) || (extent->height != other_extent->height) ||
1867 (extent->depth != other_extent->depth)) {
1868 result = false;
1869 }
1870 return result;
1871}
1872
Dave Houltonee281a52017-12-08 13:51:02 -07001873// For image copies between compressed/uncompressed formats, the extent is provided in source image texels
1874// Destination image texel extents must be adjusted by block size for the dest validation checks
1875VkExtent3D GetAdjustedDestImageExtent(VkFormat src_format, VkFormat dst_format, VkExtent3D extent) {
1876 VkExtent3D adjusted_extent = extent;
1877 if ((FormatIsCompressed(src_format) && (!FormatIsCompressed(dst_format)))) {
Dave Houltona585d132019-01-18 13:05:42 -07001878 VkExtent3D block_size = FormatTexelBlockExtent(src_format);
Dave Houltonee281a52017-12-08 13:51:02 -07001879 adjusted_extent.width /= block_size.width;
1880 adjusted_extent.height /= block_size.height;
1881 adjusted_extent.depth /= block_size.depth;
1882 } else if ((!FormatIsCompressed(src_format) && (FormatIsCompressed(dst_format)))) {
Dave Houltona585d132019-01-18 13:05:42 -07001883 VkExtent3D block_size = FormatTexelBlockExtent(dst_format);
Dave Houltonee281a52017-12-08 13:51:02 -07001884 adjusted_extent.width *= block_size.width;
1885 adjusted_extent.height *= block_size.height;
1886 adjusted_extent.depth *= block_size.depth;
1887 }
1888 return adjusted_extent;
1889}
1890
Dave Houlton6f9059e2017-05-02 17:15:13 -06001891// Returns the effective extent of an image subresource, adjusted for mip level and array depth.
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001892static inline VkExtent3D GetImageSubresourceExtent(const IMAGE_STATE *img, const VkImageSubresourceLayers *subresource) {
1893 const uint32_t mip = subresource->mipLevel;
Dave Houltonfc1a4052017-04-27 14:32:45 -06001894
1895 // Return zero extent if mip level doesn't exist
Dave Houlton1150cf52017-04-27 14:38:11 -06001896 if (mip >= img->createInfo.mipLevels) {
1897 return VkExtent3D{0, 0, 0};
Dave Houltonfc1a4052017-04-27 14:32:45 -06001898 }
Dave Houlton1150cf52017-04-27 14:38:11 -06001899
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001900 // Don't allow mip adjustment to create 0 dim, but pass along a 0 if that's what subresource specified
Dave Houltonfc1a4052017-04-27 14:32:45 -06001901 VkExtent3D extent = img->createInfo.extent;
Jeff Bolzef40fec2018-09-01 22:04:34 -05001902
Dave Houltone48cd112019-01-03 17:01:18 -07001903 // If multi-plane, adjust per-plane extent
1904 if (FormatIsMultiplane(img->createInfo.format)) {
1905 VkExtent2D divisors = FindMultiplaneExtentDivisors(img->createInfo.format, subresource->aspectMask);
1906 extent.width /= divisors.width;
1907 extent.height /= divisors.height;
1908 }
1909
Jeff Bolzef40fec2018-09-01 22:04:34 -05001910 if (img->createInfo.flags & VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV) {
1911 extent.width = (0 == extent.width ? 0 : std::max(2U, 1 + ((extent.width - 1) >> mip)));
Dave Houlton142c4cb2018-10-17 15:04:41 -06001912 extent.height = (0 == extent.height ? 0 : std::max(2U, 1 + ((extent.height - 1) >> mip)));
Jeff Bolzef40fec2018-09-01 22:04:34 -05001913 extent.depth = (0 == extent.depth ? 0 : std::max(2U, 1 + ((extent.depth - 1) >> mip)));
1914 } else {
1915 extent.width = (0 == extent.width ? 0 : std::max(1U, extent.width >> mip));
1916 extent.height = (0 == extent.height ? 0 : std::max(1U, extent.height >> mip));
1917 extent.depth = (0 == extent.depth ? 0 : std::max(1U, extent.depth >> mip));
1918 }
Dave Houltonfc1a4052017-04-27 14:32:45 -06001919
Dave Houlton6f9059e2017-05-02 17:15:13 -06001920 // Image arrays have an effective z extent that isn't diminished by mip level
1921 if (VK_IMAGE_TYPE_3D != img->createInfo.imageType) {
Dave Houltonfc1a4052017-04-27 14:32:45 -06001922 extent.depth = img->createInfo.arrayLayers;
1923 }
1924
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001925 return extent;
1926}
1927
1928// Test if the extent argument has all dimensions set to 0.
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001929static inline bool IsExtentAllZeroes(const VkExtent3D *extent) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001930 return ((extent->width == 0) && (extent->height == 0) && (extent->depth == 0));
1931}
1932
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001933// Test if the extent argument has any dimensions set to 0.
1934static inline bool IsExtentSizeZero(const VkExtent3D *extent) {
1935 return ((extent->width == 0) || (extent->height == 0) || (extent->depth == 0));
1936}
1937
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001938// Returns the image transfer granularity for a specific image scaled by compressed block size if necessary.
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001939VkExtent3D CoreChecks::GetScaledItg(layer_data *device_data, const GLOBAL_CB_NODE *cb_node, const IMAGE_STATE *img) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001940 // Default to (0, 0, 0) granularity in case we can't find the real granularity for the physical device.
1941 VkExtent3D granularity = {0, 0, 0};
Mark Lobodzinski8b0a7b82019-03-06 16:17:45 -07001942 auto pPool = GetCommandPoolNode(cb_node->createInfo.commandPool);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001943 if (pPool) {
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001944 granularity = GetPhysicalDeviceState()->queue_family_properties[pPool->queueFamilyIndex].minImageTransferGranularity;
Dave Houlton1d2022c2017-03-29 11:43:58 -06001945 if (FormatIsCompressed(img->createInfo.format)) {
Dave Houltona585d132019-01-18 13:05:42 -07001946 auto block_size = FormatTexelBlockExtent(img->createInfo.format);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001947 granularity.width *= block_size.width;
1948 granularity.height *= block_size.height;
1949 }
1950 }
1951 return granularity;
1952}
1953
1954// Test elements of a VkExtent3D structure against alignment constraints contained in another VkExtent3D structure
1955static inline bool IsExtentAligned(const VkExtent3D *extent, const VkExtent3D *granularity) {
1956 bool valid = true;
Dave Houlton1d2022c2017-03-29 11:43:58 -06001957 if ((SafeModulo(extent->depth, granularity->depth) != 0) || (SafeModulo(extent->width, granularity->width) != 0) ||
1958 (SafeModulo(extent->height, granularity->height) != 0)) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001959 valid = false;
1960 }
1961 return valid;
1962}
1963
1964// Check elements of a VkOffset3D structure against a queue family's Image Transfer Granularity values
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001965bool CoreChecks::CheckItgOffset(layer_data *device_data, const GLOBAL_CB_NODE *cb_node, const VkOffset3D *offset,
1966 const VkExtent3D *granularity, const uint32_t i, const char *function, const char *member,
1967 const char *vuid) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001968 bool skip = false;
1969 VkExtent3D offset_extent = {};
1970 offset_extent.width = static_cast<uint32_t>(abs(offset->x));
1971 offset_extent.height = static_cast<uint32_t>(abs(offset->y));
1972 offset_extent.depth = static_cast<uint32_t>(abs(offset->z));
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001973 if (IsExtentAllZeroes(granularity)) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001974 // If the queue family image transfer granularity is (0, 0, 0), then the offset must always be (0, 0, 0)
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001975 if (IsExtentAllZeroes(&offset_extent) == false) {
Petr Krausbc7f5442017-05-14 23:43:38 +02001976 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Cort Stratton420ebd42018-05-04 01:12:23 -04001977 HandleToUint64(cb_node->commandBuffer), vuid,
Dave Houltona9df0ce2018-02-07 10:51:23 -07001978 "%s: pRegion[%d].%s (x=%d, y=%d, z=%d) must be (x=0, y=0, z=0) when the command buffer's queue family "
1979 "image transfer granularity is (w=0, h=0, d=0).",
Petr Krausbc7f5442017-05-14 23:43:38 +02001980 function, i, member, offset->x, offset->y, offset->z);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001981 }
1982 } else {
1983 // If the queue family image transfer granularity is not (0, 0, 0), then the offset dimensions must always be even
1984 // integer multiples of the image transfer granularity.
1985 if (IsExtentAligned(&offset_extent, granularity) == false) {
Petr Krausbc7f5442017-05-14 23:43:38 +02001986 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Cort Stratton420ebd42018-05-04 01:12:23 -04001987 HandleToUint64(cb_node->commandBuffer), vuid,
Dave Houltona9df0ce2018-02-07 10:51:23 -07001988 "%s: pRegion[%d].%s (x=%d, y=%d, z=%d) dimensions must be even integer multiples of this command "
1989 "buffer's queue family image transfer granularity (w=%d, h=%d, d=%d).",
Petr Krausbc7f5442017-05-14 23:43:38 +02001990 function, i, member, offset->x, offset->y, offset->z, granularity->width, granularity->height,
1991 granularity->depth);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001992 }
1993 }
1994 return skip;
1995}
1996
1997// Check elements of a VkExtent3D structure against a queue family's Image Transfer Granularity values
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001998bool CoreChecks::CheckItgExtent(layer_data *device_data, const GLOBAL_CB_NODE *cb_node, const VkExtent3D *extent,
1999 const VkOffset3D *offset, const VkExtent3D *granularity, const VkExtent3D *subresource_extent,
2000 const VkImageType image_type, const uint32_t i, const char *function, const char *member,
2001 const char *vuid) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002002 bool skip = false;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07002003 if (IsExtentAllZeroes(granularity)) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002004 // If the queue family image transfer granularity is (0, 0, 0), then the extent must always match the image
2005 // subresource extent.
2006 if (IsExtentEqual(extent, subresource_extent) == false) {
Petr Krausbc7f5442017-05-14 23:43:38 +02002007 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Cort Stratton420ebd42018-05-04 01:12:23 -04002008 HandleToUint64(cb_node->commandBuffer), vuid,
Petr Krausbc7f5442017-05-14 23:43:38 +02002009 "%s: pRegion[%d].%s (w=%d, h=%d, d=%d) must match the image subresource extents (w=%d, h=%d, d=%d) "
2010 "when the command buffer's queue family image transfer granularity is (w=0, h=0, d=0).",
2011 function, i, member, extent->width, extent->height, extent->depth, subresource_extent->width,
2012 subresource_extent->height, subresource_extent->depth);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002013 }
2014 } else {
2015 // If the queue family image transfer granularity is not (0, 0, 0), then the extent dimensions must always be even
2016 // integer multiples of the image transfer granularity or the offset + extent dimensions must always match the image
2017 // subresource extent dimensions.
2018 VkExtent3D offset_extent_sum = {};
2019 offset_extent_sum.width = static_cast<uint32_t>(abs(offset->x)) + extent->width;
2020 offset_extent_sum.height = static_cast<uint32_t>(abs(offset->y)) + extent->height;
2021 offset_extent_sum.depth = static_cast<uint32_t>(abs(offset->z)) + extent->depth;
Mark Lobodzinski283ade62017-10-09 16:36:49 -06002022 bool x_ok = true;
2023 bool y_ok = true;
2024 bool z_ok = true;
2025 switch (image_type) {
2026 case VK_IMAGE_TYPE_3D:
2027 z_ok = ((0 == SafeModulo(extent->depth, granularity->depth)) ||
2028 (subresource_extent->depth == offset_extent_sum.depth));
Tobin Ehlis648b1cf2018-04-13 15:24:13 -06002029 // fall through
Mark Lobodzinski283ade62017-10-09 16:36:49 -06002030 case VK_IMAGE_TYPE_2D:
2031 y_ok = ((0 == SafeModulo(extent->height, granularity->height)) ||
2032 (subresource_extent->height == offset_extent_sum.height));
Tobin Ehlis648b1cf2018-04-13 15:24:13 -06002033 // fall through
Mark Lobodzinski283ade62017-10-09 16:36:49 -06002034 case VK_IMAGE_TYPE_1D:
2035 x_ok = ((0 == SafeModulo(extent->width, granularity->width)) ||
2036 (subresource_extent->width == offset_extent_sum.width));
2037 break;
2038 default:
2039 // Unrecognized or new IMAGE_TYPE enums will be caught in parameter_validation
2040 assert(false);
2041 }
Dave Houlton6f9059e2017-05-02 17:15:13 -06002042 if (!(x_ok && y_ok && z_ok)) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07002043 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Cort Stratton420ebd42018-05-04 01:12:23 -04002044 HandleToUint64(cb_node->commandBuffer), vuid,
Dave Houltona9df0ce2018-02-07 10:51:23 -07002045 "%s: pRegion[%d].%s (w=%d, h=%d, d=%d) dimensions must be even integer multiples of this command "
2046 "buffer's queue family image transfer granularity (w=%d, h=%d, d=%d) or offset (x=%d, y=%d, z=%d) + "
2047 "extent (w=%d, h=%d, d=%d) must match the image subresource extents (w=%d, h=%d, d=%d).",
2048 function, i, member, extent->width, extent->height, extent->depth, granularity->width,
2049 granularity->height, granularity->depth, offset->x, offset->y, offset->z, extent->width, extent->height,
2050 extent->depth, subresource_extent->width, subresource_extent->height, subresource_extent->depth);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002051 }
2052 }
2053 return skip;
2054}
2055
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002056bool CoreChecks::ValidateImageMipLevel(layer_data *device_data, const GLOBAL_CB_NODE *cb_node, const IMAGE_STATE *img,
2057 uint32_t mip_level, const uint32_t i, const char *function, const char *member,
2058 const char *vuid) {
Cort Strattonff1542a2018-05-27 10:49:28 -07002059 bool skip = false;
2060 if (mip_level >= img->createInfo.mipLevels) {
2061 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2062 HandleToUint64(cb_node->commandBuffer), vuid,
Lockee9aeebf2019-03-03 23:50:08 -07002063 "In %s, pRegions[%u].%s.mipLevel is %u, but provided image %s has %u mip levels.", function, i, member,
2064 mip_level, report_data->FormatHandle(img->image).c_str(), img->createInfo.mipLevels);
Cort Strattonff1542a2018-05-27 10:49:28 -07002065 }
2066 return skip;
2067}
2068
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002069bool CoreChecks::ValidateImageArrayLayerRange(layer_data *device_data, const GLOBAL_CB_NODE *cb_node, const IMAGE_STATE *img,
2070 const uint32_t base_layer, const uint32_t layer_count, const uint32_t i,
2071 const char *function, const char *member, const char *vuid) {
Cort Strattonff1542a2018-05-27 10:49:28 -07002072 bool skip = false;
2073 if (base_layer >= img->createInfo.arrayLayers || layer_count > img->createInfo.arrayLayers ||
2074 (base_layer + layer_count) > img->createInfo.arrayLayers) {
2075 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2076 HandleToUint64(cb_node->commandBuffer), vuid,
2077 "In %s, pRegions[%u].%s.baseArrayLayer is %u and .layerCount is "
Lockee9aeebf2019-03-03 23:50:08 -07002078 "%u, but provided image %s has %u array layers.",
2079 function, i, member, base_layer, layer_count, report_data->FormatHandle(img->image).c_str(),
2080 img->createInfo.arrayLayers);
Cort Strattonff1542a2018-05-27 10:49:28 -07002081 }
2082 return skip;
2083}
2084
Mark Lobodzinskibf0042d2018-02-26 16:01:22 -07002085// Check valid usage Image Transfer Granularity requirements for elements of a VkBufferImageCopy structure
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002086bool CoreChecks::ValidateCopyBufferImageTransferGranularityRequirements(layer_data *device_data, const GLOBAL_CB_NODE *cb_node,
2087 const IMAGE_STATE *img, const VkBufferImageCopy *region,
2088 const uint32_t i, const char *function, const char *vuid) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002089 bool skip = false;
Cort Stratton420ebd42018-05-04 01:12:23 -04002090 VkExtent3D granularity = GetScaledItg(device_data, cb_node, img);
2091 skip |= CheckItgOffset(device_data, cb_node, &region->imageOffset, &granularity, i, function, "imageOffset", vuid);
2092 VkExtent3D subresource_extent = GetImageSubresourceExtent(img, &region->imageSubresource);
2093 skip |= CheckItgExtent(device_data, cb_node, &region->imageExtent, &region->imageOffset, &granularity, &subresource_extent,
2094 img->createInfo.imageType, i, function, "imageExtent", vuid);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002095 return skip;
2096}
2097
Mark Lobodzinskibf0042d2018-02-26 16:01:22 -07002098// Check valid usage Image Transfer Granularity requirements for elements of a VkImageCopy structure
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002099bool CoreChecks::ValidateCopyImageTransferGranularityRequirements(layer_data *device_data, const GLOBAL_CB_NODE *cb_node,
2100 const IMAGE_STATE *src_img, const IMAGE_STATE *dst_img,
2101 const VkImageCopy *region, const uint32_t i,
2102 const char *function) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002103 bool skip = false;
Mark Lobodzinskid0788802017-10-19 15:38:59 -06002104 // Source image checks
Dave Houlton6f9059e2017-05-02 17:15:13 -06002105 VkExtent3D granularity = GetScaledItg(device_data, cb_node, src_img);
Dave Houltond8ed0212018-05-16 17:18:24 -06002106 skip |= CheckItgOffset(device_data, cb_node, &region->srcOffset, &granularity, i, function, "srcOffset",
2107 "VUID-vkCmdCopyImage-srcOffset-01783");
Dave Houlton6f9059e2017-05-02 17:15:13 -06002108 VkExtent3D subresource_extent = GetImageSubresourceExtent(src_img, &region->srcSubresource);
Dave Houlton94a00372017-12-14 15:08:47 -07002109 const VkExtent3D extent = region->extent;
Mark Lobodzinskid0788802017-10-19 15:38:59 -06002110 skip |= CheckItgExtent(device_data, cb_node, &extent, &region->srcOffset, &granularity, &subresource_extent,
Dave Houltond8ed0212018-05-16 17:18:24 -06002111 src_img->createInfo.imageType, i, function, "extent", "VUID-vkCmdCopyImage-srcOffset-01783");
Dave Houlton6f9059e2017-05-02 17:15:13 -06002112
Mark Lobodzinskid0788802017-10-19 15:38:59 -06002113 // Destination image checks
Dave Houlton6f9059e2017-05-02 17:15:13 -06002114 granularity = GetScaledItg(device_data, cb_node, dst_img);
Dave Houltond8ed0212018-05-16 17:18:24 -06002115 skip |= CheckItgOffset(device_data, cb_node, &region->dstOffset, &granularity, i, function, "dstOffset",
2116 "VUID-vkCmdCopyImage-dstOffset-01784");
Dave Houltonee281a52017-12-08 13:51:02 -07002117 // Adjust dest extent, if necessary
Dave Houlton94a00372017-12-14 15:08:47 -07002118 const VkExtent3D dest_effective_extent =
2119 GetAdjustedDestImageExtent(src_img->createInfo.format, dst_img->createInfo.format, extent);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002120 subresource_extent = GetImageSubresourceExtent(dst_img, &region->dstSubresource);
Dave Houltonee281a52017-12-08 13:51:02 -07002121 skip |= CheckItgExtent(device_data, cb_node, &dest_effective_extent, &region->dstOffset, &granularity, &subresource_extent,
Dave Houltond8ed0212018-05-16 17:18:24 -06002122 dst_img->createInfo.imageType, i, function, "extent", "VUID-vkCmdCopyImage-dstOffset-01784");
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002123 return skip;
2124}
2125
Dave Houlton6f9059e2017-05-02 17:15:13 -06002126// Validate contents of a VkImageCopy struct
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002127bool CoreChecks::ValidateImageCopyData(const layer_data *device_data, const debug_report_data *report_data,
2128 const uint32_t regionCount, const VkImageCopy *ic_regions, const IMAGE_STATE *src_state,
2129 const IMAGE_STATE *dst_state) {
Dave Houlton6f9059e2017-05-02 17:15:13 -06002130 bool skip = false;
2131
2132 for (uint32_t i = 0; i < regionCount; i++) {
Dave Houlton94a00372017-12-14 15:08:47 -07002133 const VkImageCopy region = ic_regions[i];
Dave Houltonee281a52017-12-08 13:51:02 -07002134
2135 // For comp<->uncomp copies, the copy extent for the dest image must be adjusted
Dave Houlton94a00372017-12-14 15:08:47 -07002136 const VkExtent3D src_copy_extent = region.extent;
2137 const VkExtent3D dst_copy_extent =
Dave Houltonee281a52017-12-08 13:51:02 -07002138 GetAdjustedDestImageExtent(src_state->createInfo.format, dst_state->createInfo.format, region.extent);
2139
Dave Houlton6f9059e2017-05-02 17:15:13 -06002140 bool slice_override = false;
2141 uint32_t depth_slices = 0;
2142
2143 // Special case for copying between a 1D/2D array and a 3D image
2144 // TBD: This seems like the only way to reconcile 3 mutually-exclusive VU checks for 2D/3D copies. Heads up.
2145 if ((VK_IMAGE_TYPE_3D == src_state->createInfo.imageType) && (VK_IMAGE_TYPE_3D != dst_state->createInfo.imageType)) {
Dave Houltonee281a52017-12-08 13:51:02 -07002146 depth_slices = region.dstSubresource.layerCount; // Slice count from 2D subresource
Dave Houlton6f9059e2017-05-02 17:15:13 -06002147 slice_override = (depth_slices != 1);
2148 } else if ((VK_IMAGE_TYPE_3D == dst_state->createInfo.imageType) && (VK_IMAGE_TYPE_3D != src_state->createInfo.imageType)) {
Dave Houltonee281a52017-12-08 13:51:02 -07002149 depth_slices = region.srcSubresource.layerCount; // Slice count from 2D subresource
Dave Houlton6f9059e2017-05-02 17:15:13 -06002150 slice_override = (depth_slices != 1);
2151 }
2152
2153 // Do all checks on source image
2154 //
2155 if (src_state->createInfo.imageType == VK_IMAGE_TYPE_1D) {
Dave Houltonee281a52017-12-08 13:51:02 -07002156 if ((0 != region.srcOffset.y) || (1 != src_copy_extent.height)) {
2157 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002158 HandleToUint64(src_state->image), "VUID-VkImageCopy-srcImage-00146",
Dave Houltonee281a52017-12-08 13:51:02 -07002159 "vkCmdCopyImage(): pRegion[%d] srcOffset.y is %d and extent.height is %d. For 1D images these must "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002160 "be 0 and 1, respectively.",
2161 i, region.srcOffset.y, src_copy_extent.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002162 }
2163 }
2164
Dave Houlton533be9f2018-03-26 17:08:30 -06002165 // VUID-VkImageCopy-srcImage-01785
2166 if ((src_state->createInfo.imageType == VK_IMAGE_TYPE_1D) && ((0 != region.srcOffset.z) || (1 != src_copy_extent.depth))) {
2167 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002168 HandleToUint64(src_state->image), "VUID-VkImageCopy-srcImage-01785",
Dave Houlton533be9f2018-03-26 17:08:30 -06002169 "vkCmdCopyImage(): pRegion[%d] srcOffset.z is %d and extent.depth is %d. For 1D images "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002170 "these must be 0 and 1, respectively.",
2171 i, region.srcOffset.z, src_copy_extent.depth);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002172 }
2173
Dave Houlton533be9f2018-03-26 17:08:30 -06002174 // VUID-VkImageCopy-srcImage-01787
2175 if ((src_state->createInfo.imageType == VK_IMAGE_TYPE_2D) && (0 != region.srcOffset.z)) {
2176 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002177 HandleToUint64(src_state->image), "VUID-VkImageCopy-srcImage-01787",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002178 "vkCmdCopyImage(): pRegion[%d] srcOffset.z is %d. For 2D images the z-offset must be 0.", i,
2179 region.srcOffset.z);
Dave Houlton533be9f2018-03-26 17:08:30 -06002180 }
2181
Mark Lobodzinski60e79032019-03-07 10:22:31 -07002182 if (GetDeviceExtensions()->vk_khr_maintenance1) {
Dave Houlton6f9059e2017-05-02 17:15:13 -06002183 if (src_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
Dave Houltonee281a52017-12-08 13:51:02 -07002184 if ((0 != region.srcSubresource.baseArrayLayer) || (1 != region.srcSubresource.layerCount)) {
Dave Houlton6f9059e2017-05-02 17:15:13 -06002185 skip |=
2186 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002187 HandleToUint64(src_state->image), "VUID-VkImageCopy-srcImage-00141",
Dave Houlton6f9059e2017-05-02 17:15:13 -06002188 "vkCmdCopyImage(): pRegion[%d] srcSubresource.baseArrayLayer is %d and srcSubresource.layerCount "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002189 "is %d. For VK_IMAGE_TYPE_3D images these must be 0 and 1, respectively.",
2190 i, region.srcSubresource.baseArrayLayer, region.srcSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002191 }
2192 }
2193 } else { // Pre maint 1
2194 if (src_state->createInfo.imageType == VK_IMAGE_TYPE_3D || dst_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
Dave Houltonee281a52017-12-08 13:51:02 -07002195 if ((0 != region.srcSubresource.baseArrayLayer) || (1 != region.srcSubresource.layerCount)) {
Petr Kraus13c98a62017-12-09 00:22:39 +01002196 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002197 HandleToUint64(src_state->image), "VUID-VkImageCopy-srcImage-00141",
Petr Kraus13c98a62017-12-09 00:22:39 +01002198 "vkCmdCopyImage(): pRegion[%d] srcSubresource.baseArrayLayer is %d and "
2199 "srcSubresource.layerCount is %d. For copies with either source or dest of type "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002200 "VK_IMAGE_TYPE_3D, these must be 0 and 1, respectively.",
2201 i, region.srcSubresource.baseArrayLayer, region.srcSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002202 }
2203 }
2204 }
2205
Dave Houltonc991cc92018-03-06 11:08:51 -07002206 // Source checks that apply only to compressed images (or to _422 images if ycbcr enabled)
Mark Lobodzinski60e79032019-03-07 10:22:31 -07002207 bool ext_ycbcr = GetDeviceExtensions()->vk_khr_sampler_ycbcr_conversion;
Dave Houltonc991cc92018-03-06 11:08:51 -07002208 if (FormatIsCompressed(src_state->createInfo.format) ||
2209 (ext_ycbcr && FormatIsSinglePlane_422(src_state->createInfo.format))) {
Dave Houltona585d132019-01-18 13:05:42 -07002210 const VkExtent3D block_size = FormatTexelBlockExtent(src_state->createInfo.format);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002211 // image offsets must be multiples of block dimensions
Dave Houltonee281a52017-12-08 13:51:02 -07002212 if ((SafeModulo(region.srcOffset.x, block_size.width) != 0) ||
2213 (SafeModulo(region.srcOffset.y, block_size.height) != 0) ||
2214 (SafeModulo(region.srcOffset.z, block_size.depth) != 0)) {
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06002215 const char *vuid = ext_ycbcr ? "VUID-VkImageCopy-srcImage-01727" : "VUID-VkImageCopy-srcOffset-00157";
Dave Houlton6f9059e2017-05-02 17:15:13 -06002216 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltonc991cc92018-03-06 11:08:51 -07002217 HandleToUint64(src_state->image), vuid,
Dave Houlton6f9059e2017-05-02 17:15:13 -06002218 "vkCmdCopyImage(): pRegion[%d] srcOffset (%d, %d) must be multiples of the compressed image's "
Dave Houltonc991cc92018-03-06 11:08:51 -07002219 "texel width & height (%d, %d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002220 i, region.srcOffset.x, region.srcOffset.y, block_size.width, block_size.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002221 }
2222
Dave Houlton94a00372017-12-14 15:08:47 -07002223 const VkExtent3D mip_extent = GetImageSubresourceExtent(src_state, &(region.srcSubresource));
Dave Houltonee281a52017-12-08 13:51:02 -07002224 if ((SafeModulo(src_copy_extent.width, block_size.width) != 0) &&
2225 (src_copy_extent.width + region.srcOffset.x != mip_extent.width)) {
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06002226 const char *vuid = ext_ycbcr ? "VUID-VkImageCopy-srcImage-01728" : "VUID-VkImageCopy-extent-00158";
Dave Houlton6f9059e2017-05-02 17:15:13 -06002227 skip |=
2228 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltonc991cc92018-03-06 11:08:51 -07002229 HandleToUint64(src_state->image), vuid,
Dave Houlton6f9059e2017-05-02 17:15:13 -06002230 "vkCmdCopyImage(): pRegion[%d] extent width (%d) must be a multiple of the compressed texture block "
Dave Houltonc991cc92018-03-06 11:08:51 -07002231 "width (%d), or when added to srcOffset.x (%d) must equal the image subresource width (%d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002232 i, src_copy_extent.width, block_size.width, region.srcOffset.x, mip_extent.width);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002233 }
2234
Mark Lobodzinskid0788802017-10-19 15:38:59 -06002235 // Extent height must be a multiple of block height, or extent+offset height must equal subresource height
Dave Houltonee281a52017-12-08 13:51:02 -07002236 if ((SafeModulo(src_copy_extent.height, block_size.height) != 0) &&
2237 (src_copy_extent.height + region.srcOffset.y != mip_extent.height)) {
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06002238 const char *vuid = ext_ycbcr ? "VUID-VkImageCopy-srcImage-01729" : "VUID-VkImageCopy-extent-00159";
Dave Houlton6f9059e2017-05-02 17:15:13 -06002239 skip |=
2240 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltonc991cc92018-03-06 11:08:51 -07002241 HandleToUint64(src_state->image), vuid,
Dave Houlton6f9059e2017-05-02 17:15:13 -06002242 "vkCmdCopyImage(): pRegion[%d] extent height (%d) must be a multiple of the compressed texture block "
Dave Houltonc991cc92018-03-06 11:08:51 -07002243 "height (%d), or when added to srcOffset.y (%d) must equal the image subresource height (%d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002244 i, src_copy_extent.height, block_size.height, region.srcOffset.y, mip_extent.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002245 }
2246
Mark Lobodzinskid0788802017-10-19 15:38:59 -06002247 // Extent depth must be a multiple of block depth, or extent+offset depth must equal subresource depth
Dave Houltonee281a52017-12-08 13:51:02 -07002248 uint32_t copy_depth = (slice_override ? depth_slices : src_copy_extent.depth);
2249 if ((SafeModulo(copy_depth, block_size.depth) != 0) && (copy_depth + region.srcOffset.z != mip_extent.depth)) {
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06002250 const char *vuid = ext_ycbcr ? "VUID-VkImageCopy-srcImage-01730" : "VUID-VkImageCopy-extent-00160";
Dave Houlton6f9059e2017-05-02 17:15:13 -06002251 skip |=
2252 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltonc991cc92018-03-06 11:08:51 -07002253 HandleToUint64(src_state->image), vuid,
Dave Houlton6f9059e2017-05-02 17:15:13 -06002254 "vkCmdCopyImage(): pRegion[%d] extent width (%d) must be a multiple of the compressed texture block "
Dave Houltonc991cc92018-03-06 11:08:51 -07002255 "depth (%d), or when added to srcOffset.z (%d) must equal the image subresource depth (%d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002256 i, src_copy_extent.depth, block_size.depth, region.srcOffset.z, mip_extent.depth);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002257 }
2258 } // Compressed
2259
2260 // Do all checks on dest image
2261 //
2262 if (dst_state->createInfo.imageType == VK_IMAGE_TYPE_1D) {
Dave Houltonee281a52017-12-08 13:51:02 -07002263 if ((0 != region.dstOffset.y) || (1 != dst_copy_extent.height)) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07002264 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002265 HandleToUint64(dst_state->image), "VUID-VkImageCopy-dstImage-00152",
Dave Houltona9df0ce2018-02-07 10:51:23 -07002266 "vkCmdCopyImage(): pRegion[%d] dstOffset.y is %d and dst_copy_extent.height is %d. For 1D images "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002267 "these must be 0 and 1, respectively.",
2268 i, region.dstOffset.y, dst_copy_extent.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002269 }
2270 }
2271
Dave Houlton533be9f2018-03-26 17:08:30 -06002272 // VUID-VkImageCopy-dstImage-01786
2273 if ((dst_state->createInfo.imageType == VK_IMAGE_TYPE_1D) && ((0 != region.dstOffset.z) || (1 != dst_copy_extent.depth))) {
2274 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002275 HandleToUint64(dst_state->image), "VUID-VkImageCopy-dstImage-01786",
Dave Houlton533be9f2018-03-26 17:08:30 -06002276 "vkCmdCopyImage(): pRegion[%d] dstOffset.z is %d and extent.depth is %d. For 1D images these must be 0 "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002277 "and 1, respectively.",
2278 i, region.dstOffset.z, dst_copy_extent.depth);
Dave Houlton533be9f2018-03-26 17:08:30 -06002279 }
2280
2281 // VUID-VkImageCopy-dstImage-01788
2282 if ((dst_state->createInfo.imageType == VK_IMAGE_TYPE_2D) && (0 != region.dstOffset.z)) {
2283 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002284 HandleToUint64(dst_state->image), "VUID-VkImageCopy-dstImage-01788",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002285 "vkCmdCopyImage(): pRegion[%d] dstOffset.z is %d. For 2D images the z-offset must be 0.", i,
2286 region.dstOffset.z);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002287 }
2288
2289 if (dst_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
Dave Houltonee281a52017-12-08 13:51:02 -07002290 if ((0 != region.dstSubresource.baseArrayLayer) || (1 != region.dstSubresource.layerCount)) {
Dave Houlton6f9059e2017-05-02 17:15:13 -06002291 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002292 HandleToUint64(dst_state->image), "VUID-VkImageCopy-srcImage-00141",
Dave Houlton6f9059e2017-05-02 17:15:13 -06002293 "vkCmdCopyImage(): pRegion[%d] dstSubresource.baseArrayLayer is %d and dstSubresource.layerCount "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002294 "is %d. For VK_IMAGE_TYPE_3D images these must be 0 and 1, respectively.",
2295 i, region.dstSubresource.baseArrayLayer, region.dstSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002296 }
2297 }
2298 // VU01199 changed with mnt1
Mark Lobodzinski60e79032019-03-07 10:22:31 -07002299 if (GetDeviceExtensions()->vk_khr_maintenance1) {
Dave Houlton6f9059e2017-05-02 17:15:13 -06002300 if (dst_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
Dave Houltonee281a52017-12-08 13:51:02 -07002301 if ((0 != region.dstSubresource.baseArrayLayer) || (1 != region.dstSubresource.layerCount)) {
Dave Houlton6f9059e2017-05-02 17:15:13 -06002302 skip |=
2303 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002304 HandleToUint64(dst_state->image), "VUID-VkImageCopy-srcImage-00141",
Dave Houlton6f9059e2017-05-02 17:15:13 -06002305 "vkCmdCopyImage(): pRegion[%d] dstSubresource.baseArrayLayer is %d and dstSubresource.layerCount "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002306 "is %d. For VK_IMAGE_TYPE_3D images these must be 0 and 1, respectively.",
2307 i, region.dstSubresource.baseArrayLayer, region.dstSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002308 }
2309 }
2310 } else { // Pre maint 1
2311 if (src_state->createInfo.imageType == VK_IMAGE_TYPE_3D || dst_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
Dave Houltonee281a52017-12-08 13:51:02 -07002312 if ((0 != region.dstSubresource.baseArrayLayer) || (1 != region.dstSubresource.layerCount)) {
Petr Kraus13c98a62017-12-09 00:22:39 +01002313 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002314 HandleToUint64(dst_state->image), "VUID-VkImageCopy-srcImage-00141",
Petr Kraus13c98a62017-12-09 00:22:39 +01002315 "vkCmdCopyImage(): pRegion[%d] dstSubresource.baseArrayLayer is %d and "
2316 "dstSubresource.layerCount is %d. For copies with either source or dest of type "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002317 "VK_IMAGE_TYPE_3D, these must be 0 and 1, respectively.",
2318 i, region.dstSubresource.baseArrayLayer, region.dstSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002319 }
2320 }
2321 }
2322
Dave Houltonc991cc92018-03-06 11:08:51 -07002323 // Dest checks that apply only to compressed images (or to _422 images if ycbcr enabled)
2324 if (FormatIsCompressed(dst_state->createInfo.format) ||
2325 (ext_ycbcr && FormatIsSinglePlane_422(dst_state->createInfo.format))) {
Dave Houltona585d132019-01-18 13:05:42 -07002326 const VkExtent3D block_size = FormatTexelBlockExtent(dst_state->createInfo.format);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002327
2328 // image offsets must be multiples of block dimensions
Dave Houltonee281a52017-12-08 13:51:02 -07002329 if ((SafeModulo(region.dstOffset.x, block_size.width) != 0) ||
2330 (SafeModulo(region.dstOffset.y, block_size.height) != 0) ||
2331 (SafeModulo(region.dstOffset.z, block_size.depth) != 0)) {
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06002332 const char *vuid = ext_ycbcr ? "VUID-VkImageCopy-dstImage-01731" : "VUID-VkImageCopy-dstOffset-00162";
Dave Houlton6f9059e2017-05-02 17:15:13 -06002333 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltonc991cc92018-03-06 11:08:51 -07002334 HandleToUint64(dst_state->image), vuid,
Dave Houlton6f9059e2017-05-02 17:15:13 -06002335 "vkCmdCopyImage(): pRegion[%d] dstOffset (%d, %d) must be multiples of the compressed image's "
Dave Houltonc991cc92018-03-06 11:08:51 -07002336 "texel width & height (%d, %d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002337 i, region.dstOffset.x, region.dstOffset.y, block_size.width, block_size.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002338 }
2339
Dave Houlton94a00372017-12-14 15:08:47 -07002340 const VkExtent3D mip_extent = GetImageSubresourceExtent(dst_state, &(region.dstSubresource));
Dave Houltonee281a52017-12-08 13:51:02 -07002341 if ((SafeModulo(dst_copy_extent.width, block_size.width) != 0) &&
2342 (dst_copy_extent.width + region.dstOffset.x != mip_extent.width)) {
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06002343 const char *vuid = ext_ycbcr ? "VUID-VkImageCopy-dstImage-01732" : "VUID-VkImageCopy-extent-00163";
Dave Houltona9df0ce2018-02-07 10:51:23 -07002344 skip |=
2345 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltonc991cc92018-03-06 11:08:51 -07002346 HandleToUint64(dst_state->image), vuid,
Dave Houltona9df0ce2018-02-07 10:51:23 -07002347 "vkCmdCopyImage(): pRegion[%d] dst_copy_extent width (%d) must be a multiple of the compressed texture "
Dave Houltonc991cc92018-03-06 11:08:51 -07002348 "block width (%d), or when added to dstOffset.x (%d) must equal the image subresource width (%d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002349 i, dst_copy_extent.width, block_size.width, region.dstOffset.x, mip_extent.width);
Mark Lobodzinskid0788802017-10-19 15:38:59 -06002350 }
2351
Dave Houltonee281a52017-12-08 13:51:02 -07002352 // Extent height must be a multiple of block height, or dst_copy_extent+offset height must equal subresource height
2353 if ((SafeModulo(dst_copy_extent.height, block_size.height) != 0) &&
2354 (dst_copy_extent.height + region.dstOffset.y != mip_extent.height)) {
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06002355 const char *vuid = ext_ycbcr ? "VUID-VkImageCopy-dstImage-01733" : "VUID-VkImageCopy-extent-00164";
Dave Houltona9df0ce2018-02-07 10:51:23 -07002356 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltonc991cc92018-03-06 11:08:51 -07002357 HandleToUint64(dst_state->image), vuid,
Dave Houltona9df0ce2018-02-07 10:51:23 -07002358 "vkCmdCopyImage(): pRegion[%d] dst_copy_extent height (%d) must be a multiple of the compressed "
2359 "texture block height (%d), or when added to dstOffset.y (%d) must equal the image subresource "
Dave Houltonc991cc92018-03-06 11:08:51 -07002360 "height (%d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002361 i, dst_copy_extent.height, block_size.height, region.dstOffset.y, mip_extent.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002362 }
2363
Dave Houltonee281a52017-12-08 13:51:02 -07002364 // Extent depth must be a multiple of block depth, or dst_copy_extent+offset depth must equal subresource depth
2365 uint32_t copy_depth = (slice_override ? depth_slices : dst_copy_extent.depth);
2366 if ((SafeModulo(copy_depth, block_size.depth) != 0) && (copy_depth + region.dstOffset.z != mip_extent.depth)) {
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06002367 const char *vuid = ext_ycbcr ? "VUID-VkImageCopy-dstImage-01734" : "VUID-VkImageCopy-extent-00165";
Dave Houltona9df0ce2018-02-07 10:51:23 -07002368 skip |=
2369 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltonc991cc92018-03-06 11:08:51 -07002370 HandleToUint64(dst_state->image), vuid,
Dave Houltona9df0ce2018-02-07 10:51:23 -07002371 "vkCmdCopyImage(): pRegion[%d] dst_copy_extent width (%d) must be a multiple of the compressed texture "
Dave Houltonc991cc92018-03-06 11:08:51 -07002372 "block depth (%d), or when added to dstOffset.z (%d) must equal the image subresource depth (%d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002373 i, dst_copy_extent.depth, block_size.depth, region.dstOffset.z, mip_extent.depth);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002374 }
2375 } // Compressed
2376 }
2377 return skip;
2378}
2379
Dave Houltonc991cc92018-03-06 11:08:51 -07002380// vkCmdCopyImage checks that only apply if the multiplane extension is enabled
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002381bool CoreChecks::CopyImageMultiplaneValidation(const layer_data *dev_data, VkCommandBuffer command_buffer,
2382 const IMAGE_STATE *src_image_state, const IMAGE_STATE *dst_image_state,
2383 const VkImageCopy region) {
Dave Houltonc991cc92018-03-06 11:08:51 -07002384 bool skip = false;
Dave Houltonc991cc92018-03-06 11:08:51 -07002385
2386 // Neither image is multiplane
2387 if ((!FormatIsMultiplane(src_image_state->createInfo.format)) && (!FormatIsMultiplane(dst_image_state->createInfo.format))) {
2388 // If neither image is multi-plane the aspectMask member of src and dst must match
2389 if (region.srcSubresource.aspectMask != region.dstSubresource.aspectMask) {
2390 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00002391 ss << "vkCmdCopyImage(): Copy between non-multiplane images with differing aspectMasks ( 0x" << std::hex
Dave Houltonc991cc92018-03-06 11:08:51 -07002392 << region.srcSubresource.aspectMask << " and 0x" << region.dstSubresource.aspectMask << " )";
2393 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002394 HandleToUint64(command_buffer), "VUID-VkImageCopy-srcImage-01551", "%s.", ss.str().c_str());
Dave Houltonc991cc92018-03-06 11:08:51 -07002395 }
2396 } else {
2397 // Source image multiplane checks
2398 uint32_t planes = FormatPlaneCount(src_image_state->createInfo.format);
2399 VkImageAspectFlags aspect = region.srcSubresource.aspectMask;
2400 if ((2 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT_KHR) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT_KHR)) {
2401 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00002402 ss << "vkCmdCopyImage(): Source image aspect mask (0x" << std::hex << aspect << ") is invalid for 2-plane format";
Dave Houltonc991cc92018-03-06 11:08:51 -07002403 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002404 HandleToUint64(command_buffer), "VUID-VkImageCopy-srcImage-01552", "%s.", ss.str().c_str());
Dave Houltonc991cc92018-03-06 11:08:51 -07002405 }
2406 if ((3 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT_KHR) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT_KHR) &&
2407 (aspect != VK_IMAGE_ASPECT_PLANE_2_BIT_KHR)) {
2408 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00002409 ss << "vkCmdCopyImage(): Source image aspect mask (0x" << std::hex << aspect << ") is invalid for 3-plane format";
Dave Houltonc991cc92018-03-06 11:08:51 -07002410 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002411 HandleToUint64(command_buffer), "VUID-VkImageCopy-srcImage-01553", "%s.", ss.str().c_str());
Dave Houltonc991cc92018-03-06 11:08:51 -07002412 }
2413 // Single-plane to multi-plane
2414 if ((!FormatIsMultiplane(src_image_state->createInfo.format)) && (FormatIsMultiplane(dst_image_state->createInfo.format)) &&
2415 (VK_IMAGE_ASPECT_COLOR_BIT != aspect)) {
2416 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00002417 ss << "vkCmdCopyImage(): Source image aspect mask (0x" << std::hex << aspect << ") is not VK_IMAGE_ASPECT_COLOR_BIT";
Dave Houltonc991cc92018-03-06 11:08:51 -07002418 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002419 HandleToUint64(command_buffer), "VUID-VkImageCopy-dstImage-01557", "%s.", ss.str().c_str());
Dave Houltonc991cc92018-03-06 11:08:51 -07002420 }
2421
2422 // Dest image multiplane checks
2423 planes = FormatPlaneCount(dst_image_state->createInfo.format);
2424 aspect = region.dstSubresource.aspectMask;
2425 if ((2 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT_KHR) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT_KHR)) {
2426 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00002427 ss << "vkCmdCopyImage(): Dest image aspect mask (0x" << std::hex << aspect << ") is invalid for 2-plane format";
Dave Houltonc991cc92018-03-06 11:08:51 -07002428 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002429 HandleToUint64(command_buffer), "VUID-VkImageCopy-dstImage-01554", "%s.", ss.str().c_str());
Dave Houltonc991cc92018-03-06 11:08:51 -07002430 }
2431 if ((3 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT_KHR) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT_KHR) &&
2432 (aspect != VK_IMAGE_ASPECT_PLANE_2_BIT_KHR)) {
2433 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00002434 ss << "vkCmdCopyImage(): Dest image aspect mask (0x" << std::hex << aspect << ") is invalid for 3-plane format";
Dave Houltonc991cc92018-03-06 11:08:51 -07002435 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002436 HandleToUint64(command_buffer), "VUID-VkImageCopy-dstImage-01555", "%s.", ss.str().c_str());
Dave Houltonc991cc92018-03-06 11:08:51 -07002437 }
2438 // Multi-plane to single-plane
2439 if ((FormatIsMultiplane(src_image_state->createInfo.format)) && (!FormatIsMultiplane(dst_image_state->createInfo.format)) &&
2440 (VK_IMAGE_ASPECT_COLOR_BIT != aspect)) {
2441 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00002442 ss << "vkCmdCopyImage(): Dest image aspect mask (0x" << std::hex << aspect << ") is not VK_IMAGE_ASPECT_COLOR_BIT";
Dave Houltonc991cc92018-03-06 11:08:51 -07002443 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002444 HandleToUint64(command_buffer), "VUID-VkImageCopy-srcImage-01556", "%s.", ss.str().c_str());
Dave Houltonc991cc92018-03-06 11:08:51 -07002445 }
2446 }
2447
2448 return skip;
2449}
2450
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002451bool CoreChecks::PreCallValidateCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
2452 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
2453 const VkImageCopy *pRegions) {
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07002454 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07002455 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07002456 auto src_image_state = GetImageState(srcImage);
2457 auto dst_image_state = GetImageState(dstImage);
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002458 bool skip = false;
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07002459
2460 skip = ValidateImageCopyData(device_data, report_data, regionCount, pRegions, src_image_state, dst_image_state);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002461
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002462 VkCommandBuffer command_buffer = cb_node->commandBuffer;
2463
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07002464 for (uint32_t i = 0; i < regionCount; i++) {
2465 const VkImageCopy region = pRegions[i];
Dave Houltonee281a52017-12-08 13:51:02 -07002466
2467 // For comp/uncomp copies, the copy extent for the dest image must be adjusted
2468 VkExtent3D src_copy_extent = region.extent;
2469 VkExtent3D dst_copy_extent =
2470 GetAdjustedDestImageExtent(src_image_state->createInfo.format, dst_image_state->createInfo.format, region.extent);
2471
Dave Houlton6f9059e2017-05-02 17:15:13 -06002472 bool slice_override = false;
2473 uint32_t depth_slices = 0;
2474
2475 // Special case for copying between a 1D/2D array and a 3D image
2476 // TBD: This seems like the only way to reconcile 3 mutually-exclusive VU checks for 2D/3D copies. Heads up.
2477 if ((VK_IMAGE_TYPE_3D == src_image_state->createInfo.imageType) &&
2478 (VK_IMAGE_TYPE_3D != dst_image_state->createInfo.imageType)) {
Dave Houltonee281a52017-12-08 13:51:02 -07002479 depth_slices = region.dstSubresource.layerCount; // Slice count from 2D subresource
Dave Houlton6f9059e2017-05-02 17:15:13 -06002480 slice_override = (depth_slices != 1);
2481 } else if ((VK_IMAGE_TYPE_3D == dst_image_state->createInfo.imageType) &&
2482 (VK_IMAGE_TYPE_3D != src_image_state->createInfo.imageType)) {
Dave Houltonee281a52017-12-08 13:51:02 -07002483 depth_slices = region.srcSubresource.layerCount; // Slice count from 2D subresource
Dave Houlton6f9059e2017-05-02 17:15:13 -06002484 slice_override = (depth_slices != 1);
2485 }
2486
Cort Strattond619a302018-05-17 19:46:32 -07002487 skip |= ValidateImageSubresourceLayers(device_data, cb_node, &region.srcSubresource, "vkCmdCopyImage", "srcSubresource", i);
2488 skip |= ValidateImageSubresourceLayers(device_data, cb_node, &region.dstSubresource, "vkCmdCopyImage", "dstSubresource", i);
Cort Strattonff1542a2018-05-27 10:49:28 -07002489 skip |= ValidateImageMipLevel(device_data, cb_node, src_image_state, region.srcSubresource.mipLevel, i, "vkCmdCopyImage",
2490 "srcSubresource", "VUID-vkCmdCopyImage-srcSubresource-01696");
2491 skip |= ValidateImageMipLevel(device_data, cb_node, dst_image_state, region.dstSubresource.mipLevel, i, "vkCmdCopyImage",
2492 "dstSubresource", "VUID-vkCmdCopyImage-dstSubresource-01697");
2493 skip |= ValidateImageArrayLayerRange(device_data, cb_node, src_image_state, region.srcSubresource.baseArrayLayer,
2494 region.srcSubresource.layerCount, i, "vkCmdCopyImage", "srcSubresource",
2495 "VUID-vkCmdCopyImage-srcSubresource-01698");
2496 skip |= ValidateImageArrayLayerRange(device_data, cb_node, dst_image_state, region.dstSubresource.baseArrayLayer,
2497 region.dstSubresource.layerCount, i, "vkCmdCopyImage", "dstSubresource",
2498 "VUID-vkCmdCopyImage-dstSubresource-01699");
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002499
Mark Lobodzinski60e79032019-03-07 10:22:31 -07002500 if (GetDeviceExtensions()->vk_khr_maintenance1) {
Dave Houlton6f9059e2017-05-02 17:15:13 -06002501 // No chance of mismatch if we're overriding depth slice count
2502 if (!slice_override) {
2503 // The number of depth slices in srcSubresource and dstSubresource must match
2504 // Depth comes from layerCount for 1D,2D resources, from extent.depth for 3D
2505 uint32_t src_slices =
Dave Houltonee281a52017-12-08 13:51:02 -07002506 (VK_IMAGE_TYPE_3D == src_image_state->createInfo.imageType ? src_copy_extent.depth
2507 : region.srcSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002508 uint32_t dst_slices =
Dave Houltonee281a52017-12-08 13:51:02 -07002509 (VK_IMAGE_TYPE_3D == dst_image_state->createInfo.imageType ? dst_copy_extent.depth
2510 : region.dstSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002511 if (src_slices != dst_slices) {
2512 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00002513 ss << "vkCmdCopyImage(): number of depth slices in source and destination subresources for pRegions[" << i
Dave Houlton6f9059e2017-05-02 17:15:13 -06002514 << "] do not match";
2515 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002516 HandleToUint64(command_buffer), "VUID-VkImageCopy-extent-00140", "%s.", ss.str().c_str());
Dave Houlton6f9059e2017-05-02 17:15:13 -06002517 }
2518 }
2519 } else {
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002520 // For each region the layerCount member of srcSubresource and dstSubresource must match
Dave Houltonee281a52017-12-08 13:51:02 -07002521 if (region.srcSubresource.layerCount != region.dstSubresource.layerCount) {
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002522 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00002523 ss << "vkCmdCopyImage(): number of layers in source and destination subresources for pRegions[" << i
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002524 << "] do not match";
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06002525 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002526 HandleToUint64(command_buffer), "VUID-VkImageCopy-extent-00140", "%s.", ss.str().c_str());
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002527 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002528 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002529
Dave Houltonc991cc92018-03-06 11:08:51 -07002530 // Do multiplane-specific checks, if extension enabled
Mark Lobodzinski60e79032019-03-07 10:22:31 -07002531 if (GetDeviceExtensions()->vk_khr_sampler_ycbcr_conversion) {
Dave Houltonc991cc92018-03-06 11:08:51 -07002532 skip |= CopyImageMultiplaneValidation(device_data, command_buffer, src_image_state, dst_image_state, region);
2533 }
2534
Mark Lobodzinski60e79032019-03-07 10:22:31 -07002535 if (!GetDeviceExtensions()->vk_khr_sampler_ycbcr_conversion) {
Dave Houltonf5217612018-02-02 16:18:52 -07002536 // not multi-plane, the aspectMask member of srcSubresource and dstSubresource must match
2537 if (region.srcSubresource.aspectMask != region.dstSubresource.aspectMask) {
Graeme Leese79b60cb2018-11-28 11:51:20 +00002538 char const str[] = "vkCmdCopyImage(): Src and dest aspectMasks for each region must match";
Dave Houltonf5217612018-02-02 16:18:52 -07002539 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002540 HandleToUint64(command_buffer), "VUID-VkImageCopy-aspectMask-00137", "%s.", str);
Dave Houltonf5217612018-02-02 16:18:52 -07002541 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002542 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002543
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06002544 // For each region, the aspectMask member of srcSubresource must be present in the source image
Dave Houltonee281a52017-12-08 13:51:02 -07002545 if (!VerifyAspectsPresent(region.srcSubresource.aspectMask, src_image_state->createInfo.format)) {
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06002546 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00002547 ss << "vkCmdCopyImage(): pRegion[" << i
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06002548 << "] srcSubresource.aspectMask cannot specify aspects not present in source image";
2549 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002550 HandleToUint64(command_buffer), "VUID-VkImageCopy-aspectMask-00142", "%s.", ss.str().c_str());
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06002551 }
2552
2553 // For each region, the aspectMask member of dstSubresource must be present in the destination image
Dave Houltonee281a52017-12-08 13:51:02 -07002554 if (!VerifyAspectsPresent(region.dstSubresource.aspectMask, dst_image_state->createInfo.format)) {
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06002555 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00002556 ss << "vkCmdCopyImage(): pRegion[" << i
2557 << "] dstSubresource.aspectMask cannot specify aspects not present in dest image";
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06002558 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002559 HandleToUint64(command_buffer), "VUID-VkImageCopy-aspectMask-00143", "%s.", ss.str().c_str());
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06002560 }
2561
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002562 // Check region extents for 1D-1D, 2D-2D, and 3D-3D copies
2563 if (src_image_state->createInfo.imageType == dst_image_state->createInfo.imageType) {
2564 // The source region specified by a given element of regions must be a region that is contained within srcImage
Dave Houltonee281a52017-12-08 13:51:02 -07002565 VkExtent3D img_extent = GetImageSubresourceExtent(src_image_state, &(region.srcSubresource));
2566 if (0 != ExceedsBounds(&region.srcOffset, &src_copy_extent, &img_extent)) {
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002567 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00002568 ss << "vkCmdCopyImage(): Source pRegion[" << i << "] with mipLevel [ " << region.srcSubresource.mipLevel
Dave Houltonee281a52017-12-08 13:51:02 -07002569 << " ], offset [ " << region.srcOffset.x << ", " << region.srcOffset.y << ", " << region.srcOffset.z
2570 << " ], extent [ " << src_copy_extent.width << ", " << src_copy_extent.height << ", " << src_copy_extent.depth
2571 << " ] exceeds the source image dimensions";
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06002572 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002573 HandleToUint64(command_buffer), "VUID-vkCmdCopyImage-pRegions-00122", "%s.", ss.str().c_str());
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002574 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002575
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002576 // The destination region specified by a given element of regions must be a region that is contained within dst_image
Dave Houltonee281a52017-12-08 13:51:02 -07002577 img_extent = GetImageSubresourceExtent(dst_image_state, &(region.dstSubresource));
2578 if (0 != ExceedsBounds(&region.dstOffset, &dst_copy_extent, &img_extent)) {
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002579 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00002580 ss << "vkCmdCopyImage(): Dest pRegion[" << i << "] with mipLevel [ " << region.dstSubresource.mipLevel
Dave Houltonee281a52017-12-08 13:51:02 -07002581 << " ], offset [ " << region.dstOffset.x << ", " << region.dstOffset.y << ", " << region.dstOffset.z
2582 << " ], extent [ " << dst_copy_extent.width << ", " << dst_copy_extent.height << ", " << dst_copy_extent.depth
2583 << " ] exceeds the destination image dimensions";
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06002584 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002585 HandleToUint64(command_buffer), "VUID-vkCmdCopyImage-pRegions-00123", "%s.", ss.str().c_str());
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002586 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002587 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002588
Dave Houltonfc1a4052017-04-27 14:32:45 -06002589 // Each dimension offset + extent limits must fall with image subresource extent
Dave Houltonee281a52017-12-08 13:51:02 -07002590 VkExtent3D subresource_extent = GetImageSubresourceExtent(src_image_state, &(region.srcSubresource));
2591 if (slice_override) src_copy_extent.depth = depth_slices;
2592 uint32_t extent_check = ExceedsBounds(&(region.srcOffset), &src_copy_extent, &subresource_extent);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002593 if (extent_check & x_bit) {
Graeme Leese79b60cb2018-11-28 11:51:20 +00002594 skip |=
2595 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2596 HandleToUint64(command_buffer), "VUID-VkImageCopy-srcOffset-00144",
2597 "vkCmdCopyImage(): Source image pRegion %1d x-dimension offset [%1d] + extent [%1d] exceeds subResource "
2598 "width [%1d].",
2599 i, region.srcOffset.x, src_copy_extent.width, subresource_extent.width);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002600 }
2601
2602 if (extent_check & y_bit) {
Graeme Leese79b60cb2018-11-28 11:51:20 +00002603 skip |=
2604 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2605 HandleToUint64(command_buffer), "VUID-VkImageCopy-srcOffset-00145",
2606 "vkCmdCopyImage(): Source image pRegion %1d y-dimension offset [%1d] + extent [%1d] exceeds subResource "
2607 "height [%1d].",
2608 i, region.srcOffset.y, src_copy_extent.height, subresource_extent.height);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002609 }
2610 if (extent_check & z_bit) {
Graeme Leese79b60cb2018-11-28 11:51:20 +00002611 skip |=
2612 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2613 HandleToUint64(command_buffer), "VUID-VkImageCopy-srcOffset-00147",
2614 "vkCmdCopyImage(): Source image pRegion %1d z-dimension offset [%1d] + extent [%1d] exceeds subResource "
2615 "depth [%1d].",
2616 i, region.srcOffset.z, src_copy_extent.depth, subresource_extent.depth);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002617 }
2618
Dave Houltonee281a52017-12-08 13:51:02 -07002619 // Adjust dest extent if necessary
2620 subresource_extent = GetImageSubresourceExtent(dst_image_state, &(region.dstSubresource));
2621 if (slice_override) dst_copy_extent.depth = depth_slices;
2622
2623 extent_check = ExceedsBounds(&(region.dstOffset), &dst_copy_extent, &subresource_extent);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002624 if (extent_check & x_bit) {
2625 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002626 HandleToUint64(command_buffer), "VUID-VkImageCopy-dstOffset-00150",
Graeme Leese79b60cb2018-11-28 11:51:20 +00002627 "vkCmdCopyImage(): Dest image pRegion %1d x-dimension offset [%1d] + extent [%1d] exceeds subResource "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002628 "width [%1d].",
2629 i, region.dstOffset.x, dst_copy_extent.width, subresource_extent.width);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002630 }
2631 if (extent_check & y_bit) {
2632 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002633 HandleToUint64(command_buffer), "VUID-VkImageCopy-dstOffset-00151",
Graeme Leese79b60cb2018-11-28 11:51:20 +00002634 "vkCmdCopyImage(): Dest image pRegion %1d y-dimension offset [%1d] + extent [%1d] exceeds subResource "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002635 "height [%1d].",
2636 i, region.dstOffset.y, dst_copy_extent.height, subresource_extent.height);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002637 }
2638 if (extent_check & z_bit) {
2639 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002640 HandleToUint64(command_buffer), "VUID-VkImageCopy-dstOffset-00153",
Graeme Leese79b60cb2018-11-28 11:51:20 +00002641 "vkCmdCopyImage(): Dest image pRegion %1d z-dimension offset [%1d] + extent [%1d] exceeds subResource "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002642 "depth [%1d].",
2643 i, region.dstOffset.z, dst_copy_extent.depth, subresource_extent.depth);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002644 }
2645
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002646 // The union of all source regions, and the union of all destination regions, specified by the elements of regions,
2647 // must not overlap in memory
2648 if (src_image_state->image == dst_image_state->image) {
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07002649 for (uint32_t j = 0; j < regionCount; j++) {
2650 if (RegionIntersects(&region, &pRegions[j], src_image_state->createInfo.imageType,
Dave Houltonf5217612018-02-02 16:18:52 -07002651 FormatIsMultiplane(src_image_state->createInfo.format))) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002652 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00002653 ss << "vkCmdCopyImage(): pRegions[" << i << "] src overlaps with pRegions[" << j << "].";
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002654 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002655 HandleToUint64(command_buffer), "VUID-vkCmdCopyImage-pRegions-00124", "%s.", ss.str().c_str());
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002656 }
2657 }
2658 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002659 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002660
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002661 // The formats of src_image and dst_image must be compatible. Formats are considered compatible if their texel size in bytes
2662 // is the same between both formats. For example, VK_FORMAT_R8G8B8A8_UNORM is compatible with VK_FORMAT_R32_UINT because
2663 // because both texels are 4 bytes in size. Depth/stencil formats must match exactly.
Dave Houlton1150cf52017-04-27 14:38:11 -06002664 if (FormatIsDepthOrStencil(src_image_state->createInfo.format) || FormatIsDepthOrStencil(dst_image_state->createInfo.format)) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002665 if (src_image_state->createInfo.format != dst_image_state->createInfo.format) {
2666 char const str[] = "vkCmdCopyImage called with unmatched source and dest image depth/stencil formats.";
Petr Krausbc7f5442017-05-14 23:43:38 +02002667 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton51653902018-06-22 17:32:13 -06002668 HandleToUint64(command_buffer), kVUID_Core_DrawState_MismatchedImageFormat, str);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002669 }
2670 } else {
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07002671 if (!FormatSizesAreEqual(src_image_state->createInfo.format, dst_image_state->createInfo.format, regionCount, pRegions)) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002672 char const str[] = "vkCmdCopyImage called with unmatched source and dest image format sizes.";
2673 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002674 HandleToUint64(command_buffer), "VUID-vkCmdCopyImage-srcImage-00135", "%s.", str);
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002675 }
2676 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002677
Dave Houlton33c22b72017-02-28 13:16:02 -07002678 // Source and dest image sample counts must match
2679 if (src_image_state->createInfo.samples != dst_image_state->createInfo.samples) {
2680 char const str[] = "vkCmdCopyImage() called on image pair with non-identical sample counts.";
2681 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002682 HandleToUint64(command_buffer), "VUID-vkCmdCopyImage-srcImage-00136", "%s", str);
Dave Houlton33c22b72017-02-28 13:16:02 -07002683 }
2684
Dave Houltond8ed0212018-05-16 17:18:24 -06002685 skip |= ValidateMemoryIsBoundToImage(device_data, src_image_state, "vkCmdCopyImage()", "VUID-vkCmdCopyImage-srcImage-00127");
2686 skip |= ValidateMemoryIsBoundToImage(device_data, dst_image_state, "vkCmdCopyImage()", "VUID-vkCmdCopyImage-dstImage-00132");
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002687 // Validate that SRC & DST images have correct usage flags set
Dave Houltond8ed0212018-05-16 17:18:24 -06002688 skip |= ValidateImageUsageFlags(device_data, src_image_state, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true,
2689 "VUID-vkCmdCopyImage-srcImage-00126", "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
2690 skip |= ValidateImageUsageFlags(device_data, dst_image_state, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true,
2691 "VUID-vkCmdCopyImage-dstImage-00131", "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
Mark Lobodzinski96d5c6e2019-03-07 11:28:21 -07002692 if (GetApiVersion() >= VK_API_VERSION_1_1 || GetDeviceExtensions()->vk_khr_maintenance1) {
Dave Houltond8ed0212018-05-16 17:18:24 -06002693 skip |=
2694 ValidateImageFormatFeatureFlags(device_data, src_image_state, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, "vkCmdCopyImage()",
Shannon McPherson40c0cba2018-08-07 13:39:13 -06002695 "VUID-vkCmdCopyImage-srcImage-01995", "VUID-vkCmdCopyImage-srcImage-01995");
Dave Houltond8ed0212018-05-16 17:18:24 -06002696 skip |=
2697 ValidateImageFormatFeatureFlags(device_data, dst_image_state, VK_FORMAT_FEATURE_TRANSFER_DST_BIT, "vkCmdCopyImage()",
Shannon McPherson40c0cba2018-08-07 13:39:13 -06002698 "VUID-vkCmdCopyImage-dstImage-01996", "VUID-vkCmdCopyImage-dstImage-01996");
Cort Stratton186b1a22018-05-01 20:18:06 -04002699 }
Mike Schuchardt9c582402017-02-23 15:57:37 -07002700 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdCopyImage()",
Dave Houltond8ed0212018-05-16 17:18:24 -06002701 VK_QUEUE_TRANSFER_BIT | VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT,
2702 "VUID-vkCmdCopyImage-commandBuffer-cmdpool");
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002703 skip |= ValidateCmd(device_data, cb_node, CMD_COPYIMAGE, "vkCmdCopyImage()");
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06002704 skip |= InsideRenderPass(device_data, cb_node, "vkCmdCopyImage()", "VUID-vkCmdCopyImage-renderpass");
Tobin Ehlisc8266452017-04-07 12:20:30 -06002705 bool hit_error = false;
Jeff Bolzfdd0d852019-02-03 21:55:12 -06002706 const char *invalid_src_layout_vuid =
Mark Lobodzinski60e79032019-03-07 10:22:31 -07002707 (src_image_state->shared_presentable && GetDeviceExtensions()->vk_khr_shared_presentable_image)
Cort Stratton7df30962018-05-17 19:45:57 -07002708 ? "VUID-vkCmdCopyImage-srcImageLayout-01917"
2709 : "VUID-vkCmdCopyImage-srcImageLayout-00129";
Jeff Bolzfdd0d852019-02-03 21:55:12 -06002710 const char *invalid_dst_layout_vuid =
Mark Lobodzinski60e79032019-03-07 10:22:31 -07002711 (dst_image_state->shared_presentable && GetDeviceExtensions()->vk_khr_shared_presentable_image)
Cort Stratton7df30962018-05-17 19:45:57 -07002712 ? "VUID-vkCmdCopyImage-dstImageLayout-01395"
2713 : "VUID-vkCmdCopyImage-dstImageLayout-00134";
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07002714 for (uint32_t i = 0; i < regionCount; ++i) {
2715 skip |= VerifyImageLayout(device_data, cb_node, src_image_state, pRegions[i].srcSubresource, srcImageLayout,
Cort Stratton7df30962018-05-17 19:45:57 -07002716 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, "vkCmdCopyImage()", invalid_src_layout_vuid,
2717 "VUID-vkCmdCopyImage-srcImageLayout-00128", &hit_error);
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07002718 skip |= VerifyImageLayout(device_data, cb_node, dst_image_state, pRegions[i].dstSubresource, dstImageLayout,
Cort Stratton7df30962018-05-17 19:45:57 -07002719 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, "vkCmdCopyImage()", invalid_dst_layout_vuid,
2720 "VUID-vkCmdCopyImage-dstImageLayout-00133", &hit_error);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002721 skip |= ValidateCopyImageTransferGranularityRequirements(device_data, cb_node, src_image_state, dst_image_state,
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07002722 &pRegions[i], i, "vkCmdCopyImage()");
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002723 }
2724
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002725 return skip;
2726}
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002727
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002728void CoreChecks::PreCallRecordCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
2729 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
2730 const VkImageCopy *pRegions) {
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07002731 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07002732 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07002733 auto src_image_state = GetImageState(srcImage);
2734 auto dst_image_state = GetImageState(dstImage);
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07002735
Tobin Ehlise35b66a2017-03-15 12:18:31 -06002736 // Make sure that all image slices are updated to correct layout
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07002737 for (uint32_t i = 0; i < regionCount; ++i) {
2738 SetImageLayout(device_data, cb_node, src_image_state, pRegions[i].srcSubresource, srcImageLayout);
2739 SetImageLayout(device_data, cb_node, dst_image_state, pRegions[i].dstSubresource, dstImageLayout);
Tobin Ehlise35b66a2017-03-15 12:18:31 -06002740 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002741 // Update bindings between images and cmd buffer
2742 AddCommandBufferBindingImage(device_data, cb_node, src_image_state);
2743 AddCommandBufferBindingImage(device_data, cb_node, dst_image_state);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002744}
2745
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002746// Returns true if sub_rect is entirely contained within rect
2747static inline bool ContainsRect(VkRect2D rect, VkRect2D sub_rect) {
2748 if ((sub_rect.offset.x < rect.offset.x) || (sub_rect.offset.x + sub_rect.extent.width > rect.offset.x + rect.extent.width) ||
2749 (sub_rect.offset.y < rect.offset.y) || (sub_rect.offset.y + sub_rect.extent.height > rect.offset.y + rect.extent.height))
2750 return false;
2751 return true;
2752}
2753
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002754bool CoreChecks::ValidateClearAttachmentExtent(layer_data *device_data, VkCommandBuffer command_buffer, uint32_t attachment_index,
2755 FRAMEBUFFER_STATE *framebuffer, uint32_t fb_attachment, const VkRect2D &render_area,
2756 uint32_t rect_count, const VkClearRect *clear_rects) {
John Zulauf3a548ef2019-02-01 16:14:07 -07002757 bool skip = false;
John Zulauff2582972019-02-09 14:53:30 -07002758 const IMAGE_VIEW_STATE *image_view_state = nullptr;
2759 if (framebuffer && (fb_attachment != VK_ATTACHMENT_UNUSED) && (fb_attachment < framebuffer->createInfo.attachmentCount)) {
Mark Lobodzinskia3a230b2019-03-06 15:35:13 -07002760 image_view_state = GetImageViewState(framebuffer->createInfo.pAttachments[fb_attachment]);
John Zulauff2582972019-02-09 14:53:30 -07002761 }
John Zulauf3a548ef2019-02-01 16:14:07 -07002762
2763 for (uint32_t j = 0; j < rect_count; j++) {
2764 if (!ContainsRect(render_area, clear_rects[j].rect)) {
2765 skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2766 HandleToUint64(command_buffer), "VUID-vkCmdClearAttachments-pRects-00016",
2767 "vkCmdClearAttachments(): The area defined by pRects[%d] is not contained in the area of "
2768 "the current render pass instance.",
2769 j);
2770 }
2771
2772 if (image_view_state) {
2773 // The layers specified by a given element of pRects must be contained within every attachment that
2774 // pAttachments refers to
2775 const auto attachment_layer_count = image_view_state->create_info.subresourceRange.layerCount;
2776 if ((clear_rects[j].baseArrayLayer >= attachment_layer_count) ||
2777 (clear_rects[j].baseArrayLayer + clear_rects[j].layerCount > attachment_layer_count)) {
2778 skip |=
2779 log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2780 HandleToUint64(command_buffer), "VUID-vkCmdClearAttachments-pRects-00017",
2781 "vkCmdClearAttachments(): The layers defined in pRects[%d] are not contained in the layers "
2782 "of pAttachment[%d].",
2783 j, attachment_index);
2784 }
2785 }
2786 }
2787 return skip;
2788}
2789
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002790bool CoreChecks::PreCallValidateCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
2791 const VkClearAttachment *pAttachments, uint32_t rectCount,
2792 const VkClearRect *pRects) {
Mark Lobodzinskidd995d22019-01-11 11:05:15 -07002793 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
2794
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07002795 GLOBAL_CB_NODE *cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002796
2797 bool skip = false;
2798 if (cb_node) {
Tobin Ehlis3c37fb32017-05-24 09:31:13 -06002799 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdClearAttachments()", VK_QUEUE_GRAPHICS_BIT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002800 "VUID-vkCmdClearAttachments-commandBuffer-cmdpool");
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002801 skip |= ValidateCmd(device_data, cb_node, CMD_CLEARATTACHMENTS, "vkCmdClearAttachments()");
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002802 // Warn if this is issued prior to Draw Cmd and clearing the entire attachment
Chris Forbes05375e72017-04-21 13:15:15 -07002803 if (!cb_node->hasDrawCmd && (cb_node->activeRenderPassBeginInfo.renderArea.extent.width == pRects[0].rect.extent.width) &&
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002804 (cb_node->activeRenderPassBeginInfo.renderArea.extent.height == pRects[0].rect.extent.height)) {
2805 // There are times where app needs to use ClearAttachments (generally when reusing a buffer inside of a render pass)
Mark Lobodzinskid833bb72017-02-22 10:55:30 -07002806 // This warning should be made more specific. It'd be best to avoid triggering this test if it's a use that must call
2807 // CmdClearAttachments.
Lockee9aeebf2019-03-03 23:50:08 -07002808 skip |=
2809 log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2810 HandleToUint64(commandBuffer), kVUID_Core_DrawState_ClearCmdBeforeDraw,
2811 "vkCmdClearAttachments() issued on command buffer object %s prior to any Draw Cmds. It is recommended you "
2812 "use RenderPass LOAD_OP_CLEAR on Attachments prior to any Draw.",
2813 report_data->FormatHandle(commandBuffer).c_str());
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002814 }
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06002815 skip |= OutsideRenderPass(device_data, cb_node, "vkCmdClearAttachments()", "VUID-vkCmdClearAttachments-renderpass");
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002816 }
2817
2818 // Validate that attachment is in reference list of active subpass
2819 if (cb_node->activeRenderPass) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01002820 const VkRenderPassCreateInfo2KHR *renderpass_create_info = cb_node->activeRenderPass->createInfo.ptr();
John Zulauff2582972019-02-09 14:53:30 -07002821 const uint32_t renderpass_attachment_count = renderpass_create_info->attachmentCount;
Tobias Hectorbbb12282018-10-22 15:17:59 +01002822 const VkSubpassDescription2KHR *subpass_desc = &renderpass_create_info->pSubpasses[cb_node->activeSubpass];
Mark Lobodzinski74772ca2019-03-06 16:15:06 -07002823 auto framebuffer = GetFramebufferState(cb_node->activeFramebuffer);
John Zulauf3a548ef2019-02-01 16:14:07 -07002824 const auto &render_area = cb_node->activeRenderPassBeginInfo.renderArea;
2825 std::shared_ptr<std::vector<VkClearRect>> clear_rect_copy;
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002826
John Zulauf3a548ef2019-02-01 16:14:07 -07002827 for (uint32_t attachment_index = 0; attachment_index < attachmentCount; attachment_index++) {
2828 auto clear_desc = &pAttachments[attachment_index];
2829 uint32_t fb_attachment = VK_ATTACHMENT_UNUSED;
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002830
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002831 if (0 == clear_desc->aspectMask) {
2832 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002833 HandleToUint64(commandBuffer), "VUID-VkClearAttachment-aspectMask-requiredbitmask", " ");
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002834 } else if (clear_desc->aspectMask & VK_IMAGE_ASPECT_METADATA_BIT) {
2835 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002836 HandleToUint64(commandBuffer), "VUID-VkClearAttachment-aspectMask-00020", " ");
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002837 } else if (clear_desc->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) {
John Zulauff2582972019-02-09 14:53:30 -07002838 uint32_t color_attachment = VK_ATTACHMENT_UNUSED;
2839 if (clear_desc->colorAttachment < subpass_desc->colorAttachmentCount) {
2840 color_attachment = subpass_desc->pColorAttachments[clear_desc->colorAttachment].attachment;
2841 if ((color_attachment != VK_ATTACHMENT_UNUSED) && (color_attachment >= renderpass_attachment_count)) {
Lockee9aeebf2019-03-03 23:50:08 -07002842 skip |= log_msg(
2843 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2844 HandleToUint64(commandBuffer), "VUID-vkCmdClearAttachments-aspectMask-02501",
2845 "vkCmdClearAttachments() pAttachments[%u].colorAttachment=%u is not VK_ATTACHMENT_UNUSED "
2846 "and not a valid attachment for render pass %s attachmentCount=%u. Subpass %u pColorAttachment[%u]=%u.",
2847 attachment_index, clear_desc->colorAttachment,
2848 report_data->FormatHandle(cb_node->activeRenderPass->renderPass).c_str(), cb_node->activeSubpass,
2849 clear_desc->colorAttachment, color_attachment, renderpass_attachment_count);
2850
John Zulauff2582972019-02-09 14:53:30 -07002851 color_attachment = VK_ATTACHMENT_UNUSED; // Defensive, prevent lookup past end of renderpass attachment
2852 }
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002853 } else {
Lockee9aeebf2019-03-03 23:50:08 -07002854 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2855 HandleToUint64(commandBuffer), "VUID-vkCmdClearAttachments-aspectMask-02501",
2856 "vkCmdClearAttachments() pAttachments[%u].colorAttachment=%u out of range for render pass %s"
2857 " subpass %u. colorAttachmentCount=%u",
2858 attachment_index, clear_desc->colorAttachment,
2859 report_data->FormatHandle(cb_node->activeRenderPass->renderPass).c_str(),
2860 cb_node->activeSubpass, subpass_desc->colorAttachmentCount);
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002861 }
John Zulauff2582972019-02-09 14:53:30 -07002862 fb_attachment = color_attachment;
2863
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002864 if ((clear_desc->aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) ||
2865 (clear_desc->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT)) {
2866 char const str[] =
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002867 "vkCmdClearAttachments() aspectMask [%d] must set only VK_IMAGE_ASPECT_COLOR_BIT of a color attachment.";
John Zulauf3a548ef2019-02-01 16:14:07 -07002868 skip |=
2869 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2870 HandleToUint64(commandBuffer), "VUID-VkClearAttachment-aspectMask-00019", str, attachment_index);
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002871 }
2872 } else { // Must be depth and/or stencil
2873 if (((clear_desc->aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) &&
2874 ((clear_desc->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT)) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002875 char const str[] = "vkCmdClearAttachments() aspectMask [%d] is not a valid combination of bits.";
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002876 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
John Zulauf3a548ef2019-02-01 16:14:07 -07002877 HandleToUint64(commandBuffer), "VUID-VkClearAttachment-aspectMask-parameter", str,
2878 attachment_index);
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002879 }
2880 if (!subpass_desc->pDepthStencilAttachment ||
2881 (subpass_desc->pDepthStencilAttachment->attachment == VK_ATTACHMENT_UNUSED)) {
2882 skip |= log_msg(
2883 report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton51653902018-06-22 17:32:13 -06002884 HandleToUint64(commandBuffer), kVUID_Core_DrawState_MissingAttachmentReference,
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002885 "vkCmdClearAttachments() depth/stencil clear with no depth/stencil attachment in subpass; ignored");
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002886 } else {
John Zulauf3a548ef2019-02-01 16:14:07 -07002887 fb_attachment = subpass_desc->pDepthStencilAttachment->attachment;
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002888 }
2889 }
John Zulauf3a548ef2019-02-01 16:14:07 -07002890 if (cb_node->createInfo.level == VK_COMMAND_BUFFER_LEVEL_PRIMARY) {
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002891 skip |= ValidateClearAttachmentExtent(device_data, commandBuffer, attachment_index, framebuffer, fb_attachment,
2892 render_area, rectCount, pRects);
John Zulauf3a548ef2019-02-01 16:14:07 -07002893 } else {
2894 // if a secondary level command buffer inherits the framebuffer from the primary command buffer
2895 // (see VkCommandBufferInheritanceInfo), this validation must be deferred until queue submit time
2896 if (!clear_rect_copy) {
2897 // We need a copy of the clear rectangles that will persist until the last lambda executes
2898 // but we want to create it as lazily as possible
2899 clear_rect_copy.reset(new std::vector<VkClearRect>(pRects, pRects + rectCount));
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002900 }
John Zulauf3a548ef2019-02-01 16:14:07 -07002901
2902 auto val_fn = [device_data, commandBuffer, attachment_index, fb_attachment, rectCount, clear_rect_copy](
2903 GLOBAL_CB_NODE *prim_cb, VkFramebuffer fb) {
2904 assert(rectCount == clear_rect_copy->size());
Mark Lobodzinski74772ca2019-03-06 16:15:06 -07002905 FRAMEBUFFER_STATE *framebuffer = device_data->GetFramebufferState(fb);
John Zulauf3a548ef2019-02-01 16:14:07 -07002906 const auto &render_area = prim_cb->activeRenderPassBeginInfo.renderArea;
2907 bool skip = false;
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002908 skip =
2909 device_data->ValidateClearAttachmentExtent(device_data, commandBuffer, attachment_index, framebuffer,
2910 fb_attachment, render_area, rectCount, clear_rect_copy->data());
John Zulauf3a548ef2019-02-01 16:14:07 -07002911 return skip;
2912 };
2913 cb_node->cmd_execute_commands_functions.emplace_back(val_fn);
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002914 }
2915 }
2916 }
2917 return skip;
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002918}
2919
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002920bool CoreChecks::PreCallValidateCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
2921 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
2922 const VkImageResolve *pRegions) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07002923 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07002924 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07002925 auto src_image_state = GetImageState(srcImage);
2926 auto dst_image_state = GetImageState(dstImage);
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07002927
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002928 bool skip = false;
2929 if (cb_node && src_image_state && dst_image_state) {
Dave Houltond8ed0212018-05-16 17:18:24 -06002930 skip |= ValidateMemoryIsBoundToImage(device_data, src_image_state, "vkCmdResolveImage()",
2931 "VUID-vkCmdResolveImage-srcImage-00256");
2932 skip |= ValidateMemoryIsBoundToImage(device_data, dst_image_state, "vkCmdResolveImage()",
2933 "VUID-vkCmdResolveImage-dstImage-00258");
2934 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdResolveImage()", VK_QUEUE_GRAPHICS_BIT,
2935 "VUID-vkCmdResolveImage-commandBuffer-cmdpool");
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002936 skip |= ValidateCmd(device_data, cb_node, CMD_RESOLVEIMAGE, "vkCmdResolveImage()");
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06002937 skip |= InsideRenderPass(device_data, cb_node, "vkCmdResolveImage()", "VUID-vkCmdResolveImage-renderpass");
Cort Stratton186b1a22018-05-01 20:18:06 -04002938 skip |= ValidateImageFormatFeatureFlags(device_data, dst_image_state, VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
Shannon McPherson40c0cba2018-08-07 13:39:13 -06002939 "vkCmdResolveImage()", "VUID-vkCmdResolveImage-dstImage-02003",
2940 "VUID-vkCmdResolveImage-dstImage-02003");
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002941
Cort Stratton7df30962018-05-17 19:45:57 -07002942 bool hit_error = false;
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002943 const char *invalid_src_layout_vuid =
Mark Lobodzinski60e79032019-03-07 10:22:31 -07002944 (src_image_state->shared_presentable && GetDeviceExtensions()->vk_khr_shared_presentable_image)
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002945 ? "VUID-vkCmdResolveImage-srcImageLayout-01400"
2946 : "VUID-vkCmdResolveImage-srcImageLayout-00261";
2947 const char *invalid_dst_layout_vuid =
Mark Lobodzinski60e79032019-03-07 10:22:31 -07002948 (dst_image_state->shared_presentable && GetDeviceExtensions()->vk_khr_shared_presentable_image)
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002949 ? "VUID-vkCmdResolveImage-dstImageLayout-01401"
2950 : "VUID-vkCmdResolveImage-dstImageLayout-00263";
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002951 // For each region, the number of layers in the image subresource should not be zero
2952 // For each region, src and dest image aspect must be color only
2953 for (uint32_t i = 0; i < regionCount; i++) {
Cort Strattond619a302018-05-17 19:46:32 -07002954 skip |= ValidateImageSubresourceLayers(device_data, cb_node, &pRegions[i].srcSubresource, "vkCmdResolveImage()",
2955 "srcSubresource", i);
2956 skip |= ValidateImageSubresourceLayers(device_data, cb_node, &pRegions[i].dstSubresource, "vkCmdResolveImage()",
2957 "dstSubresource", i);
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07002958 skip |= VerifyImageLayout(device_data, cb_node, src_image_state, pRegions[i].srcSubresource, srcImageLayout,
Cort Stratton7df30962018-05-17 19:45:57 -07002959 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, "vkCmdResolveImage()", invalid_src_layout_vuid,
2960 "VUID-vkCmdResolveImage-srcImageLayout-00260", &hit_error);
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07002961 skip |= VerifyImageLayout(device_data, cb_node, dst_image_state, pRegions[i].dstSubresource, dstImageLayout,
Cort Stratton7df30962018-05-17 19:45:57 -07002962 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, "vkCmdResolveImage()", invalid_dst_layout_vuid,
2963 "VUID-vkCmdResolveImage-dstImageLayout-00262", &hit_error);
Cort Strattonff1542a2018-05-27 10:49:28 -07002964 skip |= ValidateImageMipLevel(device_data, cb_node, src_image_state, pRegions[i].srcSubresource.mipLevel, i,
2965 "vkCmdResolveImage()", "srcSubresource", "VUID-vkCmdResolveImage-srcSubresource-01709");
2966 skip |= ValidateImageMipLevel(device_data, cb_node, dst_image_state, pRegions[i].dstSubresource.mipLevel, i,
2967 "vkCmdResolveImage()", "dstSubresource", "VUID-vkCmdResolveImage-dstSubresource-01710");
2968 skip |= ValidateImageArrayLayerRange(device_data, cb_node, src_image_state, pRegions[i].srcSubresource.baseArrayLayer,
2969 pRegions[i].srcSubresource.layerCount, i, "vkCmdResolveImage()", "srcSubresource",
2970 "VUID-vkCmdResolveImage-srcSubresource-01711");
2971 skip |= ValidateImageArrayLayerRange(device_data, cb_node, dst_image_state, pRegions[i].dstSubresource.baseArrayLayer,
2972 pRegions[i].dstSubresource.layerCount, i, "vkCmdResolveImage()", "srcSubresource",
2973 "VUID-vkCmdResolveImage-dstSubresource-01712");
Cort Stratton7df30962018-05-17 19:45:57 -07002974
2975 // layer counts must match
Mark Lobodzinski50fbef12017-02-06 15:31:33 -07002976 if (pRegions[i].srcSubresource.layerCount != pRegions[i].dstSubresource.layerCount) {
2977 skip |= log_msg(
2978 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002979 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageResolve-layerCount-00267",
Graeme Leese79b60cb2018-11-28 11:51:20 +00002980 "vkCmdResolveImage(): layerCount in source and destination subresource of pRegions[%d] does not match.", i);
Mark Lobodzinski50fbef12017-02-06 15:31:33 -07002981 }
Cort Stratton7df30962018-05-17 19:45:57 -07002982 // For each region, src and dest image aspect must be color only
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002983 if ((pRegions[i].srcSubresource.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) ||
2984 (pRegions[i].dstSubresource.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT)) {
2985 char const str[] =
Graeme Leese79b60cb2018-11-28 11:51:20 +00002986 "vkCmdResolveImage(): src and dest aspectMasks for each region must specify only VK_IMAGE_ASPECT_COLOR_BIT";
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002987 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002988 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageResolve-aspectMask-00266", "%s.", str);
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002989 }
2990 }
2991
2992 if (src_image_state->createInfo.format != dst_image_state->createInfo.format) {
2993 char const str[] = "vkCmdResolveImage called with unmatched source and dest formats.";
Mark Lobodzinski50fbef12017-02-06 15:31:33 -07002994 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton51653902018-06-22 17:32:13 -06002995 HandleToUint64(cb_node->commandBuffer), kVUID_Core_DrawState_MismatchedImageFormat, str);
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002996 }
2997 if (src_image_state->createInfo.imageType != dst_image_state->createInfo.imageType) {
2998 char const str[] = "vkCmdResolveImage called with unmatched source and dest image types.";
Mark Lobodzinski50fbef12017-02-06 15:31:33 -07002999 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton51653902018-06-22 17:32:13 -06003000 HandleToUint64(cb_node->commandBuffer), kVUID_Core_DrawState_MismatchedImageType, str);
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07003001 }
3002 if (src_image_state->createInfo.samples == VK_SAMPLE_COUNT_1_BIT) {
3003 char const str[] = "vkCmdResolveImage called with source sample count less than 2.";
3004 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003005 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdResolveImage-srcImage-00257", "%s.", str);
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07003006 }
3007 if (dst_image_state->createInfo.samples != VK_SAMPLE_COUNT_1_BIT) {
3008 char const str[] = "vkCmdResolveImage called with dest sample count greater than 1.";
3009 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003010 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdResolveImage-dstImage-00259", "%s.", str);
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07003011 }
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07003012 } else {
3013 assert(0);
3014 }
3015 return skip;
3016}
3017
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003018void CoreChecks::PreCallRecordCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
3019 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
3020 const VkImageResolve *pRegions) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07003021 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07003022 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07003023 auto src_image_state = GetImageState(srcImage);
3024 auto dst_image_state = GetImageState(dstImage);
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07003025
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07003026 // Update bindings between images and cmd buffer
3027 AddCommandBufferBindingImage(device_data, cb_node, src_image_state);
3028 AddCommandBufferBindingImage(device_data, cb_node, dst_image_state);
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07003029}
3030
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003031bool CoreChecks::PreCallValidateCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
3032 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
3033 const VkImageBlit *pRegions, VkFilter filter) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07003034 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07003035 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07003036 auto src_image_state = GetImageState(srcImage);
3037 auto dst_image_state = GetImageState(dstImage);
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07003038
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07003039 bool skip = false;
John Zulauf5c2750c2018-01-30 15:04:56 -07003040 if (cb_node) {
3041 skip |= ValidateCmd(device_data, cb_node, CMD_BLITIMAGE, "vkCmdBlitImage()");
3042 }
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07003043 if (cb_node && src_image_state && dst_image_state) {
3044 skip |= ValidateImageSampleCount(device_data, src_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdBlitImage(): srcImage",
Dave Houltond8ed0212018-05-16 17:18:24 -06003045 "VUID-vkCmdBlitImage-srcImage-00233");
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07003046 skip |= ValidateImageSampleCount(device_data, dst_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdBlitImage(): dstImage",
Dave Houltond8ed0212018-05-16 17:18:24 -06003047 "VUID-vkCmdBlitImage-dstImage-00234");
3048 skip |=
3049 ValidateMemoryIsBoundToImage(device_data, src_image_state, "vkCmdBlitImage()", "VUID-vkCmdBlitImage-srcImage-00220");
3050 skip |=
3051 ValidateMemoryIsBoundToImage(device_data, dst_image_state, "vkCmdBlitImage()", "VUID-vkCmdBlitImage-dstImage-00225");
3052 skip |=
3053 ValidateImageUsageFlags(device_data, src_image_state, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true,
3054 "VUID-vkCmdBlitImage-srcImage-00219", "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
3055 skip |=
3056 ValidateImageUsageFlags(device_data, dst_image_state, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true,
3057 "VUID-vkCmdBlitImage-dstImage-00224", "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
3058 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdBlitImage()", VK_QUEUE_GRAPHICS_BIT,
3059 "VUID-vkCmdBlitImage-commandBuffer-cmdpool");
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07003060 skip |= ValidateCmd(device_data, cb_node, CMD_BLITIMAGE, "vkCmdBlitImage()");
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06003061 skip |= InsideRenderPass(device_data, cb_node, "vkCmdBlitImage()", "VUID-vkCmdBlitImage-renderpass");
Cort Stratton186b1a22018-05-01 20:18:06 -04003062 skip |= ValidateImageFormatFeatureFlags(device_data, src_image_state, VK_FORMAT_FEATURE_BLIT_SRC_BIT, "vkCmdBlitImage()",
Shannon McPherson40c0cba2018-08-07 13:39:13 -06003063 "VUID-vkCmdBlitImage-srcImage-01999", "VUID-vkCmdBlitImage-srcImage-01999");
Cort Stratton186b1a22018-05-01 20:18:06 -04003064 skip |= ValidateImageFormatFeatureFlags(device_data, dst_image_state, VK_FORMAT_FEATURE_BLIT_DST_BIT, "vkCmdBlitImage()",
Shannon McPherson40c0cba2018-08-07 13:39:13 -06003065 "VUID-vkCmdBlitImage-dstImage-02000", "VUID-vkCmdBlitImage-dstImage-02000");
Cort Stratton186b1a22018-05-01 20:18:06 -04003066
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -06003067 // TODO: Need to validate image layouts, which will include layout validation for shared presentable images
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07003068
Dave Houlton33c2d252017-06-09 17:08:32 -06003069 VkFormat src_format = src_image_state->createInfo.format;
3070 VkFormat dst_format = dst_image_state->createInfo.format;
3071 VkImageType src_type = src_image_state->createInfo.imageType;
3072 VkImageType dst_type = dst_image_state->createInfo.imageType;
3073
Cort Stratton186b1a22018-05-01 20:18:06 -04003074 if (VK_FILTER_LINEAR == filter) {
3075 skip |= ValidateImageFormatFeatureFlags(device_data, src_image_state, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
Shannon McPherson40c0cba2018-08-07 13:39:13 -06003076 "vkCmdBlitImage()", "VUID-vkCmdBlitImage-filter-02001",
3077 "VUID-vkCmdBlitImage-filter-02001");
Cort Stratton186b1a22018-05-01 20:18:06 -04003078 } else if (VK_FILTER_CUBIC_IMG == filter) {
Dave Houltond8ed0212018-05-16 17:18:24 -06003079 skip |= ValidateImageFormatFeatureFlags(device_data, src_image_state,
3080 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, "vkCmdBlitImage()",
Shannon McPherson40c0cba2018-08-07 13:39:13 -06003081 "VUID-vkCmdBlitImage-filter-02002", "VUID-vkCmdBlitImage-filter-02002");
Dave Houlton33c2d252017-06-09 17:08:32 -06003082 }
3083
3084 if ((VK_FILTER_CUBIC_IMG == filter) && (VK_IMAGE_TYPE_3D != src_type)) {
3085 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003086 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-filter-00237",
Graeme Leese79b60cb2018-11-28 11:51:20 +00003087 "vkCmdBlitImage(): source image type must be VK_IMAGE_TYPE_3D when cubic filtering is specified.");
Dave Houlton33c2d252017-06-09 17:08:32 -06003088 }
3089
Dave Houlton33c2d252017-06-09 17:08:32 -06003090 if ((VK_SAMPLE_COUNT_1_BIT != src_image_state->createInfo.samples) ||
3091 (VK_SAMPLE_COUNT_1_BIT != dst_image_state->createInfo.samples)) {
3092 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003093 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-srcImage-00228",
Graeme Leese79b60cb2018-11-28 11:51:20 +00003094 "vkCmdBlitImage(): source or dest image has sample count other than VK_SAMPLE_COUNT_1_BIT.");
Dave Houlton33c2d252017-06-09 17:08:32 -06003095 }
3096
3097 // Validate consistency for unsigned formats
3098 if (FormatIsUInt(src_format) != FormatIsUInt(dst_format)) {
3099 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00003100 ss << "vkCmdBlitImage(): If one of srcImage and dstImage images has unsigned integer format, "
Dave Houlton33c2d252017-06-09 17:08:32 -06003101 << "the other one must also have unsigned integer format. "
3102 << "Source format is " << string_VkFormat(src_format) << " Destination format is " << string_VkFormat(dst_format);
3103 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003104 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-srcImage-00230", "%s.", ss.str().c_str());
Dave Houlton33c2d252017-06-09 17:08:32 -06003105 }
3106
3107 // Validate consistency for signed formats
3108 if (FormatIsSInt(src_format) != FormatIsSInt(dst_format)) {
3109 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00003110 ss << "vkCmdBlitImage(): If one of srcImage and dstImage images has signed integer format, "
Dave Houlton33c2d252017-06-09 17:08:32 -06003111 << "the other one must also have signed integer format. "
3112 << "Source format is " << string_VkFormat(src_format) << " Destination format is " << string_VkFormat(dst_format);
3113 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003114 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-srcImage-00229", "%s.", ss.str().c_str());
Dave Houlton33c2d252017-06-09 17:08:32 -06003115 }
3116
3117 // Validate filter for Depth/Stencil formats
3118 if (FormatIsDepthOrStencil(src_format) && (filter != VK_FILTER_NEAREST)) {
3119 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00003120 ss << "vkCmdBlitImage(): If the format of srcImage is a depth, stencil, or depth stencil "
Dave Houlton33c2d252017-06-09 17:08:32 -06003121 << "then filter must be VK_FILTER_NEAREST.";
3122 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003123 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-srcImage-00232", "%s.", ss.str().c_str());
Dave Houlton33c2d252017-06-09 17:08:32 -06003124 }
3125
3126 // Validate aspect bits and formats for depth/stencil images
3127 if (FormatIsDepthOrStencil(src_format) || FormatIsDepthOrStencil(dst_format)) {
3128 if (src_format != dst_format) {
3129 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00003130 ss << "vkCmdBlitImage(): If one of srcImage and dstImage images has a format of depth, stencil or depth "
Dave Houlton33c2d252017-06-09 17:08:32 -06003131 << "stencil, the other one must have exactly the same format. "
3132 << "Source format is " << string_VkFormat(src_format) << " Destination format is "
3133 << string_VkFormat(dst_format);
Dave Houltond8ed0212018-05-16 17:18:24 -06003134 skip |=
3135 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3136 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-srcImage-00231", "%s.", ss.str().c_str());
Dave Houlton33c2d252017-06-09 17:08:32 -06003137 }
Dave Houlton33c2d252017-06-09 17:08:32 -06003138 } // Depth or Stencil
3139
3140 // Do per-region checks
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003141 const char *invalid_src_layout_vuid =
Mark Lobodzinski60e79032019-03-07 10:22:31 -07003142 (src_image_state->shared_presentable && GetDeviceExtensions()->vk_khr_shared_presentable_image)
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003143 ? "VUID-vkCmdBlitImage-srcImageLayout-01398"
3144 : "VUID-vkCmdBlitImage-srcImageLayout-00222";
3145 const char *invalid_dst_layout_vuid =
Mark Lobodzinski60e79032019-03-07 10:22:31 -07003146 (dst_image_state->shared_presentable && GetDeviceExtensions()->vk_khr_shared_presentable_image)
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003147 ? "VUID-vkCmdBlitImage-dstImageLayout-01399"
3148 : "VUID-vkCmdBlitImage-dstImageLayout-00227";
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07003149 for (uint32_t i = 0; i < regionCount; i++) {
3150 const VkImageBlit rgn = pRegions[i];
Norbert Garnys7bd4c2c2017-11-16 10:58:04 +01003151 bool hit_error = false;
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07003152 skip |= VerifyImageLayout(device_data, cb_node, src_image_state, rgn.srcSubresource, srcImageLayout,
Cort Stratton7df30962018-05-17 19:45:57 -07003153 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, "vkCmdBlitImage()", invalid_src_layout_vuid,
3154 "VUID-vkCmdBlitImage-srcImageLayout-00221", &hit_error);
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07003155 skip |= VerifyImageLayout(device_data, cb_node, dst_image_state, rgn.dstSubresource, dstImageLayout,
Cort Stratton7df30962018-05-17 19:45:57 -07003156 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, "vkCmdBlitImage()", invalid_dst_layout_vuid,
3157 "VUID-vkCmdBlitImage-dstImageLayout-00226", &hit_error);
Cort Strattond619a302018-05-17 19:46:32 -07003158 skip |=
3159 ValidateImageSubresourceLayers(device_data, cb_node, &rgn.srcSubresource, "vkCmdBlitImage()", "srcSubresource", i);
3160 skip |=
3161 ValidateImageSubresourceLayers(device_data, cb_node, &rgn.dstSubresource, "vkCmdBlitImage()", "dstSubresource", i);
Cort Strattonff1542a2018-05-27 10:49:28 -07003162 skip |= ValidateImageMipLevel(device_data, cb_node, src_image_state, rgn.srcSubresource.mipLevel, i, "vkCmdBlitImage()",
3163 "srcSubresource", "VUID-vkCmdBlitImage-srcSubresource-01705");
3164 skip |= ValidateImageMipLevel(device_data, cb_node, dst_image_state, rgn.dstSubresource.mipLevel, i, "vkCmdBlitImage()",
3165 "dstSubresource", "VUID-vkCmdBlitImage-dstSubresource-01706");
3166 skip |= ValidateImageArrayLayerRange(device_data, cb_node, src_image_state, rgn.srcSubresource.baseArrayLayer,
3167 rgn.srcSubresource.layerCount, i, "vkCmdBlitImage()", "srcSubresource",
3168 "VUID-vkCmdBlitImage-srcSubresource-01707");
3169 skip |= ValidateImageArrayLayerRange(device_data, cb_node, dst_image_state, rgn.dstSubresource.baseArrayLayer,
3170 rgn.dstSubresource.layerCount, i, "vkCmdBlitImage()", "dstSubresource",
3171 "VUID-vkCmdBlitImage-dstSubresource-01708");
Mark Lobodzinski23c81142017-02-06 15:04:23 -07003172 // Warn for zero-sized regions
Dave Houlton48989f32017-05-26 15:01:46 -06003173 if ((rgn.srcOffsets[0].x == rgn.srcOffsets[1].x) || (rgn.srcOffsets[0].y == rgn.srcOffsets[1].y) ||
3174 (rgn.srcOffsets[0].z == rgn.srcOffsets[1].z)) {
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07003175 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00003176 ss << "vkCmdBlitImage(): pRegions[" << i << "].srcOffsets specify a zero-volume area.";
Dave Houlton51653902018-06-22 17:32:13 -06003177 skip |=
3178 log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3179 HandleToUint64(cb_node->commandBuffer), kVUID_Core_DrawState_InvalidExtents, "%s", ss.str().c_str());
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07003180 }
Dave Houlton48989f32017-05-26 15:01:46 -06003181 if ((rgn.dstOffsets[0].x == rgn.dstOffsets[1].x) || (rgn.dstOffsets[0].y == rgn.dstOffsets[1].y) ||
3182 (rgn.dstOffsets[0].z == rgn.dstOffsets[1].z)) {
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07003183 std::stringstream ss;
Graeme Leese79b60cb2018-11-28 11:51:20 +00003184 ss << "vkCmdBlitImage(): pRegions[" << i << "].dstOffsets specify a zero-volume area.";
Dave Houlton51653902018-06-22 17:32:13 -06003185 skip |=
3186 log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3187 HandleToUint64(cb_node->commandBuffer), kVUID_Core_DrawState_InvalidExtents, "%s", ss.str().c_str());
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07003188 }
Mark Lobodzinski23c81142017-02-06 15:04:23 -07003189
3190 // Check that src/dst layercounts match
Dave Houlton48989f32017-05-26 15:01:46 -06003191 if (rgn.srcSubresource.layerCount != rgn.dstSubresource.layerCount) {
Graeme Leese79b60cb2018-11-28 11:51:20 +00003192 skip |= log_msg(
3193 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3194 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-layerCount-00239",
3195 "vkCmdBlitImage(): layerCount in source and destination subresource of pRegions[%d] does not match.", i);
Mark Lobodzinski23c81142017-02-06 15:04:23 -07003196 }
Mark Lobodzinskie7e85fd2017-02-07 13:44:57 -07003197
Dave Houlton48989f32017-05-26 15:01:46 -06003198 if (rgn.srcSubresource.aspectMask != rgn.dstSubresource.aspectMask) {
Mark Lobodzinskie7e85fd2017-02-07 13:44:57 -07003199 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003200 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-aspectMask-00238",
Graeme Leese79b60cb2018-11-28 11:51:20 +00003201 "vkCmdBlitImage(): aspectMask members for pRegion[%d] do not match.", i);
Mark Lobodzinskie7e85fd2017-02-07 13:44:57 -07003202 }
Dave Houlton48989f32017-05-26 15:01:46 -06003203
Dave Houlton33c2d252017-06-09 17:08:32 -06003204 if (!VerifyAspectsPresent(rgn.srcSubresource.aspectMask, src_format)) {
3205 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003206 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-aspectMask-00241",
Graeme Leese79b60cb2018-11-28 11:51:20 +00003207 "vkCmdBlitImage(): region [%d] source aspectMask (0x%x) specifies aspects not present in source "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003208 "image format %s.",
3209 i, rgn.srcSubresource.aspectMask, string_VkFormat(src_format));
Dave Houlton33c2d252017-06-09 17:08:32 -06003210 }
3211
3212 if (!VerifyAspectsPresent(rgn.dstSubresource.aspectMask, dst_format)) {
3213 skip |= log_msg(
3214 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003215 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-aspectMask-00242",
Graeme Leese79b60cb2018-11-28 11:51:20 +00003216 "vkCmdBlitImage(): region [%d] dest aspectMask (0x%x) specifies aspects not present in dest image format %s.",
3217 i, rgn.dstSubresource.aspectMask, string_VkFormat(dst_format));
Dave Houlton33c2d252017-06-09 17:08:32 -06003218 }
3219
Dave Houlton48989f32017-05-26 15:01:46 -06003220 // Validate source image offsets
3221 VkExtent3D src_extent = GetImageSubresourceExtent(src_image_state, &(rgn.srcSubresource));
Dave Houlton33c2d252017-06-09 17:08:32 -06003222 if (VK_IMAGE_TYPE_1D == src_type) {
Dave Houlton48989f32017-05-26 15:01:46 -06003223 if ((0 != rgn.srcOffsets[0].y) || (1 != rgn.srcOffsets[1].y)) {
Graeme Leese79b60cb2018-11-28 11:51:20 +00003224 skip |=
3225 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3226 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-srcImage-00245",
3227 "vkCmdBlitImage(): region [%d], source image of type VK_IMAGE_TYPE_1D with srcOffset[].y values "
3228 "of (%1d, %1d). These must be (0, 1).",
3229 i, rgn.srcOffsets[0].y, rgn.srcOffsets[1].y);
Dave Houlton48989f32017-05-26 15:01:46 -06003230 }
3231 }
3232
Dave Houlton33c2d252017-06-09 17:08:32 -06003233 if ((VK_IMAGE_TYPE_1D == src_type) || (VK_IMAGE_TYPE_2D == src_type)) {
Dave Houlton48989f32017-05-26 15:01:46 -06003234 if ((0 != rgn.srcOffsets[0].z) || (1 != rgn.srcOffsets[1].z)) {
3235 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003236 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-srcImage-00247",
Graeme Leese79b60cb2018-11-28 11:51:20 +00003237 "vkCmdBlitImage(): region [%d], source image of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D with "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003238 "srcOffset[].z values of (%1d, %1d). These must be (0, 1).",
3239 i, rgn.srcOffsets[0].z, rgn.srcOffsets[1].z);
Dave Houlton48989f32017-05-26 15:01:46 -06003240 }
3241 }
3242
Dave Houlton33c2d252017-06-09 17:08:32 -06003243 bool oob = false;
Dave Houlton48989f32017-05-26 15:01:46 -06003244 if ((rgn.srcOffsets[0].x < 0) || (rgn.srcOffsets[0].x > static_cast<int32_t>(src_extent.width)) ||
3245 (rgn.srcOffsets[1].x < 0) || (rgn.srcOffsets[1].x > static_cast<int32_t>(src_extent.width))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06003246 oob = true;
Graeme Leese79b60cb2018-11-28 11:51:20 +00003247 skip |= log_msg(
3248 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3249 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-srcOffset-00243",
3250 "vkCmdBlitImage(): region [%d] srcOffset[].x values (%1d, %1d) exceed srcSubresource width extent (%1d).", i,
3251 rgn.srcOffsets[0].x, rgn.srcOffsets[1].x, src_extent.width);
Dave Houlton48989f32017-05-26 15:01:46 -06003252 }
3253 if ((rgn.srcOffsets[0].y < 0) || (rgn.srcOffsets[0].y > static_cast<int32_t>(src_extent.height)) ||
3254 (rgn.srcOffsets[1].y < 0) || (rgn.srcOffsets[1].y > static_cast<int32_t>(src_extent.height))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06003255 oob = true;
Dave Houlton48989f32017-05-26 15:01:46 -06003256 skip |= log_msg(
3257 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003258 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-srcOffset-00244",
Graeme Leese79b60cb2018-11-28 11:51:20 +00003259 "vkCmdBlitImage(): region [%d] srcOffset[].y values (%1d, %1d) exceed srcSubresource height extent (%1d).", i,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003260 rgn.srcOffsets[0].y, rgn.srcOffsets[1].y, src_extent.height);
Dave Houlton48989f32017-05-26 15:01:46 -06003261 }
3262 if ((rgn.srcOffsets[0].z < 0) || (rgn.srcOffsets[0].z > static_cast<int32_t>(src_extent.depth)) ||
3263 (rgn.srcOffsets[1].z < 0) || (rgn.srcOffsets[1].z > static_cast<int32_t>(src_extent.depth))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06003264 oob = true;
Graeme Leese79b60cb2018-11-28 11:51:20 +00003265 skip |= log_msg(
3266 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3267 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-srcOffset-00246",
3268 "vkCmdBlitImage(): region [%d] srcOffset[].z values (%1d, %1d) exceed srcSubresource depth extent (%1d).", i,
3269 rgn.srcOffsets[0].z, rgn.srcOffsets[1].z, src_extent.depth);
Dave Houlton48989f32017-05-26 15:01:46 -06003270 }
Cort Strattonff1542a2018-05-27 10:49:28 -07003271 if (oob) {
Dave Houlton33c2d252017-06-09 17:08:32 -06003272 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003273 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-pRegions-00215",
Graeme Leese79b60cb2018-11-28 11:51:20 +00003274 "vkCmdBlitImage(): region [%d] source image blit region exceeds image dimensions.", i);
Dave Houlton33c2d252017-06-09 17:08:32 -06003275 }
Dave Houlton48989f32017-05-26 15:01:46 -06003276
3277 // Validate dest image offsets
3278 VkExtent3D dst_extent = GetImageSubresourceExtent(dst_image_state, &(rgn.dstSubresource));
Dave Houlton33c2d252017-06-09 17:08:32 -06003279 if (VK_IMAGE_TYPE_1D == dst_type) {
Dave Houlton48989f32017-05-26 15:01:46 -06003280 if ((0 != rgn.dstOffsets[0].y) || (1 != rgn.dstOffsets[1].y)) {
Graeme Leese79b60cb2018-11-28 11:51:20 +00003281 skip |=
3282 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3283 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-dstImage-00250",
3284 "vkCmdBlitImage(): region [%d], dest image of type VK_IMAGE_TYPE_1D with dstOffset[].y values of "
3285 "(%1d, %1d). These must be (0, 1).",
3286 i, rgn.dstOffsets[0].y, rgn.dstOffsets[1].y);
Dave Houlton48989f32017-05-26 15:01:46 -06003287 }
3288 }
3289
Dave Houlton33c2d252017-06-09 17:08:32 -06003290 if ((VK_IMAGE_TYPE_1D == dst_type) || (VK_IMAGE_TYPE_2D == dst_type)) {
Dave Houlton48989f32017-05-26 15:01:46 -06003291 if ((0 != rgn.dstOffsets[0].z) || (1 != rgn.dstOffsets[1].z)) {
3292 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003293 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-dstImage-00252",
Graeme Leese79b60cb2018-11-28 11:51:20 +00003294 "vkCmdBlitImage(): region [%d], dest image of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D with "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003295 "dstOffset[].z values of (%1d, %1d). These must be (0, 1).",
3296 i, rgn.dstOffsets[0].z, rgn.dstOffsets[1].z);
Dave Houlton48989f32017-05-26 15:01:46 -06003297 }
3298 }
3299
Dave Houlton33c2d252017-06-09 17:08:32 -06003300 oob = false;
Dave Houlton48989f32017-05-26 15:01:46 -06003301 if ((rgn.dstOffsets[0].x < 0) || (rgn.dstOffsets[0].x > static_cast<int32_t>(dst_extent.width)) ||
3302 (rgn.dstOffsets[1].x < 0) || (rgn.dstOffsets[1].x > static_cast<int32_t>(dst_extent.width))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06003303 oob = true;
Graeme Leese79b60cb2018-11-28 11:51:20 +00003304 skip |= log_msg(
3305 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3306 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-dstOffset-00248",
3307 "vkCmdBlitImage(): region [%d] dstOffset[].x values (%1d, %1d) exceed dstSubresource width extent (%1d).", i,
3308 rgn.dstOffsets[0].x, rgn.dstOffsets[1].x, dst_extent.width);
Dave Houlton48989f32017-05-26 15:01:46 -06003309 }
3310 if ((rgn.dstOffsets[0].y < 0) || (rgn.dstOffsets[0].y > static_cast<int32_t>(dst_extent.height)) ||
3311 (rgn.dstOffsets[1].y < 0) || (rgn.dstOffsets[1].y > static_cast<int32_t>(dst_extent.height))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06003312 oob = true;
Dave Houlton48989f32017-05-26 15:01:46 -06003313 skip |= log_msg(
3314 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003315 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-dstOffset-00249",
Graeme Leese79b60cb2018-11-28 11:51:20 +00003316 "vkCmdBlitImage(): region [%d] dstOffset[].y values (%1d, %1d) exceed dstSubresource height extent (%1d).", i,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003317 rgn.dstOffsets[0].y, rgn.dstOffsets[1].y, dst_extent.height);
Dave Houlton48989f32017-05-26 15:01:46 -06003318 }
3319 if ((rgn.dstOffsets[0].z < 0) || (rgn.dstOffsets[0].z > static_cast<int32_t>(dst_extent.depth)) ||
3320 (rgn.dstOffsets[1].z < 0) || (rgn.dstOffsets[1].z > static_cast<int32_t>(dst_extent.depth))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06003321 oob = true;
Graeme Leese79b60cb2018-11-28 11:51:20 +00003322 skip |= log_msg(
3323 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3324 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-dstOffset-00251",
3325 "vkCmdBlitImage(): region [%d] dstOffset[].z values (%1d, %1d) exceed dstSubresource depth extent (%1d).", i,
3326 rgn.dstOffsets[0].z, rgn.dstOffsets[1].z, dst_extent.depth);
Dave Houlton48989f32017-05-26 15:01:46 -06003327 }
Cort Strattonff1542a2018-05-27 10:49:28 -07003328 if (oob) {
Dave Houlton33c2d252017-06-09 17:08:32 -06003329 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003330 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-pRegions-00216",
Graeme Leese79b60cb2018-11-28 11:51:20 +00003331 "vkCmdBlitImage(): region [%d] destination image blit region exceeds image dimensions.", i);
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07003332 }
3333
Dave Houlton33c2d252017-06-09 17:08:32 -06003334 if ((VK_IMAGE_TYPE_3D == src_type) || (VK_IMAGE_TYPE_3D == dst_type)) {
3335 if ((0 != rgn.srcSubresource.baseArrayLayer) || (1 != rgn.srcSubresource.layerCount) ||
3336 (0 != rgn.dstSubresource.baseArrayLayer) || (1 != rgn.dstSubresource.layerCount)) {
Graeme Leese79b60cb2018-11-28 11:51:20 +00003337 skip |=
3338 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3339 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-srcImage-00240",
3340 "vkCmdBlitImage(): region [%d] blit to/from a 3D image type with a non-zero baseArrayLayer, or a "
3341 "layerCount other than 1.",
3342 i);
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07003343 }
3344 }
Dave Houlton33c2d252017-06-09 17:08:32 -06003345 } // per-region checks
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07003346 } else {
3347 assert(0);
3348 }
3349 return skip;
3350}
3351
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003352void CoreChecks::PreCallRecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
3353 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
3354 const VkImageBlit *pRegions, VkFilter filter) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07003355 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07003356 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07003357 auto src_image_state = GetImageState(srcImage);
3358 auto dst_image_state = GetImageState(dstImage);
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07003359
Norbert Garnys7bd4c2c2017-11-16 10:58:04 +01003360 // Make sure that all image slices are updated to correct layout
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07003361 for (uint32_t i = 0; i < regionCount; ++i) {
3362 SetImageLayout(device_data, cb_node, src_image_state, pRegions[i].srcSubresource, srcImageLayout);
3363 SetImageLayout(device_data, cb_node, dst_image_state, pRegions[i].dstSubresource, dstImageLayout);
Norbert Garnys7bd4c2c2017-11-16 10:58:04 +01003364 }
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07003365 // Update bindings between images and cmd buffer
3366 AddCommandBufferBindingImage(device_data, cb_node, src_image_state);
3367 AddCommandBufferBindingImage(device_data, cb_node, dst_image_state);
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07003368}
3369
Shannon McPherson449fa9c2018-10-25 11:51:07 -06003370// This validates that the initial layout specified in the command buffer for the IMAGE is the same as the global IMAGE layout
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003371bool CoreChecks::ValidateCmdBufImageLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB,
3372 std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_NODE> const &globalImageLayoutMap,
3373 std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_NODE> &overlayLayoutMap) {
Mark Lobodzinskib0dd9472017-02-07 16:38:17 -07003374 bool skip = false;
Mark Lobodzinski4a3065e2017-02-07 16:36:03 -07003375 for (auto cb_image_data : pCB->imageLayoutMap) {
3376 VkImageLayout imageLayout;
Tony Barbourdf013b92017-01-25 12:53:48 -07003377
Dave Houltonb3f4b282018-02-22 16:25:16 -07003378 if (FindLayout(device_data, overlayLayoutMap, cb_image_data.first, imageLayout) ||
3379 FindLayout(device_data, globalImageLayoutMap, cb_image_data.first, imageLayout)) {
Mark Lobodzinski4a3065e2017-02-07 16:36:03 -07003380 if (cb_image_data.second.initialLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
3381 // TODO: Set memory invalid which is in mem_tracker currently
3382 } else if (imageLayout != cb_image_data.second.initialLayout) {
3383 if (cb_image_data.first.hasSubresource) {
Shannon McPherson449fa9c2018-10-25 11:51:07 -06003384 skip |=
3385 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3386 HandleToUint64(pCB->commandBuffer), kVUID_Core_DrawState_InvalidImageLayout,
Lockee9aeebf2019-03-03 23:50:08 -07003387 "Submitted command buffer expects image %s (subresource: aspectMask 0x%X array layer %u, mip level "
3388 "%u) to be in layout %s--instead, image %s's current layout is %s.",
3389 report_data->FormatHandle(cb_image_data.first.image).c_str(),
3390 cb_image_data.first.subresource.aspectMask, cb_image_data.first.subresource.arrayLayer,
3391 cb_image_data.first.subresource.mipLevel, string_VkImageLayout(cb_image_data.second.initialLayout),
3392 report_data->FormatHandle(cb_image_data.first.image).c_str(), string_VkImageLayout(imageLayout));
3393 } else {
3394 skip |= log_msg(
3395 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3396 HandleToUint64(pCB->commandBuffer), kVUID_Core_DrawState_InvalidImageLayout,
3397 "Submitted command buffer expects image %s to be in layout %s--instead, image %s's current layout is %s.",
3398 report_data->FormatHandle(cb_image_data.first.image).c_str(),
3399 string_VkImageLayout(cb_image_data.second.initialLayout),
3400 report_data->FormatHandle(cb_image_data.first.image).c_str(), string_VkImageLayout(imageLayout));
Mark Lobodzinski4a3065e2017-02-07 16:36:03 -07003401 }
3402 }
Chris Forbesf9d7acd2017-06-26 17:57:39 -07003403 SetLayout(overlayLayoutMap, cb_image_data.first, cb_image_data.second.layout);
Mark Lobodzinski4a3065e2017-02-07 16:36:03 -07003404 }
3405 }
Mark Lobodzinskib0dd9472017-02-07 16:38:17 -07003406 return skip;
Mark Lobodzinski4a3065e2017-02-07 16:36:03 -07003407}
Mark Lobodzinskib3829a52017-02-07 16:55:53 -07003408
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003409void CoreChecks::UpdateCmdBufImageLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB) {
Tony Barbourdf013b92017-01-25 12:53:48 -07003410 for (auto cb_image_data : pCB->imageLayoutMap) {
3411 VkImageLayout imageLayout;
3412 FindGlobalLayout(device_data, cb_image_data.first, imageLayout);
3413 SetGlobalLayout(device_data, cb_image_data.first, cb_image_data.second.layout);
3414 }
3415}
3416
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003417// ValidateLayoutVsAttachmentDescription is a general function where we can validate various state associated with the
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003418// VkAttachmentDescription structs that are used by the sub-passes of a renderpass. Initial check is to make sure that READ_ONLY
3419// layout attachments don't have CLEAR as their loadOp.
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003420bool CoreChecks::ValidateLayoutVsAttachmentDescription(const debug_report_data *report_data, RenderPassCreateVersion rp_version,
3421 const VkImageLayout first_layout, const uint32_t attachment,
3422 const VkAttachmentDescription2KHR &attachment_description) {
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003423 bool skip = false;
Tobias Hectorbbb12282018-10-22 15:17:59 +01003424 const char *vuid;
3425 const bool use_rp2 = (rp_version == RENDER_PASS_VERSION_2);
3426
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003427 // Verify that initial loadOp on READ_ONLY attachments is not CLEAR
3428 if (attachment_description.loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) {
Shannon McPherson3ea65132018-12-05 10:37:39 -07003429 if (use_rp2 && ((first_layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL) ||
3430 (first_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) ||
3431 (first_layout == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL))) {
Dave Houltond8ed0212018-05-16 17:18:24 -06003432 skip |=
Shannon McPherson3ea65132018-12-05 10:37:39 -07003433 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3434 "VUID-VkRenderPassCreateInfo2KHR-pAttachments-02522",
3435 "Cannot clear attachment %d with invalid first layout %s.", attachment, string_VkImageLayout(first_layout));
3436 } else if (!use_rp2 && ((first_layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL) ||
3437 (first_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL))) {
3438 skip |=
3439 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3440 "VUID-VkRenderPassCreateInfo-pAttachments-00836",
Dave Houltond8ed0212018-05-16 17:18:24 -06003441 "Cannot clear attachment %d with invalid first layout %s.", attachment, string_VkImageLayout(first_layout));
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003442 }
3443 }
Slawomir Cyganadf2b552018-04-24 17:18:26 +02003444 if (attachment_description.loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) {
3445 if (first_layout == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01003446 vuid = use_rp2 ? kVUID_Core_DrawState_InvalidRenderpass : "VUID-VkRenderPassCreateInfo-pAttachments-01566";
Dave Houltond8ed0212018-05-16 17:18:24 -06003447 skip |=
Tobias Hectorbbb12282018-10-22 15:17:59 +01003448 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
Dave Houltond8ed0212018-05-16 17:18:24 -06003449 "Cannot clear attachment %d with invalid first layout %s.", attachment, string_VkImageLayout(first_layout));
Slawomir Cyganadf2b552018-04-24 17:18:26 +02003450 }
3451 }
3452
3453 if (attachment_description.stencilLoadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) {
3454 if (first_layout == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01003455 vuid = use_rp2 ? kVUID_Core_DrawState_InvalidRenderpass : "VUID-VkRenderPassCreateInfo-pAttachments-01567";
Dave Houltond8ed0212018-05-16 17:18:24 -06003456 skip |=
Tobias Hectorbbb12282018-10-22 15:17:59 +01003457 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
Dave Houltond8ed0212018-05-16 17:18:24 -06003458 "Cannot clear attachment %d with invalid first layout %s.", attachment, string_VkImageLayout(first_layout));
Slawomir Cyganadf2b552018-04-24 17:18:26 +02003459 }
3460 }
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003461 return skip;
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003462}
3463
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003464bool CoreChecks::ValidateLayouts(layer_data *device_data, RenderPassCreateVersion rp_version, VkDevice device,
3465 const VkRenderPassCreateInfo2KHR *pCreateInfo) {
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003466 bool skip = false;
Tobias Hectorbbb12282018-10-22 15:17:59 +01003467 const char *vuid;
3468 const bool use_rp2 = (rp_version == RENDER_PASS_VERSION_2);
3469 const char *const function_name = use_rp2 ? "vkCreateRenderPass2KHR()" : "vkCreateRenderPass()";
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003470
Jason Ekstranda1906302017-12-03 20:16:32 -08003471 for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
3472 VkFormat format = pCreateInfo->pAttachments[i].format;
3473 if (pCreateInfo->pAttachments[i].initialLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
3474 if ((FormatIsColor(format) || FormatHasDepth(format)) &&
3475 pCreateInfo->pAttachments[i].loadOp == VK_ATTACHMENT_LOAD_OP_LOAD) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003476 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton51653902018-06-22 17:32:13 -06003477 kVUID_Core_DrawState_InvalidRenderpass,
Dave Houltona9df0ce2018-02-07 10:51:23 -07003478 "Render pass has an attachment with loadOp == VK_ATTACHMENT_LOAD_OP_LOAD and initialLayout == "
3479 "VK_IMAGE_LAYOUT_UNDEFINED. This is probably not what you intended. Consider using "
3480 "VK_ATTACHMENT_LOAD_OP_DONT_CARE instead if the image truely is undefined at the start of the "
3481 "render pass.");
Jason Ekstranda1906302017-12-03 20:16:32 -08003482 }
Dave Houltona9df0ce2018-02-07 10:51:23 -07003483 if (FormatHasStencil(format) && pCreateInfo->pAttachments[i].stencilLoadOp == VK_ATTACHMENT_LOAD_OP_LOAD) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003484 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton51653902018-06-22 17:32:13 -06003485 kVUID_Core_DrawState_InvalidRenderpass,
Dave Houltona9df0ce2018-02-07 10:51:23 -07003486 "Render pass has an attachment with stencilLoadOp == VK_ATTACHMENT_LOAD_OP_LOAD and initialLayout "
3487 "== VK_IMAGE_LAYOUT_UNDEFINED. This is probably not what you intended. Consider using "
3488 "VK_ATTACHMENT_LOAD_OP_DONT_CARE instead if the image truely is undefined at the start of the "
3489 "render pass.");
Jason Ekstranda1906302017-12-03 20:16:32 -08003490 }
3491 }
3492 }
3493
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003494 // Track when we're observing the first use of an attachment
3495 std::vector<bool> attach_first_use(pCreateInfo->attachmentCount, true);
3496 for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01003497 const VkSubpassDescription2KHR &subpass = pCreateInfo->pSubpasses[i];
Cort Stratton7547f772017-05-04 15:18:52 -07003498
3499 // Check input attachments first, so we can detect first-use-as-input for VU #00349
3500 for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) {
3501 auto attach_index = subpass.pInputAttachments[j].attachment;
3502 if (attach_index == VK_ATTACHMENT_UNUSED) continue;
Cort Stratton7547f772017-05-04 15:18:52 -07003503 switch (subpass.pInputAttachments[j].layout) {
3504 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
3505 case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
3506 // These are ideal.
3507 break;
3508
3509 case VK_IMAGE_LAYOUT_GENERAL:
3510 // May not be optimal. TODO: reconsider this warning based on other constraints.
3511 skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
Dave Houlton51653902018-06-22 17:32:13 -06003512 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUID_Core_DrawState_InvalidImageLayout,
Cort Stratton7547f772017-05-04 15:18:52 -07003513 "Layout for input attachment is GENERAL but should be READ_ONLY_OPTIMAL.");
3514 break;
3515
Tobias Hectorbbb12282018-10-22 15:17:59 +01003516 case VK_IMAGE_LAYOUT_UNDEFINED:
3517 case VK_IMAGE_LAYOUT_PREINITIALIZED:
3518 vuid = use_rp2 ? "VUID-VkAttachmentReference2KHR-layout-03077" : "VUID-VkAttachmentReference-layout-00857";
3519 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
3520 "Layout for input attachment reference %u in subpass %u is %s but must be "
3521 "DEPTH_STENCIL_READ_ONLY, SHADER_READ_ONLY_OPTIMAL, or GENERAL.",
3522 j, i, string_VkImageLayout(subpass.pDepthStencilAttachment->layout));
3523 break;
3524
Graeme Leese668a9862018-10-08 10:40:02 +01003525 case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR:
3526 case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR:
Mark Lobodzinski60e79032019-03-07 10:22:31 -07003527 if (GetDeviceExtensions()->vk_khr_maintenance2) {
Graeme Leese668a9862018-10-08 10:40:02 +01003528 break;
3529 } else {
3530 // Intentionally fall through to generic error message
3531 }
3532 // fall through
Tobias Hectorbbb12282018-10-22 15:17:59 +01003533
Cort Stratton7547f772017-05-04 15:18:52 -07003534 default:
3535 // No other layouts are acceptable
3536 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton51653902018-06-22 17:32:13 -06003537 kVUID_Core_DrawState_InvalidImageLayout,
Cort Stratton7547f772017-05-04 15:18:52 -07003538 "Layout for input attachment is %s but can only be READ_ONLY_OPTIMAL or GENERAL.",
3539 string_VkImageLayout(subpass.pInputAttachments[j].layout));
3540 }
3541
Cort Stratton7547f772017-05-04 15:18:52 -07003542 if (attach_first_use[attach_index]) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01003543 skip |= ValidateLayoutVsAttachmentDescription(report_data, rp_version, subpass.pInputAttachments[j].layout,
3544 attach_index, pCreateInfo->pAttachments[attach_index]);
Cort Stratton7547f772017-05-04 15:18:52 -07003545
3546 bool used_as_depth =
3547 (subpass.pDepthStencilAttachment != NULL && subpass.pDepthStencilAttachment->attachment == attach_index);
3548 bool used_as_color = false;
3549 for (uint32_t k = 0; !used_as_depth && !used_as_color && k < subpass.colorAttachmentCount; ++k) {
3550 used_as_color = (subpass.pColorAttachments[k].attachment == attach_index);
3551 }
3552 if (!used_as_depth && !used_as_color &&
3553 pCreateInfo->pAttachments[attach_index].loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01003554 vuid = use_rp2 ? "VUID-VkSubpassDescription2KHR-loadOp-03064" : "VUID-VkSubpassDescription-loadOp-00846";
3555 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
3556 "%s: attachment %u is first used as an input attachment in subpass %u with loadOp=CLEAR.",
3557 function_name, attach_index, attach_index);
Cort Stratton7547f772017-05-04 15:18:52 -07003558 }
3559 }
3560 attach_first_use[attach_index] = false;
3561 }
Tobias Hectorbbb12282018-10-22 15:17:59 +01003562
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003563 for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) {
3564 auto attach_index = subpass.pColorAttachments[j].attachment;
3565 if (attach_index == VK_ATTACHMENT_UNUSED) continue;
3566
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -06003567 // TODO: Need a way to validate shared presentable images here, currently just allowing
3568 // VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
3569 // as an acceptable layout, but need to make sure shared presentable images ONLY use that layout
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003570 switch (subpass.pColorAttachments[j].layout) {
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003571 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
Dave Houlton33c2d252017-06-09 17:08:32 -06003572 // This is ideal.
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -06003573 case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR:
3574 // TODO: See note above, just assuming that attachment is shared presentable and allowing this for now.
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003575 break;
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003576
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003577 case VK_IMAGE_LAYOUT_GENERAL:
3578 // May not be optimal; TODO: reconsider this warning based on other constraints?
3579 skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
Dave Houlton51653902018-06-22 17:32:13 -06003580 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUID_Core_DrawState_InvalidImageLayout,
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003581 "Layout for color attachment is GENERAL but should be COLOR_ATTACHMENT_OPTIMAL.");
3582 break;
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003583
Tobias Hectorbbb12282018-10-22 15:17:59 +01003584 case VK_IMAGE_LAYOUT_UNDEFINED:
3585 case VK_IMAGE_LAYOUT_PREINITIALIZED:
3586 vuid = use_rp2 ? "VUID-VkAttachmentReference2KHR-layout-03077" : "VUID-VkAttachmentReference-layout-00857";
3587 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
3588 "Layout for color attachment reference %u in subpass %u is %s but should be "
3589 "COLOR_ATTACHMENT_OPTIMAL or GENERAL.",
3590 j, i, string_VkImageLayout(subpass.pColorAttachments[j].layout));
3591 break;
3592
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003593 default:
3594 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton51653902018-06-22 17:32:13 -06003595 kVUID_Core_DrawState_InvalidImageLayout,
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003596 "Layout for color attachment is %s but can only be COLOR_ATTACHMENT_OPTIMAL or GENERAL.",
3597 string_VkImageLayout(subpass.pColorAttachments[j].layout));
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003598 }
3599
John Zulauf4eee2692019-02-09 16:14:25 -07003600 if (subpass.pResolveAttachments && (subpass.pResolveAttachments[j].attachment != VK_ATTACHMENT_UNUSED) &&
3601 (subpass.pResolveAttachments[j].layout == VK_IMAGE_LAYOUT_UNDEFINED ||
3602 subpass.pResolveAttachments[j].layout == VK_IMAGE_LAYOUT_PREINITIALIZED)) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01003603 vuid = use_rp2 ? "VUID-VkAttachmentReference2KHR-layout-03077" : "VUID-VkAttachmentReference-layout-00857";
3604 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
John Zulauf4eee2692019-02-09 16:14:25 -07003605 "Layout for resolve attachment reference %u in subpass %u is %s but should be "
Tobias Hectorbbb12282018-10-22 15:17:59 +01003606 "COLOR_ATTACHMENT_OPTIMAL or GENERAL.",
John Zulauff0f8c2b2019-02-14 12:13:44 -07003607 j, i, string_VkImageLayout(subpass.pResolveAttachments[j].layout));
Tobias Hectorbbb12282018-10-22 15:17:59 +01003608 }
3609
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003610 if (attach_first_use[attach_index]) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01003611 skip |= ValidateLayoutVsAttachmentDescription(report_data, rp_version, subpass.pColorAttachments[j].layout,
3612 attach_index, pCreateInfo->pAttachments[attach_index]);
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003613 }
3614 attach_first_use[attach_index] = false;
3615 }
Lenny Komowb79f04a2017-09-18 17:07:00 -06003616
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003617 if (subpass.pDepthStencilAttachment && subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) {
3618 switch (subpass.pDepthStencilAttachment->layout) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07003619 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
3620 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
3621 // These are ideal.
Lenny Komowb79f04a2017-09-18 17:07:00 -06003622 break;
Lenny Komowb79f04a2017-09-18 17:07:00 -06003623
Dave Houltona9df0ce2018-02-07 10:51:23 -07003624 case VK_IMAGE_LAYOUT_GENERAL:
3625 // May not be optimal; TODO: reconsider this warning based on other constraints? GENERAL can be better than
3626 // doing a bunch of transitions.
3627 skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
Dave Houlton51653902018-06-22 17:32:13 -06003628 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUID_Core_DrawState_InvalidImageLayout,
Dave Houltona9df0ce2018-02-07 10:51:23 -07003629 "GENERAL layout for depth attachment may not give optimal performance.");
3630 break;
3631
Tobias Hectorbbb12282018-10-22 15:17:59 +01003632 case VK_IMAGE_LAYOUT_UNDEFINED:
3633 case VK_IMAGE_LAYOUT_PREINITIALIZED:
3634 vuid = use_rp2 ? "VUID-VkAttachmentReference2KHR-layout-03077" : "VUID-VkAttachmentReference-layout-00857";
3635 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
3636 "Layout for depth attachment reference in subpass %u is %s but must be a valid depth/stencil "
3637 "layout or GENERAL.",
3638 i, string_VkImageLayout(subpass.pDepthStencilAttachment->layout));
3639 break;
3640
Dave Houltona9df0ce2018-02-07 10:51:23 -07003641 case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR:
3642 case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR:
Mark Lobodzinski60e79032019-03-07 10:22:31 -07003643 if (GetDeviceExtensions()->vk_khr_maintenance2) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07003644 break;
3645 } else {
3646 // Intentionally fall through to generic error message
3647 }
Tobin Ehlis648b1cf2018-04-13 15:24:13 -06003648 // fall through
Tobias Hectorbbb12282018-10-22 15:17:59 +01003649
Dave Houltona9df0ce2018-02-07 10:51:23 -07003650 default:
3651 // No other layouts are acceptable
3652 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton51653902018-06-22 17:32:13 -06003653 kVUID_Core_DrawState_InvalidImageLayout,
Dave Houltona9df0ce2018-02-07 10:51:23 -07003654 "Layout for depth attachment is %s but can only be DEPTH_STENCIL_ATTACHMENT_OPTIMAL, "
3655 "DEPTH_STENCIL_READ_ONLY_OPTIMAL or GENERAL.",
3656 string_VkImageLayout(subpass.pDepthStencilAttachment->layout));
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003657 }
3658
3659 auto attach_index = subpass.pDepthStencilAttachment->attachment;
3660 if (attach_first_use[attach_index]) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01003661 skip |= ValidateLayoutVsAttachmentDescription(report_data, rp_version, subpass.pDepthStencilAttachment->layout,
3662 attach_index, pCreateInfo->pAttachments[attach_index]);
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003663 }
3664 attach_first_use[attach_index] = false;
3665 }
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003666 }
3667 return skip;
3668}
Mark Lobodzinski08f14fa2017-02-07 17:20:06 -07003669
3670// For any image objects that overlap mapped memory, verify that their layouts are PREINIT or GENERAL
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003671bool CoreChecks::ValidateMapImageLayouts(layer_data *device_data, VkDevice device, DEVICE_MEM_INFO const *mem_info,
3672 VkDeviceSize offset, VkDeviceSize end_offset) {
Mark Lobodzinskiac23ec82017-02-07 17:21:55 -07003673 bool skip = false;
3674 // Iterate over all bound image ranges and verify that for any that overlap the map ranges, the layouts are
3675 // VK_IMAGE_LAYOUT_PREINITIALIZED or VK_IMAGE_LAYOUT_GENERAL
Mark Lobodzinski08f14fa2017-02-07 17:20:06 -07003676 // TODO : This can be optimized if we store ranges based on starting address and early exit when we pass our range
3677 for (auto image_handle : mem_info->bound_images) {
3678 auto img_it = mem_info->bound_ranges.find(image_handle);
3679 if (img_it != mem_info->bound_ranges.end()) {
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06003680 if (RangesIntersect(device_data, &img_it->second, offset, end_offset)) {
Mark Lobodzinski08f14fa2017-02-07 17:20:06 -07003681 std::vector<VkImageLayout> layouts;
Mark Lobodzinskiac23ec82017-02-07 17:21:55 -07003682 if (FindLayouts(device_data, VkImage(image_handle), layouts)) {
Mark Lobodzinski08f14fa2017-02-07 17:20:06 -07003683 for (auto layout : layouts) {
3684 if (layout != VK_IMAGE_LAYOUT_PREINITIALIZED && layout != VK_IMAGE_LAYOUT_GENERAL) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003685 skip |=
3686 log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
Dave Houlton51653902018-06-22 17:32:13 -06003687 HandleToUint64(mem_info->mem), kVUID_Core_DrawState_InvalidImageLayout,
Dave Houltona9df0ce2018-02-07 10:51:23 -07003688 "Mapping an image with layout %s can result in undefined behavior if this memory is used "
3689 "by the device. Only GENERAL or PREINITIALIZED should be used.",
Petr Krausbc7f5442017-05-14 23:43:38 +02003690 string_VkImageLayout(layout));
Mark Lobodzinski08f14fa2017-02-07 17:20:06 -07003691 }
3692 }
3693 }
3694 }
3695 }
3696 }
Mark Lobodzinskiac23ec82017-02-07 17:21:55 -07003697 return skip;
Mark Lobodzinski08f14fa2017-02-07 17:20:06 -07003698}
Mark Lobodzinski96210742017-02-09 10:33:46 -07003699
3700// Helper function to validate correct usage bits set for buffers or images. Verify that (actual & desired) flags != 0 or, if strict
3701// is true, verify that (actual & desired) flags == desired
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003702bool CoreChecks::ValidateUsageFlags(const layer_data *device_data, VkFlags actual, VkFlags desired, VkBool32 strict,
3703 uint64_t obj_handle, VulkanObjectType obj_type, const char *msgCode, char const *func_name,
3704 char const *usage_str) {
Mark Lobodzinski96210742017-02-09 10:33:46 -07003705 bool correct_usage = false;
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07003706 bool skip = false;
Mark Lobodzinski33826372017-04-13 11:10:11 -06003707 const char *type_str = object_string[obj_type];
Mark Lobodzinski96210742017-02-09 10:33:46 -07003708 if (strict) {
3709 correct_usage = ((actual & desired) == desired);
3710 } else {
3711 correct_usage = ((actual & desired) != 0);
3712 }
3713 if (!correct_usage) {
Dave Houlton8e9f6542018-05-18 12:18:22 -06003714 if (msgCode == kVUIDUndefined) {
Dave Houlton12befb92018-06-26 17:16:46 -06003715 // TODO: Fix callers with kVUIDUndefined to use correct validation checks.
Lockee9aeebf2019-03-03 23:50:08 -07003716 skip = log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, get_debug_report_enum[obj_type], obj_handle,
3717 kVUID_Core_MemTrack_InvalidUsageFlag,
3718 "Invalid usage flag for %s %s used by %s. In this case, %s should have %s set during creation.",
3719 type_str, report_data->FormatHandle(obj_handle).c_str(), func_name, type_str, usage_str);
Mark Lobodzinski96210742017-02-09 10:33:46 -07003720 } else {
Lockee9aeebf2019-03-03 23:50:08 -07003721 skip = log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, get_debug_report_enum[obj_type], obj_handle, msgCode,
3722 "Invalid usage flag for %s %s used by %s. In this case, %s should have %s set during creation.",
3723 type_str, report_data->FormatHandle(obj_handle).c_str(), func_name, type_str, usage_str);
Mark Lobodzinski96210742017-02-09 10:33:46 -07003724 }
3725 }
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07003726 return skip;
Mark Lobodzinski96210742017-02-09 10:33:46 -07003727}
3728
3729// Helper function to validate usage flags for buffers. For given buffer_state send actual vs. desired usage off to helper above
3730// where an error will be flagged if usage is not correct
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003731bool CoreChecks::ValidateImageUsageFlags(layer_data *device_data, IMAGE_STATE const *image_state, VkFlags desired, bool strict,
3732 const char *msgCode, char const *func_name, char const *usage_string) {
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06003733 return ValidateUsageFlags(device_data, image_state->createInfo.usage, desired, strict, HandleToUint64(image_state->image),
3734 kVulkanObjectTypeImage, msgCode, func_name, usage_string);
Mark Lobodzinski96210742017-02-09 10:33:46 -07003735}
3736
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003737bool CoreChecks::ValidateImageFormatFeatureFlags(layer_data *dev_data, IMAGE_STATE const *image_state, VkFormatFeatureFlags desired,
3738 char const *func_name, const char *linear_vuid, const char *optimal_vuid) {
Mark Lobodzinski5c048802019-03-07 10:47:31 -07003739 VkFormatProperties format_properties = GetPDFormatProperties(image_state->createInfo.format);
Cort Stratton186b1a22018-05-01 20:18:06 -04003740 bool skip = false;
3741 if (image_state->createInfo.tiling == VK_IMAGE_TILING_LINEAR) {
3742 if ((format_properties.linearTilingFeatures & desired) != desired) {
Lockee9aeebf2019-03-03 23:50:08 -07003743 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3744 HandleToUint64(image_state->image), linear_vuid,
3745 "In %s, invalid linearTilingFeatures (0x%08X) for format %u used by image %s.", func_name,
3746 format_properties.linearTilingFeatures, image_state->createInfo.format,
3747 report_data->FormatHandle(image_state->image).c_str());
Cort Stratton186b1a22018-05-01 20:18:06 -04003748 }
3749 } else if (image_state->createInfo.tiling == VK_IMAGE_TILING_OPTIMAL) {
3750 if ((format_properties.optimalTilingFeatures & desired) != desired) {
3751 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3752 HandleToUint64(image_state->image), optimal_vuid,
Lockee9aeebf2019-03-03 23:50:08 -07003753 "In %s, invalid optimalTilingFeatures (0x%08X) for format %u used by image %s.", func_name,
Cort Stratton186b1a22018-05-01 20:18:06 -04003754 format_properties.optimalTilingFeatures, image_state->createInfo.format,
Lockee9aeebf2019-03-03 23:50:08 -07003755 report_data->FormatHandle(image_state->image).c_str());
Cort Stratton186b1a22018-05-01 20:18:06 -04003756 }
3757 }
3758 return skip;
3759}
3760
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003761bool CoreChecks::ValidateImageSubresourceLayers(layer_data *dev_data, const GLOBAL_CB_NODE *cb_node,
3762 const VkImageSubresourceLayers *subresource_layers, char const *func_name,
3763 char const *member, uint32_t i) {
Cort Strattond619a302018-05-17 19:46:32 -07003764 bool skip = false;
Cort Strattond619a302018-05-17 19:46:32 -07003765 // layerCount must not be zero
3766 if (subresource_layers->layerCount == 0) {
3767 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3768 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageSubresourceLayers-layerCount-01700",
3769 "In %s, pRegions[%u].%s.layerCount must not be zero.", func_name, i, member);
3770 }
3771 // aspectMask must not contain VK_IMAGE_ASPECT_METADATA_BIT
3772 if (subresource_layers->aspectMask & VK_IMAGE_ASPECT_METADATA_BIT) {
3773 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3774 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageSubresourceLayers-aspectMask-00168",
3775 "In %s, pRegions[%u].%s.aspectMask has VK_IMAGE_ASPECT_METADATA_BIT set.", func_name, i, member);
3776 }
3777 // if aspectMask contains COLOR, it must not contain either DEPTH or STENCIL
3778 if ((subresource_layers->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) &&
3779 (subresource_layers->aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) {
3780 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3781 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageSubresourceLayers-aspectMask-00167",
3782 "In %s, pRegions[%u].%s.aspectMask has VK_IMAGE_ASPECT_COLOR_BIT and either VK_IMAGE_ASPECT_DEPTH_BIT or "
3783 "VK_IMAGE_ASPECT_STENCIL_BIT set.",
3784 func_name, i, member);
3785 }
3786 return skip;
3787}
3788
Mark Lobodzinski96210742017-02-09 10:33:46 -07003789// Helper function to validate usage flags for buffers. For given buffer_state send actual vs. desired usage off to helper above
3790// where an error will be flagged if usage is not correct
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003791bool CoreChecks::ValidateBufferUsageFlags(const layer_data *device_data, BUFFER_STATE const *buffer_state, VkFlags desired,
3792 bool strict, const char *msgCode, char const *func_name, char const *usage_string) {
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06003793 return ValidateUsageFlags(device_data, buffer_state->createInfo.usage, desired, strict, HandleToUint64(buffer_state->buffer),
3794 kVulkanObjectTypeBuffer, msgCode, func_name, usage_string);
Mark Lobodzinski96210742017-02-09 10:33:46 -07003795}
3796
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003797bool CoreChecks::ValidateBufferViewRange(const layer_data *device_data, const BUFFER_STATE *buffer_state,
3798 const VkBufferViewCreateInfo *pCreateInfo, const VkPhysicalDeviceLimits *device_limits) {
Shannon McPherson4c9505b2018-06-19 15:18:55 -06003799 bool skip = false;
Shannon McPherson4c9505b2018-06-19 15:18:55 -06003800
3801 const VkDeviceSize &range = pCreateInfo->range;
3802 if (range != VK_WHOLE_SIZE) {
3803 // Range must be greater than 0
3804 if (range <= 0) {
3805 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
3806 HandleToUint64(buffer_state->buffer), "VUID-VkBufferViewCreateInfo-range-00928",
3807 "If VkBufferViewCreateInfo range (%" PRIuLEAST64
3808 ") does not equal VK_WHOLE_SIZE, range must be greater than 0.",
3809 range);
3810 }
3811 // Range must be a multiple of the element size of format
Dave Houltona585d132019-01-18 13:05:42 -07003812 const size_t format_size = FormatElementSize(pCreateInfo->format);
Shannon McPherson4c9505b2018-06-19 15:18:55 -06003813 if (range % format_size != 0) {
3814 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
3815 HandleToUint64(buffer_state->buffer), "VUID-VkBufferViewCreateInfo-range-00929",
3816 "If VkBufferViewCreateInfo range (%" PRIuLEAST64
3817 ") does not equal VK_WHOLE_SIZE, range must be a multiple of the element size of the format "
3818 "(" PRINTF_SIZE_T_SPECIFIER ").",
3819 range, format_size);
3820 }
3821 // Range divided by the element size of format must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements
3822 if (range / format_size > device_limits->maxTexelBufferElements) {
3823 skip |=
3824 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
3825 HandleToUint64(buffer_state->buffer), "VUID-VkBufferViewCreateInfo-range-00930",
3826 "If VkBufferViewCreateInfo range (%" PRIuLEAST64
3827 ") does not equal VK_WHOLE_SIZE, range divided by the element size of the format (" PRINTF_SIZE_T_SPECIFIER
3828 ") must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements (%" PRIuLEAST32 ").",
3829 range, format_size, device_limits->maxTexelBufferElements);
3830 }
3831 // The sum of range and offset must be less than or equal to the size of buffer
3832 if (range + pCreateInfo->offset > buffer_state->createInfo.size) {
3833 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
3834 HandleToUint64(buffer_state->buffer), "VUID-VkBufferViewCreateInfo-offset-00931",
3835 "If VkBufferViewCreateInfo range (%" PRIuLEAST64
3836 ") does not equal VK_WHOLE_SIZE, the sum of offset (%" PRIuLEAST64
3837 ") and range must be less than or equal to the size of the buffer (%" PRIuLEAST64 ").",
3838 range, pCreateInfo->offset, buffer_state->createInfo.size);
3839 }
3840 }
3841 return skip;
3842}
3843
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003844bool CoreChecks::ValidateBufferViewBuffer(const layer_data *device_data, const BUFFER_STATE *buffer_state,
3845 const VkBufferViewCreateInfo *pCreateInfo) {
Shannon McPherson265383a2018-06-21 15:37:52 -06003846 bool skip = false;
Mark Lobodzinski5c048802019-03-07 10:47:31 -07003847 const VkFormatProperties format_properties = GetPDFormatProperties(pCreateInfo->format);
Shannon McPherson265383a2018-06-21 15:37:52 -06003848 if ((buffer_state->createInfo.usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) &&
3849 !(format_properties.bufferFeatures & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)) {
3850 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
3851 HandleToUint64(buffer_state->buffer), "VUID-VkBufferViewCreateInfo-buffer-00933",
3852 "If buffer was created with `usage` containing VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, format must "
3853 "be supported for uniform texel buffers");
3854 }
3855 if ((buffer_state->createInfo.usage & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT) &&
3856 !(format_properties.bufferFeatures & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT)) {
3857 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
3858 HandleToUint64(buffer_state->buffer), "VUID-VkBufferViewCreateInfo-buffer-00934",
3859 "If buffer was created with `usage` containing VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, format must "
3860 "be supported for storage texel buffers");
3861 }
3862 return skip;
3863}
3864
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003865bool CoreChecks::PreCallValidateCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
3866 const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) {
Mark Lobodzinskidd995d22019-01-11 11:05:15 -07003867 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
3868
Mark Lobodzinski96210742017-02-09 10:33:46 -07003869 bool skip = false;
Mark Lobodzinski847b60c2017-03-13 09:32:45 -06003870
Dave Houltond8ed0212018-05-16 17:18:24 -06003871 // TODO: Add check for "VUID-vkCreateBuffer-flags-00911" (sparse address space accounting)
Mark Lobodzinski847b60c2017-03-13 09:32:45 -06003872
Mark Lobodzinski60e79032019-03-07 10:22:31 -07003873 if ((pCreateInfo->flags & VK_BUFFER_CREATE_SPARSE_BINDING_BIT) && (!GetEnabledFeatures()->core.sparseBinding)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003874 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houltond8ed0212018-05-16 17:18:24 -06003875 "VUID-VkBufferCreateInfo-flags-00915",
Mark Lobodzinski847b60c2017-03-13 09:32:45 -06003876 "vkCreateBuffer(): the sparseBinding device feature is disabled: Buffers cannot be created with the "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003877 "VK_BUFFER_CREATE_SPARSE_BINDING_BIT set.");
Mark Lobodzinski847b60c2017-03-13 09:32:45 -06003878 }
Mark Lobodzinskiaf355062017-03-13 09:35:01 -06003879
Mark Lobodzinski60e79032019-03-07 10:22:31 -07003880 if ((pCreateInfo->flags & VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT) && (!GetEnabledFeatures()->core.sparseResidencyBuffer)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003881 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houltond8ed0212018-05-16 17:18:24 -06003882 "VUID-VkBufferCreateInfo-flags-00916",
Dave Houltona9df0ce2018-02-07 10:51:23 -07003883 "vkCreateBuffer(): the sparseResidencyBuffer device feature is disabled: Buffers cannot be created with "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003884 "the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT set.");
Mark Lobodzinskiaf355062017-03-13 09:35:01 -06003885 }
Mark Lobodzinski035a4cf2017-03-13 09:45:07 -06003886
Mark Lobodzinski60e79032019-03-07 10:22:31 -07003887 if ((pCreateInfo->flags & VK_BUFFER_CREATE_SPARSE_ALIASED_BIT) && (!GetEnabledFeatures()->core.sparseResidencyAliased)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003888 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houltond8ed0212018-05-16 17:18:24 -06003889 "VUID-VkBufferCreateInfo-flags-00917",
Dave Houltona9df0ce2018-02-07 10:51:23 -07003890 "vkCreateBuffer(): the sparseResidencyAliased device feature is disabled: Buffers cannot be created with "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003891 "the VK_BUFFER_CREATE_SPARSE_ALIASED_BIT set.");
Mark Lobodzinski035a4cf2017-03-13 09:45:07 -06003892 }
Jeff Bolz87697532019-01-11 22:54:00 -06003893
3894 auto chained_devaddr_struct = lvl_find_in_chain<VkBufferDeviceAddressCreateInfoEXT>(pCreateInfo->pNext);
3895 if (chained_devaddr_struct) {
3896 if (!(pCreateInfo->flags & VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT) &&
3897 chained_devaddr_struct->deviceAddress != 0) {
3898 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3899 "VUID-VkBufferCreateInfo-deviceAddress-02604",
3900 "vkCreateBuffer(): Non-zero VkBufferDeviceAddressCreateInfoEXT::deviceAddress "
3901 "requires VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT.");
3902 }
3903 }
3904
3905 if ((pCreateInfo->flags & VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT) &&
Mark Lobodzinski60e79032019-03-07 10:22:31 -07003906 !GetEnabledFeatures()->buffer_address.bufferDeviceAddressCaptureReplay) {
Jeff Bolz87697532019-01-11 22:54:00 -06003907 skip |= log_msg(
3908 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3909 "VUID-VkBufferCreateInfo-flags-02605",
3910 "vkCreateBuffer(): the bufferDeviceAddressCaptureReplay device feature is disabled: Buffers cannot be created with "
3911 "the VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT set.");
3912 }
3913
3914 if ((pCreateInfo->usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT) &&
Mark Lobodzinski60e79032019-03-07 10:22:31 -07003915 !GetEnabledFeatures()->buffer_address.bufferDeviceAddress) {
Jeff Bolz87697532019-01-11 22:54:00 -06003916 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3917 "VUID-VkBufferCreateInfo-usage-02606",
3918 "vkCreateBuffer(): the bufferDeviceAddress device feature is disabled: Buffers cannot be created with "
3919 "the VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT set.");
3920 }
3921
Mark Lobodzinski08ee03c2019-02-04 10:57:47 -07003922 if (pCreateInfo->sharingMode == VK_SHARING_MODE_CONCURRENT && pCreateInfo->pQueueFamilyIndices) {
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003923 skip |=
3924 ValidateQueueFamilies(device_data, pCreateInfo->queueFamilyIndexCount, pCreateInfo->pQueueFamilyIndices,
3925 "vkCreateBuffer", "pCreateInfo->pQueueFamilyIndices", "VUID-VkBufferCreateInfo-sharingMode-01419",
3926 "VUID-VkBufferCreateInfo-sharingMode-01419", false);
Mark Lobodzinski08ee03c2019-02-04 10:57:47 -07003927 }
3928
Mark Lobodzinski96210742017-02-09 10:33:46 -07003929 return skip;
3930}
3931
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003932void CoreChecks::PostCallRecordCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
3933 const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer, VkResult result) {
Mark Lobodzinski701507e2019-01-18 14:31:53 -07003934 if (result != VK_SUCCESS) return;
Mark Lobodzinski96210742017-02-09 10:33:46 -07003935 // TODO : This doesn't create deep copy of pQueueFamilyIndices so need to fix that if/when we want that data to be valid
Mark Lobodzinski1170cf22019-03-07 11:08:21 -07003936 GetBufferMap()->insert(std::make_pair(*pBuffer, std::unique_ptr<BUFFER_STATE>(new BUFFER_STATE(*pBuffer, pCreateInfo))));
Mark Lobodzinski96210742017-02-09 10:33:46 -07003937}
3938
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003939bool CoreChecks::PreCallValidateCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
3940 const VkAllocationCallbacks *pAllocator, VkBufferView *pView) {
Mark Lobodzinskidd995d22019-01-11 11:05:15 -07003941 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
3942
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07003943 bool skip = false;
Mark Lobodzinski6ed74142019-03-06 11:35:39 -07003944 BUFFER_STATE *buffer_state = GetBufferState(pCreateInfo->buffer);
Mark Lobodzinski96210742017-02-09 10:33:46 -07003945 // If this isn't a sparse buffer, it needs to have memory backing it at CreateBufferView time
3946 if (buffer_state) {
Dave Houltond8ed0212018-05-16 17:18:24 -06003947 skip |= ValidateMemoryIsBoundToBuffer(device_data, buffer_state, "vkCreateBufferView()",
3948 "VUID-VkBufferViewCreateInfo-buffer-00935");
Mark Lobodzinski96210742017-02-09 10:33:46 -07003949 // In order to create a valid buffer view, the buffer must have been created with at least one of the following flags:
3950 // UNIFORM_TEXEL_BUFFER_BIT or STORAGE_TEXEL_BUFFER_BIT
Dave Houltond8ed0212018-05-16 17:18:24 -06003951 skip |= ValidateBufferUsageFlags(device_data, buffer_state,
3952 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, false,
3953 "VUID-VkBufferViewCreateInfo-buffer-00932", "vkCreateBufferView()",
3954 "VK_BUFFER_USAGE_[STORAGE|UNIFORM]_TEXEL_BUFFER_BIT");
Shannon McPherson883f6092018-06-14 13:15:25 -06003955
Shannon McPherson0eb84f62018-06-18 16:32:40 -06003956 // Buffer view offset must be less than the size of buffer
3957 if (pCreateInfo->offset >= buffer_state->createInfo.size) {
3958 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
3959 HandleToUint64(buffer_state->buffer), "VUID-VkBufferViewCreateInfo-offset-00925",
3960 "VkBufferViewCreateInfo offset (%" PRIuLEAST64
3961 ") must be less than the size of the buffer (%" PRIuLEAST64 ").",
3962 pCreateInfo->offset, buffer_state->createInfo.size);
3963 }
3964
Mark Lobodzinski5c048802019-03-07 10:47:31 -07003965 const VkPhysicalDeviceLimits *device_limits = &(GetPDProperties()->limits);
Shannon McPherson883f6092018-06-14 13:15:25 -06003966 // Buffer view offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment
3967 if ((pCreateInfo->offset % device_limits->minTexelBufferOffsetAlignment) != 0) {
3968 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
3969 HandleToUint64(buffer_state->buffer), "VUID-VkBufferViewCreateInfo-offset-00926",
3970 "VkBufferViewCreateInfo offset (%" PRIuLEAST64
3971 ") must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment (%" PRIuLEAST64 ").",
3972 pCreateInfo->offset, device_limits->minTexelBufferOffsetAlignment);
3973 }
Shannon McPherson4c9505b2018-06-19 15:18:55 -06003974
3975 skip |= ValidateBufferViewRange(device_data, buffer_state, pCreateInfo, device_limits);
Shannon McPherson265383a2018-06-21 15:37:52 -06003976
3977 skip |= ValidateBufferViewBuffer(device_data, buffer_state, pCreateInfo);
Mark Lobodzinski96210742017-02-09 10:33:46 -07003978 }
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07003979 return skip;
Mark Lobodzinski96210742017-02-09 10:33:46 -07003980}
3981
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003982void CoreChecks::PostCallRecordCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
3983 const VkAllocationCallbacks *pAllocator, VkBufferView *pView, VkResult result) {
Mark Lobodzinski701507e2019-01-18 14:31:53 -07003984 if (result != VK_SUCCESS) return;
Mark Lobodzinski1170cf22019-03-07 11:08:21 -07003985 (*GetBufferViewMap())[*pView] = std::unique_ptr<BUFFER_VIEW_STATE>(new BUFFER_VIEW_STATE(*pView, pCreateInfo));
Mark Lobodzinski96210742017-02-09 10:33:46 -07003986}
Mark Lobodzinski602de982017-02-09 11:01:33 -07003987
3988// For the given format verify that the aspect masks make sense
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003989bool CoreChecks::ValidateImageAspectMask(const layer_data *device_data, VkImage image, VkFormat format,
3990 VkImageAspectFlags aspect_mask, const char *func_name, const char *vuid) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07003991 bool skip = false;
Tobias Hectorbbb12282018-10-22 15:17:59 +01003992 VkDebugReportObjectTypeEXT objectType = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;
3993 if (image != VK_NULL_HANDLE) {
3994 objectType = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT;
3995 }
3996
Dave Houlton1d2022c2017-03-29 11:43:58 -06003997 if (FormatIsColor(format)) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07003998 if ((aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != VK_IMAGE_ASPECT_COLOR_BIT) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01003999 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, HandleToUint64(image), vuid,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004000 "%s: Color image formats must have the VK_IMAGE_ASPECT_COLOR_BIT set.", func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07004001 } else if ((aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != aspect_mask) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01004002 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, HandleToUint64(image), vuid,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004003 "%s: Color image formats must have ONLY the VK_IMAGE_ASPECT_COLOR_BIT set.", func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07004004 }
Dave Houlton1d2022c2017-03-29 11:43:58 -06004005 } else if (FormatIsDepthAndStencil(format)) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07004006 if ((aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) == 0) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01004007 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, HandleToUint64(image), vuid,
Dave Houltona9df0ce2018-02-07 10:51:23 -07004008 "%s: Depth/stencil image formats must have at least one of VK_IMAGE_ASPECT_DEPTH_BIT and "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004009 "VK_IMAGE_ASPECT_STENCIL_BIT set.",
4010 func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07004011 } else if ((aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) != aspect_mask) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01004012 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, HandleToUint64(image), vuid,
Mark Lobodzinski602de982017-02-09 11:01:33 -07004013 "%s: Combination depth/stencil image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT and "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004014 "VK_IMAGE_ASPECT_STENCIL_BIT set.",
4015 func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07004016 }
Dave Houlton1d2022c2017-03-29 11:43:58 -06004017 } else if (FormatIsDepthOnly(format)) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07004018 if ((aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01004019 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, HandleToUint64(image), vuid,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004020 "%s: Depth-only image formats must have the VK_IMAGE_ASPECT_DEPTH_BIT set.", func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07004021 } else if ((aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) != aspect_mask) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01004022 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, HandleToUint64(image), vuid,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004023 "%s: Depth-only image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT set.", func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07004024 }
Dave Houlton1d2022c2017-03-29 11:43:58 -06004025 } else if (FormatIsStencilOnly(format)) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07004026 if ((aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01004027 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, HandleToUint64(image), vuid,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004028 "%s: Stencil-only image formats must have the VK_IMAGE_ASPECT_STENCIL_BIT set.", func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07004029 } else if ((aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) != aspect_mask) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01004030 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, HandleToUint64(image), vuid,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004031 "%s: Stencil-only image formats can have only the VK_IMAGE_ASPECT_STENCIL_BIT set.", func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07004032 }
Dave Houlton501b15b2018-03-30 15:07:41 -06004033 } else if (FormatIsMultiplane(format)) {
4034 VkImageAspectFlags valid_flags = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT;
4035 if (3 == FormatPlaneCount(format)) {
4036 valid_flags = valid_flags | VK_IMAGE_ASPECT_PLANE_2_BIT;
4037 }
4038 if ((aspect_mask & valid_flags) != aspect_mask) {
Tobias Hectorbbb12282018-10-22 15:17:59 +01004039 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, HandleToUint64(image), vuid,
Dave Houlton501b15b2018-03-30 15:07:41 -06004040 "%s: Multi-plane image formats may have only VK_IMAGE_ASPECT_COLOR_BIT or VK_IMAGE_ASPECT_PLANE_n_BITs "
4041 "set, where n = [0, 1, 2].",
4042 func_name);
4043 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07004044 }
4045 return skip;
4046}
4047
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004048bool CoreChecks::ValidateImageSubresourceRange(const layer_data *device_data, const uint32_t image_mip_count,
4049 const uint32_t image_layer_count, const VkImageSubresourceRange &subresourceRange,
4050 const char *cmd_name, const char *param_name, const char *image_layer_count_var_name,
4051 const uint64_t image_handle, SubresourceRangeErrorCodes errorCodes) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07004052 bool skip = false;
Petr Kraus4d718682017-05-18 03:38:41 +02004053
4054 // Validate mip levels
Petr Krausffa94af2017-08-08 21:46:02 +02004055 if (subresourceRange.baseMipLevel >= image_mip_count) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06004056 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, image_handle,
Mark Lobodzinski88529492018-04-01 10:38:15 -06004057 errorCodes.base_mip_err,
Petr Krausffa94af2017-08-08 21:46:02 +02004058 "%s: %s.baseMipLevel (= %" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004059 ") is greater or equal to the mip level count of the image (i.e. greater or equal to %" PRIu32 ").",
4060 cmd_name, param_name, subresourceRange.baseMipLevel, image_mip_count);
Petr Krausffa94af2017-08-08 21:46:02 +02004061 }
Petr Kraus4d718682017-05-18 03:38:41 +02004062
Petr Krausffa94af2017-08-08 21:46:02 +02004063 if (subresourceRange.levelCount != VK_REMAINING_MIP_LEVELS) {
4064 if (subresourceRange.levelCount == 0) {
4065 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, image_handle,
Mark Lobodzinski88529492018-04-01 10:38:15 -06004066 errorCodes.mip_count_err, "%s: %s.levelCount is 0.", cmd_name, param_name);
Petr Krausffa94af2017-08-08 21:46:02 +02004067 } else {
4068 const uint64_t necessary_mip_count = uint64_t{subresourceRange.baseMipLevel} + uint64_t{subresourceRange.levelCount};
Petr Kraus4d718682017-05-18 03:38:41 +02004069
Petr Krausffa94af2017-08-08 21:46:02 +02004070 if (necessary_mip_count > image_mip_count) {
4071 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, image_handle,
Mark Lobodzinski88529492018-04-01 10:38:15 -06004072 errorCodes.mip_count_err,
Petr Krausffa94af2017-08-08 21:46:02 +02004073 "%s: %s.baseMipLevel + .levelCount (= %" PRIu32 " + %" PRIu32 " = %" PRIu64
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004074 ") is greater than the mip level count of the image (i.e. greater than %" PRIu32 ").",
Petr Krausffa94af2017-08-08 21:46:02 +02004075 cmd_name, param_name, subresourceRange.baseMipLevel, subresourceRange.levelCount,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004076 necessary_mip_count, image_mip_count);
Petr Krausffa94af2017-08-08 21:46:02 +02004077 }
Petr Kraus4d718682017-05-18 03:38:41 +02004078 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07004079 }
Petr Kraus4d718682017-05-18 03:38:41 +02004080
4081 // Validate array layers
Petr Krausffa94af2017-08-08 21:46:02 +02004082 if (subresourceRange.baseArrayLayer >= image_layer_count) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06004083 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, image_handle,
Mark Lobodzinski88529492018-04-01 10:38:15 -06004084 errorCodes.base_layer_err,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004085 "%s: %s.baseArrayLayer (= %" PRIu32
4086 ") is greater or equal to the %s of the image when it was created (i.e. greater or equal to %" PRIu32 ").",
4087 cmd_name, param_name, subresourceRange.baseArrayLayer, image_layer_count_var_name, image_layer_count);
Petr Krausffa94af2017-08-08 21:46:02 +02004088 }
Petr Kraus4d718682017-05-18 03:38:41 +02004089
Petr Krausffa94af2017-08-08 21:46:02 +02004090 if (subresourceRange.layerCount != VK_REMAINING_ARRAY_LAYERS) {
4091 if (subresourceRange.layerCount == 0) {
4092 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, image_handle,
Mark Lobodzinski88529492018-04-01 10:38:15 -06004093 errorCodes.layer_count_err, "%s: %s.layerCount is 0.", cmd_name, param_name);
Petr Krausffa94af2017-08-08 21:46:02 +02004094 } else {
4095 const uint64_t necessary_layer_count =
4096 uint64_t{subresourceRange.baseArrayLayer} + uint64_t{subresourceRange.layerCount};
Petr Kraus8423f152017-05-26 01:20:04 +02004097
Petr Krausffa94af2017-08-08 21:46:02 +02004098 if (necessary_layer_count > image_layer_count) {
4099 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, image_handle,
Mark Lobodzinski88529492018-04-01 10:38:15 -06004100 errorCodes.layer_count_err,
Petr Krausffa94af2017-08-08 21:46:02 +02004101 "%s: %s.baseArrayLayer + .layerCount (= %" PRIu32 " + %" PRIu32 " = %" PRIu64
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004102 ") is greater than the %s of the image when it was created (i.e. greater than %" PRIu32 ").",
Petr Krausffa94af2017-08-08 21:46:02 +02004103 cmd_name, param_name, subresourceRange.baseArrayLayer, subresourceRange.layerCount,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004104 necessary_layer_count, image_layer_count_var_name, image_layer_count);
Petr Krausffa94af2017-08-08 21:46:02 +02004105 }
Petr Kraus4d718682017-05-18 03:38:41 +02004106 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07004107 }
Petr Kraus4d718682017-05-18 03:38:41 +02004108
Mark Lobodzinski602de982017-02-09 11:01:33 -07004109 return skip;
4110}
4111
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004112bool CoreChecks::ValidateCreateImageViewSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state,
4113 bool is_imageview_2d_type,
4114 const VkImageSubresourceRange &subresourceRange) {
Mark Lobodzinski60e79032019-03-07 10:22:31 -07004115 bool is_khr_maintenance1 = GetDeviceExtensions()->vk_khr_maintenance1;
Petr Krausffa94af2017-08-08 21:46:02 +02004116 bool is_image_slicable = image_state->createInfo.imageType == VK_IMAGE_TYPE_3D &&
4117 (image_state->createInfo.flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR);
4118 bool is_3D_to_2D_map = is_khr_maintenance1 && is_image_slicable && is_imageview_2d_type;
4119
4120 const auto image_layer_count = is_3D_to_2D_map ? image_state->createInfo.extent.depth : image_state->createInfo.arrayLayers;
4121 const auto image_layer_count_var_name = is_3D_to_2D_map ? "extent.depth" : "arrayLayers";
4122
4123 SubresourceRangeErrorCodes subresourceRangeErrorCodes = {};
Dave Houltond8ed0212018-05-16 17:18:24 -06004124 subresourceRangeErrorCodes.base_mip_err = "VUID-VkImageViewCreateInfo-subresourceRange-01478";
4125 subresourceRangeErrorCodes.mip_count_err = "VUID-VkImageViewCreateInfo-subresourceRange-01718";
4126 subresourceRangeErrorCodes.base_layer_err = is_khr_maintenance1 ? (is_3D_to_2D_map ? "VUID-VkImageViewCreateInfo-image-01484"
4127 : "VUID-VkImageViewCreateInfo-image-01482")
4128 : "VUID-VkImageViewCreateInfo-subresourceRange-01480";
4129 subresourceRangeErrorCodes.layer_count_err = is_khr_maintenance1
4130 ? (is_3D_to_2D_map ? "VUID-VkImageViewCreateInfo-subresourceRange-01485"
4131 : "VUID-VkImageViewCreateInfo-subresourceRange-01483")
4132 : "VUID-VkImageViewCreateInfo-subresourceRange-01719";
Petr Krausffa94af2017-08-08 21:46:02 +02004133
4134 return ValidateImageSubresourceRange(device_data, image_state->createInfo.mipLevels, image_layer_count, subresourceRange,
4135 "vkCreateImageView", "pCreateInfo->subresourceRange", image_layer_count_var_name,
4136 HandleToUint64(image_state->image), subresourceRangeErrorCodes);
4137}
4138
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004139bool CoreChecks::ValidateCmdClearColorSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state,
4140 const VkImageSubresourceRange &subresourceRange, const char *param_name) {
Petr Krausffa94af2017-08-08 21:46:02 +02004141 SubresourceRangeErrorCodes subresourceRangeErrorCodes = {};
Dave Houltond8ed0212018-05-16 17:18:24 -06004142 subresourceRangeErrorCodes.base_mip_err = "VUID-vkCmdClearColorImage-baseMipLevel-01470";
4143 subresourceRangeErrorCodes.mip_count_err = "VUID-vkCmdClearColorImage-pRanges-01692";
4144 subresourceRangeErrorCodes.base_layer_err = "VUID-vkCmdClearColorImage-baseArrayLayer-01472";
4145 subresourceRangeErrorCodes.layer_count_err = "VUID-vkCmdClearColorImage-pRanges-01693";
Petr Krausffa94af2017-08-08 21:46:02 +02004146
4147 return ValidateImageSubresourceRange(device_data, image_state->createInfo.mipLevels, image_state->createInfo.arrayLayers,
4148 subresourceRange, "vkCmdClearColorImage", param_name, "arrayLayers",
4149 HandleToUint64(image_state->image), subresourceRangeErrorCodes);
4150}
4151
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004152bool CoreChecks::ValidateCmdClearDepthSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state,
4153 const VkImageSubresourceRange &subresourceRange, const char *param_name) {
Petr Krausffa94af2017-08-08 21:46:02 +02004154 SubresourceRangeErrorCodes subresourceRangeErrorCodes = {};
Dave Houltond8ed0212018-05-16 17:18:24 -06004155 subresourceRangeErrorCodes.base_mip_err = "VUID-vkCmdClearDepthStencilImage-baseMipLevel-01474";
4156 subresourceRangeErrorCodes.mip_count_err = "VUID-vkCmdClearDepthStencilImage-pRanges-01694";
4157 subresourceRangeErrorCodes.base_layer_err = "VUID-vkCmdClearDepthStencilImage-baseArrayLayer-01476";
4158 subresourceRangeErrorCodes.layer_count_err = "VUID-vkCmdClearDepthStencilImage-pRanges-01695";
Petr Krausffa94af2017-08-08 21:46:02 +02004159
4160 return ValidateImageSubresourceRange(device_data, image_state->createInfo.mipLevels, image_state->createInfo.arrayLayers,
4161 subresourceRange, "vkCmdClearDepthStencilImage", param_name, "arrayLayers",
4162 HandleToUint64(image_state->image), subresourceRangeErrorCodes);
4163}
4164
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004165bool CoreChecks::ValidateImageBarrierSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state,
4166 const VkImageSubresourceRange &subresourceRange, const char *cmd_name,
4167 const char *param_name) {
Petr Krausffa94af2017-08-08 21:46:02 +02004168 SubresourceRangeErrorCodes subresourceRangeErrorCodes = {};
Dave Houltond8ed0212018-05-16 17:18:24 -06004169 subresourceRangeErrorCodes.base_mip_err = "VUID-VkImageMemoryBarrier-subresourceRange-01486";
4170 subresourceRangeErrorCodes.mip_count_err = "VUID-VkImageMemoryBarrier-subresourceRange-01724";
4171 subresourceRangeErrorCodes.base_layer_err = "VUID-VkImageMemoryBarrier-subresourceRange-01488";
4172 subresourceRangeErrorCodes.layer_count_err = "VUID-VkImageMemoryBarrier-subresourceRange-01725";
Petr Krausffa94af2017-08-08 21:46:02 +02004173
4174 return ValidateImageSubresourceRange(device_data, image_state->createInfo.mipLevels, image_state->createInfo.arrayLayers,
4175 subresourceRange, cmd_name, param_name, "arrayLayers", HandleToUint64(image_state->image),
4176 subresourceRangeErrorCodes);
4177}
4178
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004179bool CoreChecks::PreCallValidateCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
4180 const VkAllocationCallbacks *pAllocator, VkImageView *pView) {
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004181 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
Mark Lobodzinski602de982017-02-09 11:01:33 -07004182 bool skip = false;
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07004183 IMAGE_STATE *image_state = GetImageState(pCreateInfo->image);
Mark Lobodzinski602de982017-02-09 11:01:33 -07004184 if (image_state) {
4185 skip |= ValidateImageUsageFlags(
4186 device_data, image_state,
4187 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT |
Dave Houlton142c4cb2018-10-17 15:04:41 -06004188 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
4189 VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV,
Dave Houlton8e9f6542018-05-18 12:18:22 -06004190 false, kVUIDUndefined, "vkCreateImageView()",
Jeff Bolz9af91c52018-09-01 21:53:57 -05004191 "VK_IMAGE_USAGE_[SAMPLED|STORAGE|COLOR_ATTACHMENT|DEPTH_STENCIL_ATTACHMENT|INPUT_ATTACHMENT|SHADING_RATE_IMAGE]_BIT");
Mark Lobodzinski602de982017-02-09 11:01:33 -07004192 // If this isn't a sparse image, it needs to have memory backing it at CreateImageView time
Dave Houltond8ed0212018-05-16 17:18:24 -06004193 skip |=
4194 ValidateMemoryIsBoundToImage(device_data, image_state, "vkCreateImageView()", "VUID-VkImageViewCreateInfo-image-01020");
Mark Lobodzinski602de982017-02-09 11:01:33 -07004195 // Checks imported from image layer
Petr Krausffa94af2017-08-08 21:46:02 +02004196 skip |= ValidateCreateImageViewSubresourceRange(
4197 device_data, image_state,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004198 pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_2D || pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_2D_ARRAY,
4199 pCreateInfo->subresourceRange);
Mark Lobodzinski602de982017-02-09 11:01:33 -07004200
4201 VkImageCreateFlags image_flags = image_state->createInfo.flags;
4202 VkFormat image_format = image_state->createInfo.format;
Jeremy Kniagercef491c2017-07-18 11:10:28 -06004203 VkImageUsageFlags image_usage = image_state->createInfo.usage;
4204 VkImageTiling image_tiling = image_state->createInfo.tiling;
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004205 VkFormat view_format = pCreateInfo->format;
4206 VkImageAspectFlags aspect_mask = pCreateInfo->subresourceRange.aspectMask;
Jeremy Kniager846ab732017-07-10 13:12:04 -06004207 VkImageType image_type = image_state->createInfo.imageType;
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004208 VkImageViewType view_type = pCreateInfo->viewType;
Mark Lobodzinski602de982017-02-09 11:01:33 -07004209
Dave Houltonbd2e2622018-04-10 16:41:14 -06004210 // If there's a chained VkImageViewUsageCreateInfo struct, modify image_usage to match
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004211 auto chained_ivuci_struct = lvl_find_in_chain<VkImageViewUsageCreateInfoKHR>(pCreateInfo->pNext);
Dave Houltonbd2e2622018-04-10 16:41:14 -06004212 if (chained_ivuci_struct) {
4213 if (chained_ivuci_struct->usage & ~image_usage) {
4214 std::stringstream ss;
4215 ss << "vkCreateImageView(): Chained VkImageViewUsageCreateInfo usage field (0x" << std::hex
Dave Houlton0f3795b2018-04-13 15:04:35 -06004216 << chained_ivuci_struct->usage << ") must not include flags not present in underlying image's usage (0x"
Dave Houltonbd2e2622018-04-10 16:41:14 -06004217 << image_usage << ").";
Mark Young9d1ac312018-05-21 16:28:27 -06004218 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004219 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewUsageCreateInfo-usage-01587", "%s",
Mark Young9d1ac312018-05-21 16:28:27 -06004220 ss.str().c_str());
Dave Houltonbd2e2622018-04-10 16:41:14 -06004221 }
4222
4223 image_usage = chained_ivuci_struct->usage;
4224 }
4225
Dave Houlton6f5f20a2018-05-04 12:37:44 -06004226 // Validate VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT state, if view/image formats differ
4227 if ((image_flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) && (image_format != view_format)) {
Dave Houltonc7988072018-04-16 11:46:56 -06004228 if (FormatIsMultiplane(image_format)) {
4229 // View format must match the multiplane compatible format
4230 uint32_t plane = 3; // invalid
4231 switch (aspect_mask) {
4232 case VK_IMAGE_ASPECT_PLANE_0_BIT:
4233 plane = 0;
4234 break;
4235 case VK_IMAGE_ASPECT_PLANE_1_BIT:
4236 plane = 1;
4237 break;
4238 case VK_IMAGE_ASPECT_PLANE_2_BIT:
4239 plane = 2;
4240 break;
4241 default:
4242 break;
4243 }
4244
4245 VkFormat compat_format = FindMultiplaneCompatibleFormat(image_format, plane);
4246 if (view_format != compat_format) {
Lenny Komowb79f04a2017-09-18 17:07:00 -06004247 std::stringstream ss;
4248 ss << "vkCreateImageView(): ImageView format " << string_VkFormat(view_format)
Dave Houltonc7988072018-04-16 11:46:56 -06004249 << " is not compatible with plane " << plane << " of underlying image format "
4250 << string_VkFormat(image_format) << ", must be " << string_VkFormat(compat_format) << ".";
Mark Young9d1ac312018-05-21 16:28:27 -06004251 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004252 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-image-01586", "%s",
Mark Young9d1ac312018-05-21 16:28:27 -06004253 ss.str().c_str());
Dave Houltonc7988072018-04-16 11:46:56 -06004254 }
4255 } else {
Mark Lobodzinski60e79032019-03-07 10:22:31 -07004256 if ((!GetDeviceExtensions()->vk_khr_maintenance2 ||
Dave Houltonc7988072018-04-16 11:46:56 -06004257 !(image_flags & VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR))) {
4258 // Format MUST be compatible (in the same format compatibility class) as the format the image was created with
4259 if (FormatCompatibilityClass(image_format) != FormatCompatibilityClass(view_format)) {
4260 std::stringstream ss;
4261 ss << "vkCreateImageView(): ImageView format " << string_VkFormat(view_format)
Lockee9aeebf2019-03-03 23:50:08 -07004262 << " is not in the same format compatibility class as image ("
4263 << report_data->FormatHandle(pCreateInfo->image).c_str() << ") format " << string_VkFormat(image_format)
Dave Houltonc7988072018-04-16 11:46:56 -06004264 << ". Images created with the VK_IMAGE_CREATE_MUTABLE_FORMAT BIT "
4265 << "can support ImageViews with differing formats but they must be in the same compatibility class.";
Mark Young9d1ac312018-05-21 16:28:27 -06004266 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004267 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-image-01018", "%s",
Mark Young9d1ac312018-05-21 16:28:27 -06004268 ss.str().c_str());
Dave Houltonc7988072018-04-16 11:46:56 -06004269 }
Lenny Komowb79f04a2017-09-18 17:07:00 -06004270 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07004271 }
4272 } else {
4273 // Format MUST be IDENTICAL to the format the image was created with
4274 if (image_format != view_format) {
4275 std::stringstream ss;
4276 ss << "vkCreateImageView() format " << string_VkFormat(view_format) << " differs from image "
Lockee9aeebf2019-03-03 23:50:08 -07004277 << report_data->FormatHandle(pCreateInfo->image).c_str() << " format " << string_VkFormat(image_format)
Mark Lobodzinski602de982017-02-09 11:01:33 -07004278 << ". Formats MUST be IDENTICAL unless VK_IMAGE_CREATE_MUTABLE_FORMAT BIT was set on image creation.";
Mark Young9d1ac312018-05-21 16:28:27 -06004279 skip |=
4280 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004281 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-image-01019", "%s", ss.str().c_str());
Mark Lobodzinski602de982017-02-09 11:01:33 -07004282 }
4283 }
4284
4285 // Validate correct image aspect bits for desired formats and format consistency
4286 skip |= ValidateImageAspectMask(device_data, image_state->image, image_format, aspect_mask, "vkCreateImageView()");
Jeremy Kniager846ab732017-07-10 13:12:04 -06004287
4288 switch (image_type) {
4289 case VK_IMAGE_TYPE_1D:
4290 if (view_type != VK_IMAGE_VIEW_TYPE_1D && view_type != VK_IMAGE_VIEW_TYPE_1D_ARRAY) {
Mark Young9d1ac312018-05-21 16:28:27 -06004291 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004292 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-subResourceRange-01021",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004293 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
4294 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06004295 }
4296 break;
4297 case VK_IMAGE_TYPE_2D:
4298 if (view_type != VK_IMAGE_VIEW_TYPE_2D && view_type != VK_IMAGE_VIEW_TYPE_2D_ARRAY) {
4299 if ((view_type == VK_IMAGE_VIEW_TYPE_CUBE || view_type == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) &&
4300 !(image_flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)) {
Mark Young9d1ac312018-05-21 16:28:27 -06004301 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004302 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-image-01003",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004303 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
4304 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06004305 } else if (view_type != VK_IMAGE_VIEW_TYPE_CUBE && view_type != VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) {
Mark Young9d1ac312018-05-21 16:28:27 -06004306 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004307 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-subResourceRange-01021",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004308 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
4309 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06004310 }
4311 }
4312 break;
4313 case VK_IMAGE_TYPE_3D:
Mark Lobodzinski60e79032019-03-07 10:22:31 -07004314 if (GetDeviceExtensions()->vk_khr_maintenance1) {
Jeremy Kniager846ab732017-07-10 13:12:04 -06004315 if (view_type != VK_IMAGE_VIEW_TYPE_3D) {
4316 if ((view_type == VK_IMAGE_VIEW_TYPE_2D || view_type == VK_IMAGE_VIEW_TYPE_2D_ARRAY)) {
4317 if (!(image_flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR)) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004318 skip |=
Mark Young9d1ac312018-05-21 16:28:27 -06004319 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004320 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-image-01005",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004321 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
4322 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06004323 } else if ((image_flags & (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT |
4324 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT))) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07004325 skip |=
Mark Young9d1ac312018-05-21 16:28:27 -06004326 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004327 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-subResourceRange-01021",
Dave Houltona9df0ce2018-02-07 10:51:23 -07004328 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s "
4329 "when the VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004330 "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT flags are enabled.",
4331 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06004332 }
4333 } else {
Mark Young9d1ac312018-05-21 16:28:27 -06004334 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004335 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-subResourceRange-01021",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004336 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
4337 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06004338 }
4339 }
4340 } else {
4341 if (view_type != VK_IMAGE_VIEW_TYPE_3D) {
Mark Young9d1ac312018-05-21 16:28:27 -06004342 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004343 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-subResourceRange-01021",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004344 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
4345 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06004346 }
4347 }
4348 break;
4349 default:
4350 break;
4351 }
Jeremy Kniagercef491c2017-07-18 11:10:28 -06004352
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06004353 // External format checks needed when VK_ANDROID_external_memory_android_hardware_buffer enabled
Mark Lobodzinski60e79032019-03-07 10:22:31 -07004354 if (GetDeviceExtensions()->vk_android_external_memory_android_hardware_buffer) {
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004355 skip |= ValidateCreateImageViewANDROID(device_data, pCreateInfo);
Jeremy Kniagercef491c2017-07-18 11:10:28 -06004356 }
4357
Mark Lobodzinski5c048802019-03-07 10:47:31 -07004358 VkFormatProperties format_properties = GetPDFormatProperties(view_format);
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06004359 VkFormatFeatureFlags tiling_features = (image_tiling & VK_IMAGE_TILING_LINEAR) ? format_properties.linearTilingFeatures
4360 : format_properties.optimalTilingFeatures;
4361
4362 if (tiling_features == 0) {
4363 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004364 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-None-02273",
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06004365 "vkCreateImageView(): pCreateInfo->format %s with tiling %s has no supported format features on this "
4366 "physical device.",
4367 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
4368 } else if ((image_usage & VK_IMAGE_USAGE_SAMPLED_BIT) && !(tiling_features & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
4369 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004370 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-usage-02274",
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06004371 "vkCreateImageView(): pCreateInfo->format %s with tiling %s does not support usage that includes "
4372 "VK_IMAGE_USAGE_SAMPLED_BIT.",
4373 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
4374 } else if ((image_usage & VK_IMAGE_USAGE_STORAGE_BIT) && !(tiling_features & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)) {
4375 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004376 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-usage-02275",
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06004377 "vkCreateImageView(): pCreateInfo->format %s with tiling %s does not support usage that includes "
4378 "VK_IMAGE_USAGE_STORAGE_BIT.",
4379 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
4380 } else if ((image_usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) &&
4381 !(tiling_features & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) {
4382 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004383 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-usage-02276",
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06004384 "vkCreateImageView(): pCreateInfo->format %s with tiling %s does not support usage that includes "
4385 "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT.",
4386 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
4387 } else if ((image_usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) &&
4388 !(tiling_features & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
4389 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004390 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-usage-02277",
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06004391 "vkCreateImageView(): pCreateInfo->format %s with tiling %s does not support usage that includes "
4392 "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT.",
4393 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
Jeremy Kniagercef491c2017-07-18 11:10:28 -06004394 }
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06004395
Jeff Bolz9af91c52018-09-01 21:53:57 -05004396 if (image_usage & VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV) {
4397 if (view_type != VK_IMAGE_VIEW_TYPE_2D && view_type != VK_IMAGE_VIEW_TYPE_2D_ARRAY) {
4398 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004399 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-image-02086",
Jeff Bolz9af91c52018-09-01 21:53:57 -05004400 "vkCreateImageView() If image was created with usage containing "
4401 "VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, viewType must be "
4402 "VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY.");
4403 }
4404 if (view_format != VK_FORMAT_R8_UINT) {
4405 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004406 HandleToUint64(pCreateInfo->image), "VUID-VkImageViewCreateInfo-image-02087",
Jeff Bolz9af91c52018-09-01 21:53:57 -05004407 "vkCreateImageView() If image was created with usage containing "
4408 "VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, format must be VK_FORMAT_R8_UINT.");
4409 }
4410 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07004411 }
4412 return skip;
4413}
4414
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004415void CoreChecks::PostCallRecordCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
4416 const VkAllocationCallbacks *pAllocator, VkImageView *pView, VkResult result) {
Mark Lobodzinski701507e2019-01-18 14:31:53 -07004417 if (result != VK_SUCCESS) return;
Mark Lobodzinski1170cf22019-03-07 11:08:21 -07004418 auto image_view_map = GetImageViewMap();
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004419 (*image_view_map)[*pView] = std::unique_ptr<IMAGE_VIEW_STATE>(new IMAGE_VIEW_STATE(*pView, pCreateInfo));
Mark Lobodzinskiefd933b2017-02-10 12:09:23 -07004420
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07004421 auto image_state = GetImageState(pCreateInfo->image);
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004422 auto &sub_res_range = (*image_view_map)[*pView].get()->create_info.subresourceRange;
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06004423 sub_res_range.levelCount = ResolveRemainingLevels(&sub_res_range, image_state->createInfo.mipLevels);
4424 sub_res_range.layerCount = ResolveRemainingLayers(&sub_res_range, image_state->createInfo.arrayLayers);
Mark Lobodzinski602de982017-02-09 11:01:33 -07004425}
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07004426
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004427bool CoreChecks::PreCallValidateCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
4428 uint32_t regionCount, const VkBufferCopy *pRegions) {
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07004429 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07004430 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski6ed74142019-03-06 11:35:39 -07004431 auto src_buffer_state = GetBufferState(srcBuffer);
4432 auto dst_buffer_state = GetBufferState(dstBuffer);
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07004433
Mark Lobodzinski680421d2017-02-09 13:06:56 -07004434 bool skip = false;
Dave Houltond8ed0212018-05-16 17:18:24 -06004435 skip |=
4436 ValidateMemoryIsBoundToBuffer(device_data, src_buffer_state, "vkCmdCopyBuffer()", "VUID-vkCmdCopyBuffer-srcBuffer-00119");
4437 skip |=
4438 ValidateMemoryIsBoundToBuffer(device_data, dst_buffer_state, "vkCmdCopyBuffer()", "VUID-vkCmdCopyBuffer-dstBuffer-00121");
Mark Lobodzinski680421d2017-02-09 13:06:56 -07004439 // Validate that SRC & DST buffers have correct usage flags set
Dave Houltond8ed0212018-05-16 17:18:24 -06004440 skip |=
4441 ValidateBufferUsageFlags(device_data, src_buffer_state, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true,
4442 "VUID-vkCmdCopyBuffer-srcBuffer-00118", "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_SRC_BIT");
4443 skip |=
4444 ValidateBufferUsageFlags(device_data, dst_buffer_state, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true,
4445 "VUID-vkCmdCopyBuffer-dstBuffer-00120", "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
Mike Schuchardt9c582402017-02-23 15:57:37 -07004446 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdCopyBuffer()",
Dave Houltond8ed0212018-05-16 17:18:24 -06004447 VK_QUEUE_TRANSFER_BIT | VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT,
4448 "VUID-vkCmdCopyBuffer-commandBuffer-cmdpool");
Mark Lobodzinski680421d2017-02-09 13:06:56 -07004449 skip |= ValidateCmd(device_data, cb_node, CMD_COPYBUFFER, "vkCmdCopyBuffer()");
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06004450 skip |= InsideRenderPass(device_data, cb_node, "vkCmdCopyBuffer()", "VUID-vkCmdCopyBuffer-renderpass");
Mark Lobodzinski680421d2017-02-09 13:06:56 -07004451 return skip;
4452}
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07004453
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004454void CoreChecks::PreCallRecordCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
4455 uint32_t regionCount, const VkBufferCopy *pRegions) {
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07004456 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07004457 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski6ed74142019-03-06 11:35:39 -07004458 auto src_buffer_state = GetBufferState(srcBuffer);
4459 auto dst_buffer_state = GetBufferState(dstBuffer);
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07004460
Mark Lobodzinski680421d2017-02-09 13:06:56 -07004461 // Update bindings between buffers and cmd buffer
4462 AddCommandBufferBindingBuffer(device_data, cb_node, src_buffer_state);
4463 AddCommandBufferBindingBuffer(device_data, cb_node, dst_buffer_state);
Mark Lobodzinski680421d2017-02-09 13:06:56 -07004464}
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004465
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004466bool CoreChecks::ValidateIdleBuffer(layer_data *device_data, VkBuffer buffer) {
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004467 bool skip = false;
Mark Lobodzinski6ed74142019-03-06 11:35:39 -07004468 auto buffer_state = GetBufferState(buffer);
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004469 if (!buffer_state) {
Petr Krausbc7f5442017-05-14 23:43:38 +02004470 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, HandleToUint64(buffer),
Lockee9aeebf2019-03-03 23:50:08 -07004471 kVUID_Core_DrawState_DoubleDestroy, "Cannot free buffer %s that has not been allocated.",
4472 report_data->FormatHandle(buffer).c_str());
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004473 } else {
4474 if (buffer_state->in_use.load()) {
Petr Krausbc7f5442017-05-14 23:43:38 +02004475 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004476 HandleToUint64(buffer), "VUID-vkDestroyBuffer-buffer-00922",
Lockee9aeebf2019-03-03 23:50:08 -07004477 "Cannot free buffer %s that is in use by a command buffer.", report_data->FormatHandle(buffer).c_str());
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004478 }
4479 }
4480 return skip;
4481}
4482
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004483bool CoreChecks::PreCallValidateDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) {
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004484 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
Mark Lobodzinskia3a230b2019-03-06 15:35:13 -07004485 IMAGE_VIEW_STATE *image_view_state = GetImageViewState(imageView);
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004486 VK_OBJECT obj_struct = {HandleToUint64(imageView), kVulkanObjectTypeImageView};
4487
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004488 bool skip = false;
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004489 if (image_view_state) {
4490 skip |= ValidateObjectNotInUse(device_data, image_view_state, obj_struct, "vkDestroyImageView",
Dave Houltond8ed0212018-05-16 17:18:24 -06004491 "VUID-vkDestroyImageView-imageView-01026");
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004492 }
4493 return skip;
4494}
4495
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004496void CoreChecks::PreCallRecordDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) {
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004497 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
Mark Lobodzinskia3a230b2019-03-06 15:35:13 -07004498 IMAGE_VIEW_STATE *image_view_state = GetImageViewState(imageView);
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07004499 if (!image_view_state) return;
4500 VK_OBJECT obj_struct = {HandleToUint64(imageView), kVulkanObjectTypeImageView};
4501
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004502 // Any bound cmd buffers are now invalid
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06004503 InvalidateCommandBuffers(device_data, image_view_state->cb_bindings, obj_struct);
Mark Lobodzinski1170cf22019-03-07 11:08:21 -07004504 (*GetImageViewMap()).erase(imageView);
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004505}
4506
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004507bool CoreChecks::PreCallValidateDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) {
Mark Lobodzinskidd995d22019-01-11 11:05:15 -07004508 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
Mark Lobodzinski6ed74142019-03-06 11:35:39 -07004509 auto buffer_state = GetBufferState(buffer);
Mark Lobodzinskidd995d22019-01-11 11:05:15 -07004510
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004511 bool skip = false;
Mark Lobodzinskidd995d22019-01-11 11:05:15 -07004512 if (buffer_state) {
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06004513 skip |= ValidateIdleBuffer(device_data, buffer);
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004514 }
4515 return skip;
4516}
4517
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004518void CoreChecks::PreCallRecordDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) {
Mark Lobodzinskidd995d22019-01-11 11:05:15 -07004519 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
4520 if (!buffer) return;
Mark Lobodzinski6ed74142019-03-06 11:35:39 -07004521 auto buffer_state = GetBufferState(buffer);
Mark Lobodzinskidd995d22019-01-11 11:05:15 -07004522 VK_OBJECT obj_struct = {HandleToUint64(buffer), kVulkanObjectTypeBuffer};
4523
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06004524 InvalidateCommandBuffers(device_data, buffer_state->cb_bindings, obj_struct);
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004525 for (auto mem_binding : buffer_state->GetBoundMemory()) {
Mark Lobodzinski97f83f72019-03-07 10:01:52 -07004526 auto mem_info = GetMemObjInfo(mem_binding);
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004527 if (mem_info) {
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004528 RemoveBufferMemoryRange(HandleToUint64(buffer), mem_info);
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004529 }
4530 }
Mark Lobodzinski97f83f72019-03-07 10:01:52 -07004531 ClearMemoryObjectBindings(HandleToUint64(buffer), kVulkanObjectTypeBuffer);
John Zulauf6b4aae82018-05-09 13:03:36 -06004532 EraseQFOReleaseBarriers<VkBufferMemoryBarrier>(device_data, buffer);
Mark Lobodzinski1170cf22019-03-07 11:08:21 -07004533 GetBufferMap()->erase(buffer_state->buffer);
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004534}
4535
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004536bool CoreChecks::PreCallValidateDestroyBufferView(VkDevice device, VkBufferView bufferView,
4537 const VkAllocationCallbacks *pAllocator) {
Mark Lobodzinskidd995d22019-01-11 11:05:15 -07004538 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
Mark Lobodzinski31aa9b02019-03-06 11:51:37 -07004539 auto buffer_view_state = GetBufferViewState(bufferView);
Mark Lobodzinskidd995d22019-01-11 11:05:15 -07004540 VK_OBJECT obj_struct = {HandleToUint64(bufferView), kVulkanObjectTypeBufferView};
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004541 bool skip = false;
Mark Lobodzinskidd995d22019-01-11 11:05:15 -07004542 if (buffer_view_state) {
4543 skip |= ValidateObjectNotInUse(device_data, buffer_view_state, obj_struct, "vkDestroyBufferView",
Dave Houltond8ed0212018-05-16 17:18:24 -06004544 "VUID-vkDestroyBufferView-bufferView-00936");
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004545 }
4546 return skip;
4547}
4548
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004549void CoreChecks::PreCallRecordDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) {
Mark Lobodzinskidd995d22019-01-11 11:05:15 -07004550 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
4551 if (!bufferView) return;
Mark Lobodzinski31aa9b02019-03-06 11:51:37 -07004552 auto buffer_view_state = GetBufferViewState(bufferView);
Mark Lobodzinskidd995d22019-01-11 11:05:15 -07004553 VK_OBJECT obj_struct = {HandleToUint64(bufferView), kVulkanObjectTypeBufferView};
4554
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004555 // Any bound cmd buffers are now invalid
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06004556 InvalidateCommandBuffers(device_data, buffer_view_state->cb_bindings, obj_struct);
Mark Lobodzinski1170cf22019-03-07 11:08:21 -07004557 GetBufferViewMap()->erase(bufferView);
Mark Lobodzinski306441e2017-02-10 13:48:38 -07004558}
Mark Lobodzinskidf0acbf2017-02-10 14:01:27 -07004559
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004560bool CoreChecks::PreCallValidateCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
4561 VkDeviceSize size, uint32_t data) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07004562 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07004563 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski6ed74142019-03-06 11:35:39 -07004564 auto buffer_state = GetBufferState(dstBuffer);
Mark Lobodzinskidf0acbf2017-02-10 14:01:27 -07004565 bool skip = false;
Dave Houltond8ed0212018-05-16 17:18:24 -06004566 skip |= ValidateMemoryIsBoundToBuffer(device_data, buffer_state, "vkCmdFillBuffer()", "VUID-vkCmdFillBuffer-dstBuffer-00031");
Mike Schuchardt9c582402017-02-23 15:57:37 -07004567 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdFillBuffer()",
Dave Houltond8ed0212018-05-16 17:18:24 -06004568 VK_QUEUE_TRANSFER_BIT | VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT,
4569 "VUID-vkCmdFillBuffer-commandBuffer-cmdpool");
Mark Lobodzinskidf0acbf2017-02-10 14:01:27 -07004570 skip |= ValidateCmd(device_data, cb_node, CMD_FILLBUFFER, "vkCmdFillBuffer()");
4571 // Validate that DST buffer has correct usage flags set
Dave Houltond8ed0212018-05-16 17:18:24 -06004572 skip |=
4573 ValidateBufferUsageFlags(device_data, buffer_state, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true,
4574 "VUID-vkCmdFillBuffer-dstBuffer-00029", "vkCmdFillBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06004575 skip |= InsideRenderPass(device_data, cb_node, "vkCmdFillBuffer()", "VUID-vkCmdFillBuffer-renderpass");
Mark Lobodzinskidf0acbf2017-02-10 14:01:27 -07004576 return skip;
4577}
4578
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004579void CoreChecks::PreCallRecordCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
4580 VkDeviceSize size, uint32_t data) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07004581 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07004582 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski6ed74142019-03-06 11:35:39 -07004583 auto buffer_state = GetBufferState(dstBuffer);
Mark Lobodzinskidf0acbf2017-02-10 14:01:27 -07004584 // Update bindings between buffer and cmd buffer
4585 AddCommandBufferBindingBuffer(device_data, cb_node, buffer_state);
Mark Lobodzinskidf0acbf2017-02-10 14:01:27 -07004586}
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004587
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004588bool CoreChecks::ValidateBufferImageCopyData(const debug_report_data *report_data, uint32_t regionCount,
4589 const VkBufferImageCopy *pRegions, IMAGE_STATE *image_state, const char *function) {
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004590 bool skip = false;
4591
4592 for (uint32_t i = 0; i < regionCount; i++) {
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004593 if (image_state->createInfo.imageType == VK_IMAGE_TYPE_1D) {
4594 if ((pRegions[i].imageOffset.y != 0) || (pRegions[i].imageExtent.height != 1)) {
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004595 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004596 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-srcImage-00199",
Dave Houltona9df0ce2018-02-07 10:51:23 -07004597 "%s(): pRegion[%d] imageOffset.y is %d and imageExtent.height is %d. For 1D images these must be 0 "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004598 "and 1, respectively.",
4599 function, i, pRegions[i].imageOffset.y, pRegions[i].imageExtent.height);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004600 }
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004601 }
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004602
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004603 if ((image_state->createInfo.imageType == VK_IMAGE_TYPE_1D) || (image_state->createInfo.imageType == VK_IMAGE_TYPE_2D)) {
4604 if ((pRegions[i].imageOffset.z != 0) || (pRegions[i].imageExtent.depth != 1)) {
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004605 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004606 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-srcImage-00201",
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004607 "%s(): pRegion[%d] imageOffset.z is %d and imageExtent.depth is %d. For 1D and 2D images these "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004608 "must be 0 and 1, respectively.",
4609 function, i, pRegions[i].imageOffset.z, pRegions[i].imageExtent.depth);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004610 }
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004611 }
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004612
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004613 if (image_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
4614 if ((0 != pRegions[i].imageSubresource.baseArrayLayer) || (1 != pRegions[i].imageSubresource.layerCount)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06004615 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004616 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-baseArrayLayer-00213",
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06004617 "%s(): pRegion[%d] imageSubresource.baseArrayLayer is %d and imageSubresource.layerCount is %d. "
4618 "For 3D images these must be 0 and 1, respectively.",
4619 function, i, pRegions[i].imageSubresource.baseArrayLayer, pRegions[i].imageSubresource.layerCount);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004620 }
4621 }
4622
4623 // If the the calling command's VkImage parameter's format is not a depth/stencil format,
Dave Houltona585d132019-01-18 13:05:42 -07004624 // then bufferOffset must be a multiple of the calling command's VkImage parameter's element size
4625 uint32_t element_size = FormatElementSize(image_state->createInfo.format);
4626 if (!FormatIsDepthAndStencil(image_state->createInfo.format) && SafeModulo(pRegions[i].bufferOffset, element_size) != 0) {
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004627 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004628 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-bufferOffset-00193",
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004629 "%s(): pRegion[%d] bufferOffset 0x%" PRIxLEAST64
Dave Houltona585d132019-01-18 13:05:42 -07004630 " must be a multiple of this format's texel size (%" PRIu32 ").",
4631 function, i, pRegions[i].bufferOffset, element_size);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004632 }
4633
4634 // BufferOffset must be a multiple of 4
Dave Houlton1d2022c2017-03-29 11:43:58 -06004635 if (SafeModulo(pRegions[i].bufferOffset, 4) != 0) {
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004636 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004637 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-bufferOffset-00194",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004638 "%s(): pRegion[%d] bufferOffset 0x%" PRIxLEAST64 " must be a multiple of 4.", function, i,
4639 pRegions[i].bufferOffset);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004640 }
4641
4642 // BufferRowLength must be 0, or greater than or equal to the width member of imageExtent
4643 if ((pRegions[i].bufferRowLength != 0) && (pRegions[i].bufferRowLength < pRegions[i].imageExtent.width)) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004644 skip |=
4645 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004646 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-bufferRowLength-00195",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004647 "%s(): pRegion[%d] bufferRowLength (%d) must be zero or greater-than-or-equal-to imageExtent.width (%d).",
4648 function, i, pRegions[i].bufferRowLength, pRegions[i].imageExtent.width);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004649 }
4650
4651 // BufferImageHeight must be 0, or greater than or equal to the height member of imageExtent
4652 if ((pRegions[i].bufferImageHeight != 0) && (pRegions[i].bufferImageHeight < pRegions[i].imageExtent.height)) {
4653 skip |= log_msg(
4654 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004655 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-bufferImageHeight-00196",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004656 "%s(): pRegion[%d] bufferImageHeight (%d) must be zero or greater-than-or-equal-to imageExtent.height (%d).",
4657 function, i, pRegions[i].bufferImageHeight, pRegions[i].imageExtent.height);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004658 }
4659
4660 // subresource aspectMask must have exactly 1 bit set
4661 const int num_bits = sizeof(VkFlags) * CHAR_BIT;
4662 std::bitset<num_bits> aspect_mask_bits(pRegions[i].imageSubresource.aspectMask);
4663 if (aspect_mask_bits.count() != 1) {
4664 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004665 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-aspectMask-00212",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004666 "%s: aspectMasks for imageSubresource in each region must have only a single bit set.", function);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004667 }
4668
4669 // image subresource aspect bit must match format
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06004670 if (!VerifyAspectsPresent(pRegions[i].imageSubresource.aspectMask, image_state->createInfo.format)) {
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004671 skip |= log_msg(
4672 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004673 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-aspectMask-00211",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004674 "%s(): pRegion[%d] subresource aspectMask 0x%x specifies aspects that are not present in image format 0x%x.",
4675 function, i, pRegions[i].imageSubresource.aspectMask, image_state->createInfo.format);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004676 }
4677
4678 // Checks that apply only to compressed images
Cort Stratton420ebd42018-05-04 01:12:23 -04004679 if (FormatIsCompressed(image_state->createInfo.format) || FormatIsSinglePlane_422(image_state->createInfo.format)) {
Dave Houltona585d132019-01-18 13:05:42 -07004680 auto block_size = FormatTexelBlockExtent(image_state->createInfo.format);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004681
4682 // BufferRowLength must be a multiple of block width
Dave Houlton1d2022c2017-03-29 11:43:58 -06004683 if (SafeModulo(pRegions[i].bufferRowLength, block_size.width) != 0) {
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004684 skip |= log_msg(
4685 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004686 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-bufferRowLength-00203",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004687 "%s(): pRegion[%d] bufferRowLength (%d) must be a multiple of the compressed image's texel width (%d)..",
4688 function, i, pRegions[i].bufferRowLength, block_size.width);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004689 }
4690
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004691 // BufferRowHeight must be a multiple of block height
Dave Houlton1d2022c2017-03-29 11:43:58 -06004692 if (SafeModulo(pRegions[i].bufferImageHeight, block_size.height) != 0) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07004693 skip |= log_msg(
4694 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004695 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-bufferImageHeight-00204",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004696 "%s(): pRegion[%d] bufferImageHeight (%d) must be a multiple of the compressed image's texel height (%d)..",
4697 function, i, pRegions[i].bufferImageHeight, block_size.height);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004698 }
4699
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004700 // image offsets must be multiples of block dimensions
Dave Houlton1d2022c2017-03-29 11:43:58 -06004701 if ((SafeModulo(pRegions[i].imageOffset.x, block_size.width) != 0) ||
4702 (SafeModulo(pRegions[i].imageOffset.y, block_size.height) != 0) ||
4703 (SafeModulo(pRegions[i].imageOffset.z, block_size.depth) != 0)) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004704 skip |=
4705 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004706 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-imageOffset-00205",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004707 "%s(): pRegion[%d] imageOffset(x,y) (%d, %d) must be multiples of the compressed image's texel "
4708 "width & height (%d, %d)..",
4709 function, i, pRegions[i].imageOffset.x, pRegions[i].imageOffset.y, block_size.width, block_size.height);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004710 }
4711
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004712 // bufferOffset must be a multiple of block size (linear bytes)
Dave Houltona585d132019-01-18 13:05:42 -07004713 uint32_t block_size_in_bytes = FormatElementSize(image_state->createInfo.format);
Dave Houlton1d2022c2017-03-29 11:43:58 -06004714 if (SafeModulo(pRegions[i].bufferOffset, block_size_in_bytes) != 0) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004715 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004716 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-bufferOffset-00206",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004717 "%s(): pRegion[%d] bufferOffset (0x%" PRIxLEAST64
Dave Houltona585d132019-01-18 13:05:42 -07004718 ") must be a multiple of the compressed image's texel block size (%" PRIu32 ")..",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004719 function, i, pRegions[i].bufferOffset, block_size_in_bytes);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004720 }
Dave Houlton67e9b532017-03-02 17:00:10 -07004721
4722 // imageExtent width must be a multiple of block width, or extent+offset width must equal subresource width
Dave Houlton75967fc2017-03-06 17:21:16 -07004723 VkExtent3D mip_extent = GetImageSubresourceExtent(image_state, &(pRegions[i].imageSubresource));
Dave Houlton1d2022c2017-03-29 11:43:58 -06004724 if ((SafeModulo(pRegions[i].imageExtent.width, block_size.width) != 0) &&
Dave Houlton75967fc2017-03-06 17:21:16 -07004725 (pRegions[i].imageExtent.width + pRegions[i].imageOffset.x != mip_extent.width)) {
4726 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004727 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-imageExtent-00207",
Dave Houlton75967fc2017-03-06 17:21:16 -07004728 "%s(): pRegion[%d] extent width (%d) must be a multiple of the compressed texture block width "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004729 "(%d), or when added to offset.x (%d) must equal the image subresource width (%d)..",
Dave Houlton75967fc2017-03-06 17:21:16 -07004730 function, i, pRegions[i].imageExtent.width, block_size.width, pRegions[i].imageOffset.x,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004731 mip_extent.width);
Dave Houlton67e9b532017-03-02 17:00:10 -07004732 }
4733
4734 // imageExtent height must be a multiple of block height, or extent+offset height must equal subresource height
Dave Houlton1d2022c2017-03-29 11:43:58 -06004735 if ((SafeModulo(pRegions[i].imageExtent.height, block_size.height) != 0) &&
Dave Houlton75967fc2017-03-06 17:21:16 -07004736 (pRegions[i].imageExtent.height + pRegions[i].imageOffset.y != mip_extent.height)) {
4737 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004738 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-imageExtent-00208",
Dave Houlton75967fc2017-03-06 17:21:16 -07004739 "%s(): pRegion[%d] extent height (%d) must be a multiple of the compressed texture block height "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004740 "(%d), or when added to offset.y (%d) must equal the image subresource height (%d)..",
Dave Houlton75967fc2017-03-06 17:21:16 -07004741 function, i, pRegions[i].imageExtent.height, block_size.height, pRegions[i].imageOffset.y,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004742 mip_extent.height);
Dave Houlton67e9b532017-03-02 17:00:10 -07004743 }
4744
4745 // imageExtent depth must be a multiple of block depth, or extent+offset depth must equal subresource depth
Dave Houlton1d2022c2017-03-29 11:43:58 -06004746 if ((SafeModulo(pRegions[i].imageExtent.depth, block_size.depth) != 0) &&
Dave Houlton75967fc2017-03-06 17:21:16 -07004747 (pRegions[i].imageExtent.depth + pRegions[i].imageOffset.z != mip_extent.depth)) {
4748 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004749 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-imageExtent-00209",
Dave Houlton75967fc2017-03-06 17:21:16 -07004750 "%s(): pRegion[%d] extent width (%d) must be a multiple of the compressed texture block depth "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004751 "(%d), or when added to offset.z (%d) must equal the image subresource depth (%d)..",
Dave Houlton75967fc2017-03-06 17:21:16 -07004752 function, i, pRegions[i].imageExtent.depth, block_size.depth, pRegions[i].imageOffset.z,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004753 mip_extent.depth);
Dave Houlton67e9b532017-03-02 17:00:10 -07004754 }
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004755 }
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004756 }
4757
4758 return skip;
4759}
4760
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004761static bool ValidateImageBounds(const debug_report_data *report_data, const IMAGE_STATE *image_state, const uint32_t regionCount,
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06004762 const VkBufferImageCopy *pRegions, const char *func_name, const char *msg_code) {
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004763 bool skip = false;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004764 const VkImageCreateInfo *image_info = &(image_state->createInfo);
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004765
4766 for (uint32_t i = 0; i < regionCount; i++) {
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004767 VkExtent3D extent = pRegions[i].imageExtent;
4768 VkOffset3D offset = pRegions[i].imageOffset;
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004769
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004770 if (IsExtentSizeZero(&extent)) // Warn on zero area subresource
4771 {
Dave Houlton51653902018-06-22 17:32:13 -06004772 skip |=
4773 log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)0,
4774 kVUID_Core_Image_ZeroAreaSubregion, "%s: pRegion[%d] imageExtent of {%1d, %1d, %1d} has zero area",
4775 func_name, i, extent.width, extent.height, extent.depth);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004776 }
4777
4778 VkExtent3D image_extent = GetImageSubresourceExtent(image_state, &(pRegions[i].imageSubresource));
4779
4780 // If we're using a compressed format, valid extent is rounded up to multiple of block size (per 18.1)
Dave Houlton1d2022c2017-03-29 11:43:58 -06004781 if (FormatIsCompressed(image_info->format)) {
Dave Houltona585d132019-01-18 13:05:42 -07004782 auto block_extent = FormatTexelBlockExtent(image_info->format);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004783 if (image_extent.width % block_extent.width) {
4784 image_extent.width += (block_extent.width - (image_extent.width % block_extent.width));
4785 }
4786 if (image_extent.height % block_extent.height) {
4787 image_extent.height += (block_extent.height - (image_extent.height % block_extent.height));
4788 }
4789 if (image_extent.depth % block_extent.depth) {
4790 image_extent.depth += (block_extent.depth - (image_extent.depth % block_extent.depth));
4791 }
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004792 }
4793
Dave Houltonfc1a4052017-04-27 14:32:45 -06004794 if (0 != ExceedsBounds(&offset, &extent, &image_extent)) {
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004795 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)0,
Mark Lobodzinski88529492018-04-01 10:38:15 -06004796 msg_code, "%s: pRegion[%d] exceeds image bounds..", func_name, i);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004797 }
4798 }
4799
4800 return skip;
4801}
4802
Chris Forbese8ba09a2017-06-01 17:39:02 -07004803static inline bool ValidateBufferBounds(const debug_report_data *report_data, IMAGE_STATE *image_state, BUFFER_STATE *buff_state,
Dave Houlton33c2d252017-06-09 17:08:32 -06004804 uint32_t regionCount, const VkBufferImageCopy *pRegions, const char *func_name,
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06004805 const char *msg_code) {
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004806 bool skip = false;
4807
4808 VkDeviceSize buffer_size = buff_state->createInfo.size;
4809
4810 for (uint32_t i = 0; i < regionCount; i++) {
4811 VkExtent3D copy_extent = pRegions[i].imageExtent;
4812
4813 VkDeviceSize buffer_width = (0 == pRegions[i].bufferRowLength ? copy_extent.width : pRegions[i].bufferRowLength);
4814 VkDeviceSize buffer_height = (0 == pRegions[i].bufferImageHeight ? copy_extent.height : pRegions[i].bufferImageHeight);
Dave Houltona585d132019-01-18 13:05:42 -07004815 VkDeviceSize unit_size = FormatElementSize(image_state->createInfo.format); // size (bytes) of texel or block
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004816
Dave Houltonf3229d52017-02-21 15:59:08 -07004817 // Handle special buffer packing rules for specific depth/stencil formats
4818 if (pRegions[i].imageSubresource.aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) {
Dave Houltona585d132019-01-18 13:05:42 -07004819 unit_size = FormatElementSize(VK_FORMAT_S8_UINT);
Dave Houltonf3229d52017-02-21 15:59:08 -07004820 } else if (pRegions[i].imageSubresource.aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) {
4821 switch (image_state->createInfo.format) {
4822 case VK_FORMAT_D16_UNORM_S8_UINT:
Dave Houltona585d132019-01-18 13:05:42 -07004823 unit_size = FormatElementSize(VK_FORMAT_D16_UNORM);
Dave Houltonf3229d52017-02-21 15:59:08 -07004824 break;
4825 case VK_FORMAT_D32_SFLOAT_S8_UINT:
Dave Houltona585d132019-01-18 13:05:42 -07004826 unit_size = FormatElementSize(VK_FORMAT_D32_SFLOAT);
Dave Houltonf3229d52017-02-21 15:59:08 -07004827 break;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004828 case VK_FORMAT_X8_D24_UNORM_PACK32: // Fall through
Dave Houltonf3229d52017-02-21 15:59:08 -07004829 case VK_FORMAT_D24_UNORM_S8_UINT:
4830 unit_size = 4;
4831 break;
4832 default:
4833 break;
4834 }
4835 }
4836
Tom Cooperb2550c72018-10-15 13:08:41 +01004837 if (FormatIsCompressed(image_state->createInfo.format) || FormatIsSinglePlane_422(image_state->createInfo.format)) {
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004838 // Switch to texel block units, rounding up for any partially-used blocks
Dave Houltona585d132019-01-18 13:05:42 -07004839 auto block_dim = FormatTexelBlockExtent(image_state->createInfo.format);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004840 buffer_width = (buffer_width + block_dim.width - 1) / block_dim.width;
4841 buffer_height = (buffer_height + block_dim.height - 1) / block_dim.height;
4842
4843 copy_extent.width = (copy_extent.width + block_dim.width - 1) / block_dim.width;
4844 copy_extent.height = (copy_extent.height + block_dim.height - 1) / block_dim.height;
4845 copy_extent.depth = (copy_extent.depth + block_dim.depth - 1) / block_dim.depth;
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004846 }
4847
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004848 // Either depth or layerCount may be greater than 1 (not both). This is the number of 'slices' to copy
4849 uint32_t z_copies = std::max(copy_extent.depth, pRegions[i].imageSubresource.layerCount);
4850 if (IsExtentSizeZero(&copy_extent) || (0 == z_copies)) {
Chris Forbese8ba09a2017-06-01 17:39:02 -07004851 // TODO: Issue warning here? Already warned in ValidateImageBounds()...
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004852 } else {
4853 // Calculate buffer offset of final copied byte, + 1.
4854 VkDeviceSize max_buffer_offset = (z_copies - 1) * buffer_height * buffer_width; // offset to slice
4855 max_buffer_offset += ((copy_extent.height - 1) * buffer_width) + copy_extent.width; // add row,col
4856 max_buffer_offset *= unit_size; // convert to bytes
4857 max_buffer_offset += pRegions[i].bufferOffset; // add initial offset (bytes)
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004858
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004859 if (buffer_size < max_buffer_offset) {
Mark Lobodzinski88529492018-04-01 10:38:15 -06004860 skip |=
4861 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)0,
4862 msg_code, "%s: pRegion[%d] exceeds buffer size of %" PRIu64 " bytes..", func_name, i, buffer_size);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004863 }
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004864 }
4865 }
4866
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004867 return skip;
4868}
4869
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004870bool CoreChecks::PreCallValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
4871 VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) {
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07004872 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07004873 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07004874 auto src_image_state = GetImageState(srcImage);
Mark Lobodzinski6ed74142019-03-06 11:35:39 -07004875 auto dst_buffer_state = GetBufferState(dstBuffer);
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07004876
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004877 bool skip = ValidateBufferImageCopyData(report_data, regionCount, pRegions, src_image_state, "vkCmdCopyImageToBuffer");
4878
4879 // Validate command buffer state
John Zulauf5c2750c2018-01-30 15:04:56 -07004880 skip |= ValidateCmd(device_data, cb_node, CMD_COPYIMAGETOBUFFER, "vkCmdCopyImageToBuffer()");
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004881
4882 // Command pool must support graphics, compute, or transfer operations
Mark Lobodzinski8b0a7b82019-03-06 16:17:45 -07004883 auto pPool = GetCommandPoolNode(cb_node->createInfo.commandPool);
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004884
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004885 VkQueueFlags queue_flags = GetPhysicalDeviceState()->queue_family_properties[pPool->queueFamilyIndex].queueFlags;
Mark Lobodzinskif6dd3762019-02-27 12:11:59 -07004886
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004887 if (0 == (queue_flags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT))) {
4888 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004889 HandleToUint64(cb_node->createInfo.commandPool), "VUID-vkCmdCopyImageToBuffer-commandBuffer-cmdpool",
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004890 "Cannot call vkCmdCopyImageToBuffer() on a command buffer allocated from a pool without graphics, compute, "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004891 "or transfer capabilities..");
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004892 }
Dave Houlton0ef27492018-04-04 11:41:48 -06004893 skip |= ValidateImageBounds(report_data, src_image_state, regionCount, pRegions, "vkCmdCopyImageToBuffer()",
Dave Houltond8ed0212018-05-16 17:18:24 -06004894 "VUID-vkCmdCopyImageToBuffer-pRegions-00182");
Chris Forbese8ba09a2017-06-01 17:39:02 -07004895 skip |= ValidateBufferBounds(report_data, src_image_state, dst_buffer_state, regionCount, pRegions, "vkCmdCopyImageToBuffer()",
Dave Houltond8ed0212018-05-16 17:18:24 -06004896 "VUID-vkCmdCopyImageToBuffer-pRegions-00183");
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004897
4898 skip |= ValidateImageSampleCount(device_data, src_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdCopyImageToBuffer(): srcImage",
Dave Houltond8ed0212018-05-16 17:18:24 -06004899 "VUID-vkCmdCopyImageToBuffer-srcImage-00188");
4900 skip |= ValidateMemoryIsBoundToImage(device_data, src_image_state, "vkCmdCopyImageToBuffer()",
4901 "VUID-vkCmdCopyImageToBuffer-srcImage-00187");
4902 skip |= ValidateMemoryIsBoundToBuffer(device_data, dst_buffer_state, "vkCmdCopyImageToBuffer()",
4903 "VUID-vkCmdCopyImageToBuffer-dstBuffer-00192");
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07004904
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004905 // Validate that SRC image & DST buffer have correct usage flags set
Dave Houltond8ed0212018-05-16 17:18:24 -06004906 skip |= ValidateImageUsageFlags(device_data, src_image_state, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true,
4907 "VUID-vkCmdCopyImageToBuffer-srcImage-00186", "vkCmdCopyImageToBuffer()",
4908 "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
Tobin Ehlis3c37fb32017-05-24 09:31:13 -06004909 skip |= ValidateBufferUsageFlags(device_data, dst_buffer_state, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true,
Dave Houltond8ed0212018-05-16 17:18:24 -06004910 "VUID-vkCmdCopyImageToBuffer-dstBuffer-00191", "vkCmdCopyImageToBuffer()",
4911 "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
Mark Lobodzinski96d5c6e2019-03-07 11:28:21 -07004912 if (GetApiVersion() >= VK_API_VERSION_1_1 || GetDeviceExtensions()->vk_khr_maintenance1) {
Cort Stratton186b1a22018-05-01 20:18:06 -04004913 skip |= ValidateImageFormatFeatureFlags(device_data, src_image_state, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
Shannon McPherson40c0cba2018-08-07 13:39:13 -06004914 "vkCmdCopyImageToBuffer()", "VUID-vkCmdCopyImageToBuffer-srcImage-01998",
4915 "VUID-vkCmdCopyImageToBuffer-srcImage-01998");
Cort Stratton186b1a22018-05-01 20:18:06 -04004916 }
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06004917 skip |= InsideRenderPass(device_data, cb_node, "vkCmdCopyImageToBuffer()", "VUID-vkCmdCopyImageToBuffer-renderpass");
Tobin Ehlisc8266452017-04-07 12:20:30 -06004918 bool hit_error = false;
Jeff Bolzfdd0d852019-02-03 21:55:12 -06004919 const char *src_invalid_layout_vuid =
Mark Lobodzinski60e79032019-03-07 10:22:31 -07004920 (src_image_state->shared_presentable && GetDeviceExtensions()->vk_khr_shared_presentable_image)
Cort Stratton7df30962018-05-17 19:45:57 -07004921 ? "VUID-vkCmdCopyImageToBuffer-srcImageLayout-01397"
4922 : "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00190";
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07004923 for (uint32_t i = 0; i < regionCount; ++i) {
Cort Strattond619a302018-05-17 19:46:32 -07004924 skip |= ValidateImageSubresourceLayers(device_data, cb_node, &pRegions[i].imageSubresource, "vkCmdCopyImageToBuffer()",
4925 "imageSubresource", i);
Tobin Ehlis3c37fb32017-05-24 09:31:13 -06004926 skip |= VerifyImageLayout(device_data, cb_node, src_image_state, pRegions[i].imageSubresource, srcImageLayout,
Cort Stratton7df30962018-05-17 19:45:57 -07004927 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, "vkCmdCopyImageToBuffer()", src_invalid_layout_vuid,
4928 "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00189", &hit_error);
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07004929 skip |= ValidateCopyBufferImageTransferGranularityRequirements(device_data, cb_node, src_image_state, &pRegions[i], i,
Dave Houltond8ed0212018-05-16 17:18:24 -06004930 "vkCmdCopyImageToBuffer()",
4931 "VUID-vkCmdCopyImageToBuffer-imageOffset-01794");
Cort Strattonff1542a2018-05-27 10:49:28 -07004932 skip |= ValidateImageMipLevel(device_data, cb_node, src_image_state, pRegions[i].imageSubresource.mipLevel, i,
4933 "vkCmdCopyImageToBuffer()", "imageSubresource",
4934 "VUID-vkCmdCopyImageToBuffer-imageSubresource-01703");
4935 skip |= ValidateImageArrayLayerRange(device_data, cb_node, src_image_state, pRegions[i].imageSubresource.baseArrayLayer,
4936 pRegions[i].imageSubresource.layerCount, i, "vkCmdCopyImageToBuffer()",
4937 "imageSubresource", "VUID-vkCmdCopyImageToBuffer-imageSubresource-01704");
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07004938 }
4939 return skip;
4940}
4941
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004942void CoreChecks::PreCallRecordCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
4943 VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) {
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07004944 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07004945 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07004946 auto src_image_state = GetImageState(srcImage);
Mark Lobodzinski6ed74142019-03-06 11:35:39 -07004947 auto dst_buffer_state = GetBufferState(dstBuffer);
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07004948
Tobin Ehlise35b66a2017-03-15 12:18:31 -06004949 // Make sure that all image slices are updated to correct layout
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07004950 for (uint32_t i = 0; i < regionCount; ++i) {
4951 SetImageLayout(device_data, cb_node, src_image_state, pRegions[i].imageSubresource, srcImageLayout);
Tobin Ehlise35b66a2017-03-15 12:18:31 -06004952 }
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07004953 // Update bindings between buffer/image and cmd buffer
4954 AddCommandBufferBindingImage(device_data, cb_node, src_image_state);
Mark Lobodzinski1fe9b002017-02-15 14:11:12 -07004955 AddCommandBufferBindingBuffer(device_data, cb_node, dst_buffer_state);
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004956}
4957
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004958bool CoreChecks::PreCallValidateCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
4959 VkImageLayout dstImageLayout, uint32_t regionCount,
4960 const VkBufferImageCopy *pRegions) {
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07004961 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07004962 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski6ed74142019-03-06 11:35:39 -07004963 auto src_buffer_state = GetBufferState(srcBuffer);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07004964 auto dst_image_state = GetImageState(dstImage);
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07004965
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004966 bool skip = ValidateBufferImageCopyData(report_data, regionCount, pRegions, dst_image_state, "vkCmdCopyBufferToImage");
4967
4968 // Validate command buffer state
John Zulauf5c2750c2018-01-30 15:04:56 -07004969 skip |= ValidateCmd(device_data, cb_node, CMD_COPYBUFFERTOIMAGE, "vkCmdCopyBufferToImage()");
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004970
4971 // Command pool must support graphics, compute, or transfer operations
Mark Lobodzinski8b0a7b82019-03-06 16:17:45 -07004972 auto pPool = GetCommandPoolNode(cb_node->createInfo.commandPool);
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004973 VkQueueFlags queue_flags = GetPhysicalDeviceState()->queue_family_properties[pPool->queueFamilyIndex].queueFlags;
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004974 if (0 == (queue_flags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT))) {
4975 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004976 HandleToUint64(cb_node->createInfo.commandPool), "VUID-vkCmdCopyBufferToImage-commandBuffer-cmdpool",
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004977 "Cannot call vkCmdCopyBufferToImage() on a command buffer allocated from a pool without graphics, compute, "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004978 "or transfer capabilities..");
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004979 }
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004980 skip |= ValidateImageBounds(report_data, dst_image_state, regionCount, pRegions, "vkCmdCopyBufferToImage()",
Dave Houltond8ed0212018-05-16 17:18:24 -06004981 "VUID-vkCmdCopyBufferToImage-pRegions-00172");
Chris Forbese8ba09a2017-06-01 17:39:02 -07004982 skip |= ValidateBufferBounds(report_data, dst_image_state, src_buffer_state, regionCount, pRegions, "vkCmdCopyBufferToImage()",
Dave Houltond8ed0212018-05-16 17:18:24 -06004983 "VUID-vkCmdCopyBufferToImage-pRegions-00171");
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004984 skip |= ValidateImageSampleCount(device_data, dst_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdCopyBufferToImage(): dstImage",
Dave Houltond8ed0212018-05-16 17:18:24 -06004985 "VUID-vkCmdCopyBufferToImage-dstImage-00179");
4986 skip |= ValidateMemoryIsBoundToBuffer(device_data, src_buffer_state, "vkCmdCopyBufferToImage()",
4987 "VUID-vkCmdCopyBufferToImage-srcBuffer-00176");
4988 skip |= ValidateMemoryIsBoundToImage(device_data, dst_image_state, "vkCmdCopyBufferToImage()",
4989 "VUID-vkCmdCopyBufferToImage-dstImage-00178");
Tobin Ehlis3c37fb32017-05-24 09:31:13 -06004990 skip |= ValidateBufferUsageFlags(device_data, src_buffer_state, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true,
Dave Houltond8ed0212018-05-16 17:18:24 -06004991 "VUID-vkCmdCopyBufferToImage-srcBuffer-00174", "vkCmdCopyBufferToImage()",
4992 "VK_BUFFER_USAGE_TRANSFER_SRC_BIT");
4993 skip |= ValidateImageUsageFlags(device_data, dst_image_state, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true,
4994 "VUID-vkCmdCopyBufferToImage-dstImage-00177", "vkCmdCopyBufferToImage()",
4995 "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
Mark Lobodzinski96d5c6e2019-03-07 11:28:21 -07004996 if (GetApiVersion() >= VK_API_VERSION_1_1 || GetDeviceExtensions()->vk_khr_maintenance1) {
Cort Stratton186b1a22018-05-01 20:18:06 -04004997 skip |= ValidateImageFormatFeatureFlags(device_data, dst_image_state, VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
Shannon McPherson40c0cba2018-08-07 13:39:13 -06004998 "vkCmdCopyBufferToImage()", "VUID-vkCmdCopyBufferToImage-dstImage-01997",
4999 "VUID-vkCmdCopyBufferToImage-dstImage-01997");
Cort Stratton186b1a22018-05-01 20:18:06 -04005000 }
Shannon McPhersonc06c33d2018-06-28 17:21:12 -06005001 skip |= InsideRenderPass(device_data, cb_node, "vkCmdCopyBufferToImage()", "VUID-vkCmdCopyBufferToImage-renderpass");
Tobin Ehlisc8266452017-04-07 12:20:30 -06005002 bool hit_error = false;
Jeff Bolzfdd0d852019-02-03 21:55:12 -06005003 const char *dst_invalid_layout_vuid =
Mark Lobodzinski60e79032019-03-07 10:22:31 -07005004 (dst_image_state->shared_presentable && GetDeviceExtensions()->vk_khr_shared_presentable_image)
Cort Stratton7df30962018-05-17 19:45:57 -07005005 ? "VUID-vkCmdCopyBufferToImage-dstImageLayout-01396"
5006 : "VUID-vkCmdCopyBufferToImage-dstImageLayout-00181";
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07005007 for (uint32_t i = 0; i < regionCount; ++i) {
Cort Strattond619a302018-05-17 19:46:32 -07005008 skip |= ValidateImageSubresourceLayers(device_data, cb_node, &pRegions[i].imageSubresource, "vkCmdCopyBufferToImage()",
5009 "imageSubresource", i);
Tobin Ehlis3c37fb32017-05-24 09:31:13 -06005010 skip |= VerifyImageLayout(device_data, cb_node, dst_image_state, pRegions[i].imageSubresource, dstImageLayout,
Cort Stratton7df30962018-05-17 19:45:57 -07005011 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, "vkCmdCopyBufferToImage()", dst_invalid_layout_vuid,
5012 "VUID-vkCmdCopyBufferToImage-dstImageLayout-00180", &hit_error);
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07005013 skip |= ValidateCopyBufferImageTransferGranularityRequirements(device_data, cb_node, dst_image_state, &pRegions[i], i,
Dave Houltond8ed0212018-05-16 17:18:24 -06005014 "vkCmdCopyBufferToImage()",
5015 "VUID-vkCmdCopyBufferToImage-imageOffset-01793");
Cort Strattonff1542a2018-05-27 10:49:28 -07005016 skip |= ValidateImageMipLevel(device_data, cb_node, dst_image_state, pRegions[i].imageSubresource.mipLevel, i,
5017 "vkCmdCopyBufferToImage()", "imageSubresource",
5018 "VUID-vkCmdCopyBufferToImage-imageSubresource-01701");
5019 skip |= ValidateImageArrayLayerRange(device_data, cb_node, dst_image_state, pRegions[i].imageSubresource.baseArrayLayer,
5020 pRegions[i].imageSubresource.layerCount, i, "vkCmdCopyBufferToImage()",
5021 "imageSubresource", "VUID-vkCmdCopyBufferToImage-imageSubresource-01702");
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07005022 }
5023 return skip;
5024}
5025
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07005026void CoreChecks::PreCallRecordCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
5027 VkImageLayout dstImageLayout, uint32_t regionCount,
5028 const VkBufferImageCopy *pRegions) {
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07005029 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
Mark Lobodzinski1b3a9712019-03-06 15:51:47 -07005030 auto cb_node = GetCBNode(commandBuffer);
Mark Lobodzinski6ed74142019-03-06 11:35:39 -07005031 auto src_buffer_state = GetBufferState(srcBuffer);
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07005032 auto dst_image_state = GetImageState(dstImage);
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07005033
Tobin Ehlise35b66a2017-03-15 12:18:31 -06005034 // Make sure that all image slices are updated to correct layout
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07005035 for (uint32_t i = 0; i < regionCount; ++i) {
5036 SetImageLayout(device_data, cb_node, dst_image_state, pRegions[i].imageSubresource, dstImageLayout);
Tobin Ehlise35b66a2017-03-15 12:18:31 -06005037 }
Mark Lobodzinski1fe9b002017-02-15 14:11:12 -07005038 AddCommandBufferBindingBuffer(device_data, cb_node, src_buffer_state);
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07005039 AddCommandBufferBindingImage(device_data, cb_node, dst_image_state);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07005040}
Mike Weiblen672b58b2017-02-21 14:32:53 -07005041
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07005042bool CoreChecks::PreCallValidateGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource,
5043 VkSubresourceLayout *pLayout) {
Mark Lobodzinski6b35c8a2019-01-10 10:57:27 -07005044 layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
5045 const auto report_data = device_data->report_data;
Mike Weiblen672b58b2017-02-21 14:32:53 -07005046 bool skip = false;
5047 const VkImageAspectFlags sub_aspect = pSubresource->aspectMask;
5048
Dave Houlton1d960ff2018-01-19 12:17:05 -07005049 // The aspectMask member of pSubresource must only have a single bit set
Mike Weiblen672b58b2017-02-21 14:32:53 -07005050 const int num_bits = sizeof(sub_aspect) * CHAR_BIT;
5051 std::bitset<num_bits> aspect_mask_bits(sub_aspect);
5052 if (aspect_mask_bits.count() != 1) {
Petr Krausbc7f5442017-05-14 23:43:38 +02005053 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image),
Dave Houltond8ed0212018-05-16 17:18:24 -06005054 "VUID-vkGetImageSubresourceLayout-aspectMask-00997",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06005055 "vkGetImageSubresourceLayout(): VkImageSubresource.aspectMask must have exactly 1 bit set.");
Mike Weiblen672b58b2017-02-21 14:32:53 -07005056 }
5057
Mark Lobodzinski8ddc23f2019-03-06 11:48:49 -07005058 IMAGE_STATE *image_entry = GetImageState(image);
Mike Weiblen672b58b2017-02-21 14:32:53 -07005059 if (!image_entry) {
5060 return skip;
5061 }
5062
Dave Houlton1d960ff2018-01-19 12:17:05 -07005063 // image must have been created with tiling equal to VK_IMAGE_TILING_LINEAR
Mike Weiblen672b58b2017-02-21 14:32:53 -07005064 if (image_entry->createInfo.tiling != VK_IMAGE_TILING_LINEAR) {
Dave Houltond8ed0212018-05-16 17:18:24 -06005065 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image),
5066 "VUID-vkGetImageSubresourceLayout-image-00996",
5067 "vkGetImageSubresourceLayout(): Image must have tiling of VK_IMAGE_TILING_LINEAR.");
Mike Weiblen672b58b2017-02-21 14:32:53 -07005068 }
5069
Dave Houlton1d960ff2018-01-19 12:17:05 -07005070 // mipLevel must be less than the mipLevels specified in VkImageCreateInfo when the image was created
Mike Weiblen672b58b2017-02-21 14:32:53 -07005071 if (pSubresource->mipLevel >= image_entry->createInfo.mipLevels) {
Dave Houltond8ed0212018-05-16 17:18:24 -06005072 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image),
5073 "VUID-vkGetImageSubresourceLayout-mipLevel-01716",
5074 "vkGetImageSubresourceLayout(): pSubresource.mipLevel (%d) must be less than %d.", pSubresource->mipLevel,
5075 image_entry->createInfo.mipLevels);
Mike Weiblen672b58b2017-02-21 14:32:53 -07005076 }
5077
Dave Houlton1d960ff2018-01-19 12:17:05 -07005078 // arrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when the image was created
Mike Weiblen672b58b2017-02-21 14:32:53 -07005079 if (pSubresource->arrayLayer >= image_entry->createInfo.arrayLayers) {
Dave Houltond8ed0212018-05-16 17:18:24 -06005080 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image),
5081 "VUID-vkGetImageSubresourceLayout-arrayLayer-01717",
5082 "vkGetImageSubresourceLayout(): pSubresource.arrayLayer (%d) must be less than %d.",
5083 pSubresource->arrayLayer, image_entry->createInfo.arrayLayers);
Mike Weiblen672b58b2017-02-21 14:32:53 -07005084 }
5085
Dave Houlton1d960ff2018-01-19 12:17:05 -07005086 // subresource's aspect must be compatible with image's format.
Mike Weiblen672b58b2017-02-21 14:32:53 -07005087 const VkFormat img_format = image_entry->createInfo.format;
Dave Houlton1d960ff2018-01-19 12:17:05 -07005088 if (FormatIsMultiplane(img_format)) {
5089 VkImageAspectFlags allowed_flags = (VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR);
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06005090 const char *vuid = "VUID-vkGetImageSubresourceLayout-format-01581"; // 2-plane version
Dave Houlton1d960ff2018-01-19 12:17:05 -07005091 if (FormatPlaneCount(img_format) > 2u) {
5092 allowed_flags |= VK_IMAGE_ASPECT_PLANE_2_BIT_KHR;
Dave Houltond8ed0212018-05-16 17:18:24 -06005093 vuid = "VUID-vkGetImageSubresourceLayout-format-01582"; // 3-plane version
Dave Houlton1d960ff2018-01-19 12:17:05 -07005094 }
5095 if (sub_aspect != (sub_aspect & allowed_flags)) {
5096 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06005097 HandleToUint64(image), vuid,
Dave Houlton1d960ff2018-01-19 12:17:05 -07005098 "vkGetImageSubresourceLayout(): For multi-planar images, VkImageSubresource.aspectMask (0x%" PRIx32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06005099 ") must be a single-plane specifier flag.",
5100 sub_aspect);
Dave Houlton1d960ff2018-01-19 12:17:05 -07005101 }
5102 } else if (FormatIsColor(img_format)) {
Mike Weiblen672b58b2017-02-21 14:32:53 -07005103 if (sub_aspect != VK_IMAGE_ASPECT_COLOR_BIT) {
Dave Houlton852287e2018-01-19 15:11:51 -07005104 skip |= log_msg(
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06005105 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image),
Dave Houltond8ed0212018-05-16 17:18:24 -06005106 "VUID-VkImageSubresource-aspectMask-parameter",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06005107 "vkGetImageSubresourceLayout(): For color formats, VkImageSubresource.aspectMask must be VK_IMAGE_ASPECT_COLOR.");
Mike Weiblen672b58b2017-02-21 14:32:53 -07005108 }
Dave Houlton1d2022c2017-03-29 11:43:58 -06005109 } else if (FormatIsDepthOrStencil(img_format)) {
Mike Weiblen672b58b2017-02-21 14:32:53 -07005110 if ((sub_aspect != VK_IMAGE_ASPECT_DEPTH_BIT) && (sub_aspect != VK_IMAGE_ASPECT_STENCIL_BIT)) {
Mark Lobodzinski0827aec2017-03-21 16:41:45 -06005111 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06005112 HandleToUint64(image), "VUID-VkImageSubresource-aspectMask-parameter",
Mike Weiblen672b58b2017-02-21 14:32:53 -07005113 "vkGetImageSubresourceLayout(): For depth/stencil formats, VkImageSubresource.aspectMask must be "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06005114 "either VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT.");
Mike Weiblen672b58b2017-02-21 14:32:53 -07005115 }
5116 }
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06005117
Mark Lobodzinski60e79032019-03-07 10:22:31 -07005118 if (GetDeviceExtensions()->vk_android_external_memory_android_hardware_buffer) {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06005119 skip |= ValidateGetImageSubresourceLayoutANDROID(device_data, image);
5120 }
5121
Mike Weiblen672b58b2017-02-21 14:32:53 -07005122 return skip;
5123}