blob: c3af96ae81c16a873f8973ac4d64649f0904409a [file] [log] [blame]
Mark Lobodzinskid42e4d22017-01-17 14:14:22 -07001/* Copyright (c) 2015-2017 The Khronos Group Inc.
2 * Copyright (c) 2015-2017 Valve Corporation
3 * Copyright (c) 2015-2017 LunarG, Inc.
4 * Copyright (C) 2015-2017 Google Inc.
5 *
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>
Mark Lobodzinskid42e4d22017-01-17 14:14:22 -070020 */
21
22// Allow use of STL min and max functions in Windows
23#define NOMINMAX
24
Mark Lobodzinski90224de2017-01-26 15:23:11 -070025#include <sstream>
Petr Kraus4d718682017-05-18 03:38:41 +020026#include <string>
Mark Lobodzinski90224de2017-01-26 15:23:11 -070027
28#include "vk_enum_string_helper.h"
29#include "vk_layer_data.h"
30#include "vk_layer_utils.h"
31#include "vk_layer_logging.h"
Dave Houltonbd2e2622018-04-10 16:41:14 -060032#include "vk_typemap_helper.h"
Mark Lobodzinski90224de2017-01-26 15:23:11 -070033
Mark Lobodzinskid42e4d22017-01-17 14:14:22 -070034#include "buffer_validation.h"
Mark Lobodzinski42fe5f72017-01-11 11:36:16 -070035
Tobin Ehlis58c884f2017-02-08 12:15:27 -070036void SetLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair, const VkImageLayout &layout) {
Dave Houltonb3f4b282018-02-22 16:25:16 -070037 auto it = pCB->imageLayoutMap.find(imgpair);
38 if (it != pCB->imageLayoutMap.end()) {
39 it->second.layout = layout;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -070040 } else {
41 assert(imgpair.hasSubresource);
42 IMAGE_CMD_BUF_LAYOUT_NODE node;
43 if (!FindCmdBufLayout(device_data, pCB, imgpair.image, imgpair.subresource, node)) {
44 node.initialLayout = layout;
45 }
46 SetLayout(device_data, pCB, imgpair, {node.initialLayout, layout});
47 }
48}
49template <class OBJECT, class LAYOUT>
Tobin Ehlis58c884f2017-02-08 12:15:27 -070050void SetLayout(layer_data *device_data, OBJECT *pObject, VkImage image, VkImageSubresource range, const LAYOUT &layout) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -070051 ImageSubresourcePair imgpair = {image, true, range};
52 SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_COLOR_BIT);
53 SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_DEPTH_BIT);
54 SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_STENCIL_BIT);
55 SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_METADATA_BIT);
Dave Houltonb3f4b282018-02-22 16:25:16 -070056 if (GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) {
57 SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR);
58 SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR);
59 SetLayout(device_data, pObject, imgpair, layout, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
60 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -070061}
62
63template <class OBJECT, class LAYOUT>
Tobin Ehlis58c884f2017-02-08 12:15:27 -070064void SetLayout(layer_data *device_data, OBJECT *pObject, ImageSubresourcePair imgpair, const LAYOUT &layout,
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -070065 VkImageAspectFlags aspectMask) {
66 if (imgpair.subresource.aspectMask & aspectMask) {
67 imgpair.subresource.aspectMask = aspectMask;
68 SetLayout(device_data, pObject, imgpair, layout);
69 }
70}
71
Tony Barbourdf013b92017-01-25 12:53:48 -070072// Set the layout in supplied map
Tony Barboure0c5cc92017-02-08 13:53:39 -070073void SetLayout(std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_NODE> &imageLayoutMap, ImageSubresourcePair imgpair,
74 VkImageLayout layout) {
Dave Houltonb3f4b282018-02-22 16:25:16 -070075 auto it = imageLayoutMap.find(imgpair);
76 if (it != imageLayoutMap.end()) {
77 it->second.layout = layout; // Update
78 } else {
79 imageLayoutMap[imgpair].layout = layout; // Insert
80 }
Tony Barbourdf013b92017-01-25 12:53:48 -070081}
82
Tobin Ehlisc8266452017-04-07 12:20:30 -060083bool FindLayoutVerifyNode(layer_data const *device_data, GLOBAL_CB_NODE const *pCB, ImageSubresourcePair imgpair,
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -070084 IMAGE_CMD_BUF_LAYOUT_NODE &node, const VkImageAspectFlags aspectMask) {
85 const debug_report_data *report_data = core_validation::GetReportData(device_data);
86
87 if (!(imgpair.subresource.aspectMask & aspectMask)) {
88 return false;
89 }
90 VkImageAspectFlags oldAspectMask = imgpair.subresource.aspectMask;
91 imgpair.subresource.aspectMask = aspectMask;
92 auto imgsubIt = pCB->imageLayoutMap.find(imgpair);
93 if (imgsubIt == pCB->imageLayoutMap.end()) {
94 return false;
95 }
96 if (node.layout != VK_IMAGE_LAYOUT_MAX_ENUM && node.layout != imgsubIt->second.layout) {
Petr Krausbc7f5442017-05-14 23:43:38 +020097 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(imgpair.image),
Mark Lobodzinski88529492018-04-01 10:38:15 -060098 DRAWSTATE_INVALID_LAYOUT,
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -070099 "Cannot query for VkImage 0x%" PRIx64 " layout when combined aspect mask %d has multiple layout types: %s and %s",
Petr Krausbc7f5442017-05-14 23:43:38 +0200100 HandleToUint64(imgpair.image), oldAspectMask, string_VkImageLayout(node.layout),
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700101 string_VkImageLayout(imgsubIt->second.layout));
102 }
103 if (node.initialLayout != VK_IMAGE_LAYOUT_MAX_ENUM && node.initialLayout != imgsubIt->second.initialLayout) {
Petr Krausbc7f5442017-05-14 23:43:38 +0200104 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(imgpair.image),
Mark Lobodzinski88529492018-04-01 10:38:15 -0600105 DRAWSTATE_INVALID_LAYOUT,
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700106 "Cannot query for VkImage 0x%" PRIx64
107 " layout when combined aspect mask %d has multiple initial layout types: %s and %s",
Petr Krausbc7f5442017-05-14 23:43:38 +0200108 HandleToUint64(imgpair.image), oldAspectMask, string_VkImageLayout(node.initialLayout),
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700109 string_VkImageLayout(imgsubIt->second.initialLayout));
110 }
111 node = imgsubIt->second;
112 return true;
113}
114
Tobin Ehlisc8266452017-04-07 12:20:30 -0600115bool FindLayoutVerifyLayout(layer_data const *device_data, ImageSubresourcePair imgpair, VkImageLayout &layout,
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700116 const VkImageAspectFlags aspectMask) {
117 if (!(imgpair.subresource.aspectMask & aspectMask)) {
118 return false;
119 }
120 const debug_report_data *report_data = core_validation::GetReportData(device_data);
121 VkImageAspectFlags oldAspectMask = imgpair.subresource.aspectMask;
122 imgpair.subresource.aspectMask = aspectMask;
123 auto imgsubIt = (*core_validation::GetImageLayoutMap(device_data)).find(imgpair);
124 if (imgsubIt == (*core_validation::GetImageLayoutMap(device_data)).end()) {
125 return false;
126 }
127 if (layout != VK_IMAGE_LAYOUT_MAX_ENUM && layout != imgsubIt->second.layout) {
Petr Krausbc7f5442017-05-14 23:43:38 +0200128 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(imgpair.image),
Mark Lobodzinski88529492018-04-01 10:38:15 -0600129 DRAWSTATE_INVALID_LAYOUT,
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700130 "Cannot query for VkImage 0x%" PRIx64 " layout when combined aspect mask %d has multiple layout types: %s and %s",
Petr Krausbc7f5442017-05-14 23:43:38 +0200131 HandleToUint64(imgpair.image), oldAspectMask, string_VkImageLayout(layout),
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700132 string_VkImageLayout(imgsubIt->second.layout));
133 }
134 layout = imgsubIt->second.layout;
135 return true;
136}
137
138// Find layout(s) on the command buffer level
Tobin Ehlisc8266452017-04-07 12:20:30 -0600139bool FindCmdBufLayout(layer_data const *device_data, GLOBAL_CB_NODE const *pCB, VkImage image, VkImageSubresource range,
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700140 IMAGE_CMD_BUF_LAYOUT_NODE &node) {
141 ImageSubresourcePair imgpair = {image, true, range};
142 node = IMAGE_CMD_BUF_LAYOUT_NODE(VK_IMAGE_LAYOUT_MAX_ENUM, VK_IMAGE_LAYOUT_MAX_ENUM);
143 FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_COLOR_BIT);
144 FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_DEPTH_BIT);
145 FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_STENCIL_BIT);
146 FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_METADATA_BIT);
Dave Houltonb3f4b282018-02-22 16:25:16 -0700147 if (GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) {
148 FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR);
149 FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR);
150 FindLayoutVerifyNode(device_data, pCB, imgpair, node, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
151 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700152 if (node.layout == VK_IMAGE_LAYOUT_MAX_ENUM) {
153 imgpair = {image, false, VkImageSubresource()};
154 auto imgsubIt = pCB->imageLayoutMap.find(imgpair);
155 if (imgsubIt == pCB->imageLayoutMap.end()) return false;
156 // TODO: This is ostensibly a find function but it changes state here
157 node = imgsubIt->second;
158 }
159 return true;
160}
161
162// Find layout(s) on the global level
Tobin Ehlis58c884f2017-02-08 12:15:27 -0700163bool FindGlobalLayout(layer_data *device_data, ImageSubresourcePair imgpair, VkImageLayout &layout) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700164 layout = VK_IMAGE_LAYOUT_MAX_ENUM;
165 FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_COLOR_BIT);
166 FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_DEPTH_BIT);
167 FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_STENCIL_BIT);
168 FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_METADATA_BIT);
Dave Houltonb3f4b282018-02-22 16:25:16 -0700169 if (GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) {
170 FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR);
171 FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR);
172 FindLayoutVerifyLayout(device_data, imgpair, layout, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
173 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700174 if (layout == VK_IMAGE_LAYOUT_MAX_ENUM) {
175 imgpair = {imgpair.image, false, VkImageSubresource()};
176 auto imgsubIt = (*core_validation::GetImageLayoutMap(device_data)).find(imgpair);
177 if (imgsubIt == (*core_validation::GetImageLayoutMap(device_data)).end()) return false;
178 layout = imgsubIt->second.layout;
179 }
180 return true;
181}
182
Tobin Ehlis58c884f2017-02-08 12:15:27 -0700183bool FindLayouts(layer_data *device_data, VkImage image, std::vector<VkImageLayout> &layouts) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700184 auto sub_data = (*core_validation::GetImageSubresourceMap(device_data)).find(image);
185 if (sub_data == (*core_validation::GetImageSubresourceMap(device_data)).end()) return false;
Tobin Ehlisb2e1e2c2017-02-08 09:16:32 -0700186 auto image_state = GetImageState(device_data, image);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700187 if (!image_state) return false;
188 bool ignoreGlobal = false;
189 // TODO: Make this robust for >1 aspect mask. Now it will just say ignore potential errors in this case.
190 if (sub_data->second.size() >= (image_state->createInfo.arrayLayers * image_state->createInfo.mipLevels + 1)) {
191 ignoreGlobal = true;
192 }
193 for (auto imgsubpair : sub_data->second) {
194 if (ignoreGlobal && !imgsubpair.hasSubresource) continue;
195 auto img_data = (*core_validation::GetImageLayoutMap(device_data)).find(imgsubpair);
196 if (img_data != (*core_validation::GetImageLayoutMap(device_data)).end()) {
197 layouts.push_back(img_data->second.layout);
198 }
199 }
200 return true;
201}
Tony Barboure0c5cc92017-02-08 13:53:39 -0700202bool FindLayout(const std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_NODE> &imageLayoutMap, ImageSubresourcePair imgpair,
203 VkImageLayout &layout, const VkImageAspectFlags aspectMask) {
Tony Barbourdf013b92017-01-25 12:53:48 -0700204 if (!(imgpair.subresource.aspectMask & aspectMask)) {
205 return false;
206 }
207 imgpair.subresource.aspectMask = aspectMask;
208 auto imgsubIt = imageLayoutMap.find(imgpair);
209 if (imgsubIt == imageLayoutMap.end()) {
210 return false;
211 }
212 layout = imgsubIt->second.layout;
213 return true;
Tony Barboure0c5cc92017-02-08 13:53:39 -0700214}
Tony Barbourdf013b92017-01-25 12:53:48 -0700215
216// find layout in supplied map
Dave Houltonb3f4b282018-02-22 16:25:16 -0700217bool FindLayout(layer_data *device_data, const std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_NODE> &imageLayoutMap,
218 ImageSubresourcePair imgpair, VkImageLayout &layout) {
Tony Barbourdf013b92017-01-25 12:53:48 -0700219 layout = VK_IMAGE_LAYOUT_MAX_ENUM;
220 FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_COLOR_BIT);
221 FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_DEPTH_BIT);
222 FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_STENCIL_BIT);
223 FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_METADATA_BIT);
Dave Houltonb3f4b282018-02-22 16:25:16 -0700224 if (GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) {
225 FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR);
226 FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR);
227 FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
228 }
229 // Image+subresource not found, look for image handle w/o subresource
Tony Barbourdf013b92017-01-25 12:53:48 -0700230 if (layout == VK_IMAGE_LAYOUT_MAX_ENUM) {
231 imgpair = {imgpair.image, false, VkImageSubresource()};
232 auto imgsubIt = imageLayoutMap.find(imgpair);
233 if (imgsubIt == imageLayoutMap.end()) return false;
234 layout = imgsubIt->second.layout;
235 }
236 return true;
237}
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700238
239// Set the layout on the global level
Tobin Ehlis58c884f2017-02-08 12:15:27 -0700240void SetGlobalLayout(layer_data *device_data, ImageSubresourcePair imgpair, const VkImageLayout &layout) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700241 VkImage &image = imgpair.image;
Dave Houltonb3f4b282018-02-22 16:25:16 -0700242 auto &lmap = (*core_validation::GetImageLayoutMap(device_data));
243 auto data = lmap.find(imgpair);
244 if (data != lmap.end()) {
245 data->second.layout = layout; // Update
246 } else {
247 lmap[imgpair].layout = layout; // Insert
248 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700249 auto &image_subresources = (*core_validation::GetImageSubresourceMap(device_data))[image];
250 auto subresource = std::find(image_subresources.begin(), image_subresources.end(), imgpair);
251 if (subresource == image_subresources.end()) {
252 image_subresources.push_back(imgpair);
253 }
254}
255
256// Set the layout on the cmdbuf level
Tobin Ehlis58c884f2017-02-08 12:15:27 -0700257void SetLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair, const IMAGE_CMD_BUF_LAYOUT_NODE &node) {
Dave Houltonb3f4b282018-02-22 16:25:16 -0700258 auto it = pCB->imageLayoutMap.find(imgpair);
259 if (it != pCB->imageLayoutMap.end()) {
260 it->second = node; // Update
261 } else {
262 pCB->imageLayoutMap[imgpair] = node; // Insert
263 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700264}
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600265// Set image layout for given VkImageSubresourceRange struct
266void SetImageLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, const IMAGE_STATE *image_state,
267 VkImageSubresourceRange image_subresource_range, const VkImageLayout &layout) {
268 assert(image_state);
John Zulauf48a6a702017-12-22 17:14:54 -0700269 cb_node->image_layout_change_count++; // Change the version of this data to force revalidation
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600270 for (uint32_t level_index = 0; level_index < image_subresource_range.levelCount; ++level_index) {
271 uint32_t level = image_subresource_range.baseMipLevel + level_index;
272 for (uint32_t layer_index = 0; layer_index < image_subresource_range.layerCount; layer_index++) {
273 uint32_t layer = image_subresource_range.baseArrayLayer + layer_index;
274 VkImageSubresource sub = {image_subresource_range.aspectMask, level, layer};
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700275 // TODO: If ImageView was created with depth or stencil, transition both layouts as the aspectMask is ignored and both
276 // are used. Verify that the extra implicit layout is OK for descriptor set layout validation
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600277 if (image_subresource_range.aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
Dave Houlton1d2022c2017-03-29 11:43:58 -0600278 if (FormatIsDepthAndStencil(image_state->createInfo.format)) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700279 sub.aspectMask |= (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
280 }
281 }
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600282 SetLayout(device_data, cb_node, image_state->image, sub, layout);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700283 }
284 }
285}
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600286// Set image layout for given VkImageSubresourceLayers struct
287void SetImageLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, const IMAGE_STATE *image_state,
288 VkImageSubresourceLayers image_subresource_layers, const VkImageLayout &layout) {
289 // Transfer VkImageSubresourceLayers into VkImageSubresourceRange struct
290 VkImageSubresourceRange image_subresource_range;
291 image_subresource_range.aspectMask = image_subresource_layers.aspectMask;
292 image_subresource_range.baseArrayLayer = image_subresource_layers.baseArrayLayer;
293 image_subresource_range.layerCount = image_subresource_layers.layerCount;
294 image_subresource_range.baseMipLevel = image_subresource_layers.mipLevel;
295 image_subresource_range.levelCount = 1;
296 SetImageLayout(device_data, cb_node, image_state, image_subresource_range, layout);
297}
Dave Houltonddd65c52018-05-08 14:58:01 -0600298
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600299// Set image layout for all slices of an image view
300void SetImageViewLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, VkImageView imageView, const VkImageLayout &layout) {
301 auto view_state = GetImageViewState(device_data, imageView);
302 assert(view_state);
303
Dave Houltonddd65c52018-05-08 14:58:01 -0600304 IMAGE_STATE *image_state = GetImageState(device_data, view_state->create_info.image);
305 VkImageSubresourceRange sub_range = view_state->create_info.subresourceRange;
306
307 // When changing the layout of a 3D image subresource via a 2D or 2D_ARRRAY image view, all depth slices of
308 // the subresource mip level(s) are transitioned, ignoring any layers restriction in the subresource info.
309 if ((image_state->createInfo.imageType == VK_IMAGE_TYPE_3D) && (view_state->create_info.viewType != VK_IMAGE_VIEW_TYPE_3D)) {
310 sub_range.baseArrayLayer = 0;
311 sub_range.layerCount = image_state->createInfo.extent.depth;
312 }
313
314 SetImageLayout(device_data, cb_node, image_state, sub_range, layout);
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600315}
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700316
Tobin Ehlis58c884f2017-02-08 12:15:27 -0700317bool VerifyFramebufferAndRenderPassLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB,
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700318 const VkRenderPassBeginInfo *pRenderPassBegin,
319 const FRAMEBUFFER_STATE *framebuffer_state) {
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600320 bool skip = false;
Tobin Ehlisb2e1e2c2017-02-08 09:16:32 -0700321 auto const pRenderPassInfo = GetRenderPassState(device_data, pRenderPassBegin->renderPass)->createInfo.ptr();
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700322 auto const &framebufferInfo = framebuffer_state->createInfo;
323 const auto report_data = core_validation::GetReportData(device_data);
324 if (pRenderPassInfo->attachmentCount != framebufferInfo.attachmentCount) {
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600325 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -0600326 HandleToUint64(pCB->commandBuffer), DRAWSTATE_INVALID_RENDERPASS,
Dave Houltona9df0ce2018-02-07 10:51:23 -0700327 "You cannot start a render pass using a framebuffer with a different number of attachments.");
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700328 }
329 for (uint32_t i = 0; i < pRenderPassInfo->attachmentCount; ++i) {
330 const VkImageView &image_view = framebufferInfo.pAttachments[i];
Tobin Ehlisb2e1e2c2017-02-08 09:16:32 -0700331 auto view_state = GetImageViewState(device_data, image_view);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700332 assert(view_state);
333 const VkImage &image = view_state->create_info.image;
334 const VkImageSubresourceRange &subRange = view_state->create_info.subresourceRange;
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700335 auto initial_layout = pRenderPassInfo->pAttachments[i].initialLayout;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700336 // TODO: Do not iterate over every possibility - consolidate where possible
337 for (uint32_t j = 0; j < subRange.levelCount; j++) {
338 uint32_t level = subRange.baseMipLevel + j;
339 for (uint32_t k = 0; k < subRange.layerCount; k++) {
340 uint32_t layer = subRange.baseArrayLayer + k;
341 VkImageSubresource sub = {subRange.aspectMask, level, layer};
342 IMAGE_CMD_BUF_LAYOUT_NODE node;
343 if (!FindCmdBufLayout(device_data, pCB, image, sub, node)) {
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700344 // Missing layouts will be added during state update
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700345 continue;
346 }
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700347 if (initial_layout != VK_IMAGE_LAYOUT_UNDEFINED && initial_layout != node.layout) {
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600348 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Mark Lobodzinski88529492018-04-01 10:38:15 -0600349 DRAWSTATE_INVALID_RENDERPASS,
Dave Houltona9df0ce2018-02-07 10:51:23 -0700350 "You cannot start a render pass using attachment %u where the render pass initial layout is %s "
351 "and the previous known layout of the attachment is %s. The layouts must match, or the render "
352 "pass initial layout for the attachment must be VK_IMAGE_LAYOUT_UNDEFINED",
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600353 i, string_VkImageLayout(initial_layout), string_VkImageLayout(node.layout));
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700354 }
355 }
356 }
357 }
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600358 return skip;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700359}
360
Tobin Ehlis58c884f2017-02-08 12:15:27 -0700361void TransitionAttachmentRefLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, FRAMEBUFFER_STATE *pFramebuffer,
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700362 VkAttachmentReference ref) {
363 if (ref.attachment != VK_ATTACHMENT_UNUSED) {
364 auto image_view = pFramebuffer->createInfo.pAttachments[ref.attachment];
365 SetImageViewLayout(device_data, pCB, image_view, ref.layout);
366 }
367}
368
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700369void TransitionSubpassLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB, const RENDER_PASS_STATE *render_pass_state,
Tobin Ehlis58c884f2017-02-08 12:15:27 -0700370 const int subpass_index, FRAMEBUFFER_STATE *framebuffer_state) {
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700371 assert(render_pass_state);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700372
373 if (framebuffer_state) {
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700374 auto const &subpass = render_pass_state->createInfo.pSubpasses[subpass_index];
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700375 for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) {
376 TransitionAttachmentRefLayout(device_data, pCB, framebuffer_state, subpass.pInputAttachments[j]);
377 }
378 for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) {
379 TransitionAttachmentRefLayout(device_data, pCB, framebuffer_state, subpass.pColorAttachments[j]);
380 }
381 if (subpass.pDepthStencilAttachment) {
382 TransitionAttachmentRefLayout(device_data, pCB, framebuffer_state, *subpass.pDepthStencilAttachment);
383 }
384 }
385}
386
Tobin Ehlis9c0df962017-07-17 10:14:27 -0600387bool ValidateImageAspectLayout(layer_data *device_data, GLOBAL_CB_NODE const *pCB, const VkImageMemoryBarrier *mem_barrier,
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -0700388 uint32_t level, uint32_t layer, VkImageAspectFlags aspect) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700389 if (!(mem_barrier->subresourceRange.aspectMask & aspect)) {
390 return false;
391 }
392 VkImageSubresource sub = {aspect, level, layer};
393 IMAGE_CMD_BUF_LAYOUT_NODE node;
394 if (!FindCmdBufLayout(device_data, pCB, mem_barrier->image, sub, node)) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700395 return false;
396 }
397 bool skip = false;
398 if (mem_barrier->oldLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
399 // TODO: Set memory invalid which is in mem_tracker currently
400 } else if (node.layout != mem_barrier->oldLayout) {
Dave Houltond8ed0212018-05-16 17:18:24 -0600401 skip = log_msg(core_validation::GetReportData(device_data), VK_DEBUG_REPORT_ERROR_BIT_EXT,
402 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(pCB->commandBuffer),
403 "VUID-VkImageMemoryBarrier-oldLayout-01197",
404 "For image 0x%" PRIx64
405 " you cannot transition the layout of aspect=%d level=%d layer=%d from %s when current layout is %s.",
406 HandleToUint64(mem_barrier->image), aspect, level, layer, string_VkImageLayout(mem_barrier->oldLayout),
407 string_VkImageLayout(node.layout));
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700408 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700409 return skip;
410}
411
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700412// Transition the layout state for renderpass attachments based on the BeginRenderPass() call. This includes:
413// 1. Transition into initialLayout state
414// 2. Transition from initialLayout to layout used in subpass 0
415void TransitionBeginRenderPassLayouts(layer_data *device_data, GLOBAL_CB_NODE *cb_state, const RENDER_PASS_STATE *render_pass_state,
416 FRAMEBUFFER_STATE *framebuffer_state) {
417 // First transition into initialLayout
418 auto const rpci = render_pass_state->createInfo.ptr();
419 for (uint32_t i = 0; i < rpci->attachmentCount; ++i) {
420 VkImageView image_view = framebuffer_state->createInfo.pAttachments[i];
421 SetImageViewLayout(device_data, cb_state, image_view, rpci->pAttachments[i].initialLayout);
422 }
423 // Now transition for first subpass (index 0)
424 TransitionSubpassLayouts(device_data, cb_state, render_pass_state, 0, framebuffer_state);
425}
426
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -0700427void TransitionImageAspectLayout(layer_data *device_data, GLOBAL_CB_NODE *pCB, const VkImageMemoryBarrier *mem_barrier,
428 uint32_t level, uint32_t layer, VkImageAspectFlags aspect) {
429 if (!(mem_barrier->subresourceRange.aspectMask & aspect)) {
430 return;
431 }
432 VkImageSubresource sub = {aspect, level, layer};
433 IMAGE_CMD_BUF_LAYOUT_NODE node;
434 if (!FindCmdBufLayout(device_data, pCB, mem_barrier->image, sub, node)) {
John Zulauf48a6a702017-12-22 17:14:54 -0700435 pCB->image_layout_change_count++; // Change the version of this data to force revalidation
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -0700436 SetLayout(device_data, pCB, mem_barrier->image, sub,
437 IMAGE_CMD_BUF_LAYOUT_NODE(mem_barrier->oldLayout, mem_barrier->newLayout));
438 return;
439 }
440 if (mem_barrier->oldLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
441 // TODO: Set memory invalid
442 }
443 SetLayout(device_data, pCB, mem_barrier->image, sub, mem_barrier->newLayout);
444}
445
Dave Houlton10b39482017-03-16 13:18:15 -0600446bool VerifyAspectsPresent(VkImageAspectFlags aspect_mask, VkFormat format) {
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600447 if ((aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != 0) {
Dave Houltone2fca552018-04-05 16:20:33 -0600448 if (!(FormatIsColor(format) || FormatIsMultiplane(format))) return false;
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600449 }
450 if ((aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) != 0) {
Dave Houlton1d2022c2017-03-29 11:43:58 -0600451 if (!FormatHasDepth(format)) return false;
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600452 }
453 if ((aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) != 0) {
Dave Houlton1d2022c2017-03-29 11:43:58 -0600454 if (!FormatHasStencil(format)) return false;
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600455 }
Dave Houltonb3f4b282018-02-22 16:25:16 -0700456 if (0 !=
457 (aspect_mask & (VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR | VK_IMAGE_ASPECT_PLANE_2_BIT_KHR))) {
458 if (FormatPlaneCount(format) == 1) return false;
459 }
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600460 return true;
461}
462
Mike Weiblen62d08a32017-03-07 22:18:27 -0700463// Verify an ImageMemoryBarrier's old/new ImageLayouts are compatible with the Image's ImageUsageFlags.
464bool ValidateBarrierLayoutToImageUsage(layer_data *device_data, const VkImageMemoryBarrier *img_barrier, bool new_not_old,
465 VkImageUsageFlags usage_flags, const char *func_name) {
466 const auto report_data = core_validation::GetReportData(device_data);
467 bool skip = false;
468 const VkImageLayout layout = (new_not_old) ? img_barrier->newLayout : img_barrier->oldLayout;
Dave Houlton8e9f6542018-05-18 12:18:22 -0600469 std::string msg_code = kVUIDUndefined; // sentinel value meaning "no error"
Mike Weiblen62d08a32017-03-07 22:18:27 -0700470
471 switch (layout) {
472 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
473 if ((usage_flags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -0600474 msg_code = "VUID-VkImageMemoryBarrier-oldLayout-01208";
Mike Weiblen62d08a32017-03-07 22:18:27 -0700475 }
476 break;
477 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
478 if ((usage_flags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -0600479 msg_code = "VUID-VkImageMemoryBarrier-oldLayout-01209";
Mike Weiblen62d08a32017-03-07 22:18:27 -0700480 }
481 break;
482 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
483 if ((usage_flags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -0600484 msg_code = "VUID-VkImageMemoryBarrier-oldLayout-01210";
Mike Weiblen62d08a32017-03-07 22:18:27 -0700485 }
486 break;
487 case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
488 if ((usage_flags & (VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)) == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -0600489 msg_code = "VUID-VkImageMemoryBarrier-oldLayout-01211";
Mike Weiblen62d08a32017-03-07 22:18:27 -0700490 }
491 break;
492 case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
493 if ((usage_flags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -0600494 msg_code = "VUID-VkImageMemoryBarrier-oldLayout-01212";
Mike Weiblen62d08a32017-03-07 22:18:27 -0700495 }
496 break;
497 case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
498 if ((usage_flags & VK_IMAGE_USAGE_TRANSFER_DST_BIT) == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -0600499 msg_code = "VUID-VkImageMemoryBarrier-oldLayout-01213";
Mike Weiblen62d08a32017-03-07 22:18:27 -0700500 }
501 break;
502 default:
503 // Other VkImageLayout values do not have VUs defined in this context.
504 break;
505 }
506
Dave Houlton8e9f6542018-05-18 12:18:22 -0600507 if (msg_code != kVUIDUndefined) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600508 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 -0600509 HandleToUint64(img_barrier->image), msg_code,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600510 "%s: Image barrier 0x%p %sLayout=%s is not compatible with image 0x%" PRIx64 " usage flags 0x%" PRIx32 ".",
511 func_name, static_cast<const void *>(img_barrier), ((new_not_old) ? "new" : "old"),
512 string_VkImageLayout(layout), HandleToUint64(img_barrier->image), usage_flags);
Mike Weiblen62d08a32017-03-07 22:18:27 -0700513 }
514 return skip;
515}
516
517// Verify image barriers are compatible with the images they reference.
Tobin Ehlis9c0df962017-07-17 10:14:27 -0600518bool ValidateBarriersToImages(layer_data *device_data, GLOBAL_CB_NODE const *cb_state, uint32_t imageMemoryBarrierCount,
Mike Weiblen62d08a32017-03-07 22:18:27 -0700519 const VkImageMemoryBarrier *pImageMemoryBarriers, const char *func_name) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700520 bool skip = false;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700521
Mike Weiblen62d08a32017-03-07 22:18:27 -0700522 for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
523 auto img_barrier = &pImageMemoryBarriers[i];
524 if (!img_barrier) continue;
525
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -0600526 auto image_state = GetImageState(device_data, img_barrier->image);
527 if (image_state) {
528 VkImageUsageFlags usage_flags = image_state->createInfo.usage;
529 skip |= ValidateBarrierLayoutToImageUsage(device_data, img_barrier, false, usage_flags, func_name);
530 skip |= ValidateBarrierLayoutToImageUsage(device_data, img_barrier, true, usage_flags, func_name);
531
532 // Make sure layout is able to be transitioned, currently only presented shared presentable images are locked
533 if (image_state->layout_locked) {
534 // TODO: Add unique id for error when available
Dave Houlton33c2d252017-06-09 17:08:32 -0600535 skip |= log_msg(
536 core_validation::GetReportData(device_data), VK_DEBUG_REPORT_ERROR_BIT_EXT,
Mark Young9d1ac312018-05-21 16:28:27 -0600537 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(img_barrier->image), 0,
Petr Kraus13c98a62017-12-09 00:22:39 +0100538 "Attempting to transition shared presentable image 0x%" PRIx64
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -0600539 " from layout %s to layout %s, but image has already been presented and cannot have its layout transitioned.",
Petr Kraus13c98a62017-12-09 00:22:39 +0100540 HandleToUint64(img_barrier->image), string_VkImageLayout(img_barrier->oldLayout),
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -0600541 string_VkImageLayout(img_barrier->newLayout));
542 }
543 }
544
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -0600545 VkImageCreateInfo *image_create_info = &(GetImageState(device_data, img_barrier->image)->createInfo);
Tobin Ehlis7ee9cbd2017-04-26 16:51:48 -0600546 // For a Depth/Stencil image both aspects MUST be set
547 if (FormatIsDepthAndStencil(image_create_info->format)) {
548 auto const aspect_mask = img_barrier->subresourceRange.aspectMask;
549 auto const ds_mask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
550 if ((aspect_mask & ds_mask) != (ds_mask)) {
Mark Lobodzinski88529492018-04-01 10:38:15 -0600551 skip |=
552 log_msg(core_validation::GetReportData(device_data), VK_DEBUG_REPORT_ERROR_BIT_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -0600553 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(img_barrier->image),
554 "VUID-VkImageMemoryBarrier-image-01207",
Mark Lobodzinski88529492018-04-01 10:38:15 -0600555 "%s: Image barrier 0x%p references image 0x%" PRIx64
556 " of format %s that must have the depth and stencil aspects set, but its aspectMask is 0x%" PRIx32 ".",
557 func_name, static_cast<const void *>(img_barrier), HandleToUint64(img_barrier->image),
558 string_VkFormat(image_create_info->format), aspect_mask);
Tobin Ehlis7ee9cbd2017-04-26 16:51:48 -0600559 }
560 }
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -0600561 uint32_t level_count = ResolveRemainingLevels(&img_barrier->subresourceRange, image_create_info->mipLevels);
562 uint32_t layer_count = ResolveRemainingLayers(&img_barrier->subresourceRange, image_create_info->arrayLayers);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700563
Mike Weiblen62d08a32017-03-07 22:18:27 -0700564 for (uint32_t j = 0; j < level_count; j++) {
565 uint32_t level = img_barrier->subresourceRange.baseMipLevel + j;
566 for (uint32_t k = 0; k < layer_count; k++) {
567 uint32_t layer = img_barrier->subresourceRange.baseArrayLayer + k;
Tobin Ehlis9c0df962017-07-17 10:14:27 -0600568 skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, VK_IMAGE_ASPECT_COLOR_BIT);
569 skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, VK_IMAGE_ASPECT_DEPTH_BIT);
570 skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, VK_IMAGE_ASPECT_STENCIL_BIT);
571 skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer, VK_IMAGE_ASPECT_METADATA_BIT);
Dave Houltonb3f4b282018-02-22 16:25:16 -0700572 if (GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) {
573 skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer,
574 VK_IMAGE_ASPECT_PLANE_0_BIT_KHR);
575 skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer,
576 VK_IMAGE_ASPECT_PLANE_1_BIT_KHR);
577 skip |= ValidateImageAspectLayout(device_data, cb_state, img_barrier, level, layer,
578 VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
579 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700580 }
581 }
582 }
583 return skip;
584}
585
Chris Forbes4de4b132017-08-21 11:27:08 -0700586static bool IsReleaseOp(layer_data *device_data, GLOBAL_CB_NODE *cb_state, VkImageMemoryBarrier const *barrier) {
John Zulauf1b33d5a2018-03-24 19:52:19 -0600587 if (!IsTransferOp(barrier)) return false;
Chris Forbes4de4b132017-08-21 11:27:08 -0700588
589 auto pool = GetCommandPoolNode(device_data, cb_state->createInfo.commandPool);
John Zulauf1b33d5a2018-03-24 19:52:19 -0600590 return pool && IsReleaseOp<VkImageMemoryBarrier, true>(pool, barrier);
Chris Forbes4de4b132017-08-21 11:27:08 -0700591}
592
John Zulauf6b4aae82018-05-09 13:03:36 -0600593template <typename Barrier>
594bool ValidateQFOTransferBarrierUniqueness(layer_data *device_data, const char *func_name, GLOBAL_CB_NODE *cb_state,
595 uint32_t barrier_count, const Barrier *barriers) {
596 using BarrierRecord = QFOTransferBarrier<Barrier>;
597 bool skip = false;
598 const auto report_data = core_validation::GetReportData(device_data);
599 auto pool = GetCommandPoolNode(device_data, cb_state->createInfo.commandPool);
600 auto &barrier_sets = GetQFOBarrierSets(cb_state, typename BarrierRecord::Tag());
601 const char *barrier_name = BarrierRecord::BarrierName();
602 const char *handle_name = BarrierRecord::HandleName();
603 const char *transfer_type = nullptr;
604 for (uint32_t b = 0; b < barrier_count; b++) {
605 if (!IsTransferOp(&barriers[b])) continue;
606 const BarrierRecord *barrier_record = nullptr;
607 if (IsReleaseOp<Barrier, true /* Assume IsTransfer */>(pool, &barriers[b])) {
608 const auto found = barrier_sets.release.find(barriers[b]);
609 if (found != barrier_sets.release.cend()) {
610 barrier_record = &(*found);
611 transfer_type = "releasing";
612 }
613 } else if (IsAcquireOp<Barrier, true /*Assume IsTransfer */>(pool, &barriers[b])) {
614 const auto found = barrier_sets.acquire.find(barriers[b]);
615 if (found != barrier_sets.acquire.cend()) {
616 barrier_record = &(*found);
617 transfer_type = "acquiring";
618 }
619 }
620 if (barrier_record != nullptr) {
621 skip |=
622 log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
623 HandleToUint64(cb_state->commandBuffer), BarrierRecord::ErrMsgDuplicateQFOInCB(),
624 "%s: %s at index %" PRIu32 " %s queue ownership of %s (0x%" PRIx64 "), from srcQueueFamilyIndex %" PRIu32
625 " to dstQueueFamilyIndex %" PRIu32 " duplicates existing barrier recorded in this command buffer.",
626 func_name, barrier_name, b, transfer_type, handle_name, HandleToUint64(barrier_record->handle),
627 barrier_record->srcQueueFamilyIndex, barrier_record->dstQueueFamilyIndex);
628 }
629 }
630 return skip;
631}
632
633template <typename Barrier>
634void RecordQFOTransferBarriers(layer_data *device_data, GLOBAL_CB_NODE *cb_state, uint32_t barrier_count, const Barrier *barriers) {
635 auto pool = GetCommandPoolNode(device_data, cb_state->createInfo.commandPool);
636 auto &barrier_sets = GetQFOBarrierSets(cb_state, typename QFOTransferBarrier<Barrier>::Tag());
637 for (uint32_t b = 0; b < barrier_count; b++) {
638 if (!IsTransferOp(&barriers[b])) continue;
639 if (IsReleaseOp<Barrier, true /* Assume IsTransfer*/>(pool, &barriers[b])) {
640 barrier_sets.release.emplace(barriers[b]);
641 } else if (IsAcquireOp<Barrier, true /*Assume IsTransfer */>(pool, &barriers[b])) {
642 barrier_sets.acquire.emplace(barriers[b]);
643 }
644 }
645}
646
647bool ValidateBarriersQFOTransferUniqueness(layer_data *device_data, const char *func_name, GLOBAL_CB_NODE *cb_state,
648 uint32_t bufferBarrierCount, const VkBufferMemoryBarrier *pBufferMemBarriers,
649 uint32_t imageMemBarrierCount, const VkImageMemoryBarrier *pImageMemBarriers) {
650 bool skip = false;
651 skip |= ValidateQFOTransferBarrierUniqueness(device_data, func_name, cb_state, bufferBarrierCount, pBufferMemBarriers);
652 skip |= ValidateQFOTransferBarrierUniqueness(device_data, func_name, cb_state, imageMemBarrierCount, pImageMemBarriers);
653 return skip;
654}
655
656void RecordBarriersQFOTransfers(layer_data *device_data, const char *func_name, GLOBAL_CB_NODE *cb_state,
657 uint32_t bufferBarrierCount, const VkBufferMemoryBarrier *pBufferMemBarriers,
658 uint32_t imageMemBarrierCount, const VkImageMemoryBarrier *pImageMemBarriers) {
659 RecordQFOTransferBarriers(device_data, cb_state, bufferBarrierCount, pBufferMemBarriers);
660 RecordQFOTransferBarriers(device_data, cb_state, imageMemBarrierCount, pImageMemBarriers);
661}
662
663template <typename BarrierRecord, typename Scoreboard>
664static bool ValidateAndUpdateQFOScoreboard(const debug_report_data *report_data, const GLOBAL_CB_NODE *cb_state,
665 const char *operation, const BarrierRecord &barrier, Scoreboard *scoreboard) {
666 // Record to the scoreboard or report that we have a duplication
667 bool skip = false;
668 auto inserted = scoreboard->insert(std::make_pair(barrier, cb_state));
669 if (!inserted.second && inserted.first->second != cb_state) {
670 // This is a duplication (but don't report duplicates from the same CB, as we do that at record time
671 skip = log_msg(
672 report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
673 HandleToUint64(cb_state->commandBuffer), BarrierRecord::ErrMsgDuplicateQFOInSubmit(),
674 "%s: %s %s queue ownership of %s (0x%" PRIx64 "), from srcQueueFamilyIndex %" PRIu32 " to dstQueueFamilyIndex %" PRIu32
675 " duplicates existing barrier submitted in this batch from command buffer 0x%" PRIx64 ".",
676 "vkQueueSubmit()", BarrierRecord::BarrierName(), operation, BarrierRecord::HandleName(), HandleToUint64(barrier.handle),
677 barrier.srcQueueFamilyIndex, barrier.dstQueueFamilyIndex, HandleToUint64(inserted.first->second));
678 }
679 return skip;
680}
681
682template <typename Barrier>
683static bool ValidateQueuedQFOTransferBarriers(layer_data *device_data, GLOBAL_CB_NODE *cb_state,
684 QFOTransferCBScoreboards<Barrier> *scoreboards) {
685 using BarrierRecord = QFOTransferBarrier<Barrier>;
686 using TypeTag = typename BarrierRecord::Tag;
687 bool skip = false;
688 const auto report_data = core_validation::GetReportData(device_data);
689 const auto &cb_barriers = GetQFOBarrierSets(cb_state, TypeTag());
690 const GlobalQFOTransferBarrierMap<Barrier> &global_release_barriers =
691 core_validation::GetGlobalQFOReleaseBarrierMap(device_data, TypeTag());
692 const char *barrier_name = BarrierRecord::BarrierName();
693 const char *handle_name = BarrierRecord::HandleName();
694 // No release should have an extant duplicate (WARNING)
695 for (const auto &release : cb_barriers.release) {
696 // Check the global pending release barriers
697 const auto set_it = global_release_barriers.find(release.handle);
698 if (set_it != global_release_barriers.cend()) {
699 const QFOTransferBarrierSet<Barrier> &set_for_handle = set_it->second;
700 const auto found = set_for_handle.find(release);
701 if (found != set_for_handle.cend()) {
702 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
703 HandleToUint64(cb_state->commandBuffer), BarrierRecord::ErrMsgDuplicateQFOSubmitted(),
704 "%s: %s releasing queue ownership of %s (0x%" PRIx64 "), from srcQueueFamilyIndex %" PRIu32
705 " to dstQueueFamilyIndex %" PRIu32
706 " duplicates existing barrier queued for execution, without intervening acquire operation.",
707 "vkQueueSubmit()", barrier_name, handle_name, HandleToUint64(found->handle),
708 found->srcQueueFamilyIndex, found->dstQueueFamilyIndex);
709 }
710 }
711 skip |= ValidateAndUpdateQFOScoreboard(report_data, cb_state, "releasing", release, &scoreboards->release);
712 }
713 // Each acquire must have a matching release (ERROR)
714 for (const auto &acquire : cb_barriers.acquire) {
715 const auto set_it = global_release_barriers.find(acquire.handle);
716 bool matching_release_found = false;
717 if (set_it != global_release_barriers.cend()) {
718 const QFOTransferBarrierSet<Barrier> &set_for_handle = set_it->second;
719 matching_release_found = set_for_handle.find(acquire) != set_for_handle.cend();
720 }
721 if (!matching_release_found) {
722 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
723 HandleToUint64(cb_state->commandBuffer), BarrierRecord::ErrMsgMissingQFOReleaseInSubmit(),
724 "%s: in submitted command buffer %s aquiring ownership of %s (0x%" PRIx64
725 "), from srcQueueFamilyIndex %" PRIu32 " to dstQueueFamilyIndex %" PRIu32
726 " has no matching release barrier queued for execution.",
727 "vkQueueSubmit()", barrier_name, handle_name, HandleToUint64(acquire.handle),
728 acquire.srcQueueFamilyIndex, acquire.dstQueueFamilyIndex);
729 }
730 skip |= ValidateAndUpdateQFOScoreboard(report_data, cb_state, "acquiring", acquire, &scoreboards->acquire);
731 }
732 return skip;
733}
734
735bool ValidateQueuedQFOTransfers(layer_data *device_data, GLOBAL_CB_NODE *cb_state,
736 QFOTransferCBScoreboards<VkImageMemoryBarrier> *qfo_image_scoreboards,
737 QFOTransferCBScoreboards<VkBufferMemoryBarrier> *qfo_buffer_scoreboards) {
738 bool skip = false;
739 skip |= ValidateQueuedQFOTransferBarriers<VkImageMemoryBarrier>(device_data, cb_state, qfo_image_scoreboards);
740 skip |= ValidateQueuedQFOTransferBarriers<VkBufferMemoryBarrier>(device_data, cb_state, qfo_buffer_scoreboards);
741 return skip;
742}
743
744template <typename Barrier>
745static void RecordQueuedQFOTransferBarriers(layer_data *device_data, GLOBAL_CB_NODE *cb_state) {
746 using BarrierRecord = QFOTransferBarrier<Barrier>;
747 using TypeTag = typename BarrierRecord::Tag;
748 const auto &cb_barriers = GetQFOBarrierSets(cb_state, TypeTag());
749 GlobalQFOTransferBarrierMap<Barrier> &global_release_barriers =
750 core_validation::GetGlobalQFOReleaseBarrierMap(device_data, TypeTag());
751
752 // Add release barriers from this submit to the global map
753 for (const auto &release : cb_barriers.release) {
754 // the global barrier list is mapped by resource handle to allow cleanup on resource destruction
755 // NOTE: We're using [] because creation of a Set is a needed side effect for new handles
756 global_release_barriers[release.handle].insert(release);
757 }
758
759 // Erase acquired barriers from this submit from the global map -- essentially marking releases as consumed
760 for (const auto &acquire : cb_barriers.acquire) {
761 // NOTE: We're not using [] because we don't want to create entries for missing releases
762 auto set_it = global_release_barriers.find(acquire.handle);
763 if (set_it != global_release_barriers.end()) {
764 QFOTransferBarrierSet<Barrier> &set_for_handle = set_it->second;
765 set_for_handle.erase(acquire);
766 if (set_for_handle.size() == 0) { // Clean up empty sets
767 global_release_barriers.erase(set_it);
768 }
769 }
770 }
771}
772
773void RecordQueuedQFOTransfers(layer_data *device_data, GLOBAL_CB_NODE *cb_state) {
774 RecordQueuedQFOTransferBarriers<VkImageMemoryBarrier>(device_data, cb_state);
775 RecordQueuedQFOTransferBarriers<VkBufferMemoryBarrier>(device_data, cb_state);
776}
777
778// Remove the pending QFO release records from the global set
779// Note that the type of the handle argument constrained to match Barrier type
780// The defaulted BarrierRecord argument allows use to declare the type once, but is not intended to be specified by the caller
781template <typename Barrier, typename BarrierRecord = QFOTransferBarrier<Barrier>>
782static void EraseQFOReleaseBarriers(layer_data *device_data, const typename BarrierRecord::HandleType &handle) {
783 GlobalQFOTransferBarrierMap<Barrier> &global_release_barriers =
784 core_validation::GetGlobalQFOReleaseBarrierMap(device_data, typename BarrierRecord::Tag());
785 global_release_barriers.erase(handle);
786}
787
788// Avoid making the template globally visible by exporting the one instance of it we need.
789void EraseQFOImageRelaseBarriers(layer_data *device_data, const VkImage &image) {
790 EraseQFOReleaseBarriers<VkImageMemoryBarrier>(device_data, image);
791}
792
Chris Forbes399a6782017-08-18 15:00:48 -0700793void TransitionImageLayouts(layer_data *device_data, GLOBAL_CB_NODE *cb_state, uint32_t memBarrierCount,
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -0700794 const VkImageMemoryBarrier *pImgMemBarriers) {
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -0700795 for (uint32_t i = 0; i < memBarrierCount; ++i) {
796 auto mem_barrier = &pImgMemBarriers[i];
797 if (!mem_barrier) continue;
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -0700798
Chris Forbes4de4b132017-08-21 11:27:08 -0700799 // For ownership transfers, the barrier is specified twice; as a release
800 // operation on the yielding queue family, and as an acquire operation
801 // on the acquiring queue family. This barrier may also include a layout
802 // transition, which occurs 'between' the two operations. For validation
803 // purposes it doesn't seem important which side performs the layout
804 // transition, but it must not be performed twice. We'll arbitrarily
805 // choose to perform it as part of the acquire operation.
806 if (IsReleaseOp(device_data, cb_state, mem_barrier)) {
807 continue;
808 }
809
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -0600810 VkImageCreateInfo *image_create_info = &(GetImageState(device_data, mem_barrier->image)->createInfo);
811 uint32_t level_count = ResolveRemainingLevels(&mem_barrier->subresourceRange, image_create_info->mipLevels);
812 uint32_t layer_count = ResolveRemainingLayers(&mem_barrier->subresourceRange, image_create_info->arrayLayers);
813
Dave Houltonb3f4b282018-02-22 16:25:16 -0700814 // Special case for 3D images with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR flag bit, where <extent.depth> and
815 // <arrayLayers> can potentially alias. When recording layout for the entire image, pre-emptively record layouts
816 // for all (potential) layer sub_resources.
817 if ((0 != (image_create_info->flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR)) &&
818 (mem_barrier->subresourceRange.baseArrayLayer == 0) && (layer_count == 1)) {
819 layer_count = image_create_info->extent.depth; // Treat each depth slice as a layer subresource
820 }
821
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -0600822 for (uint32_t j = 0; j < level_count; j++) {
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -0700823 uint32_t level = mem_barrier->subresourceRange.baseMipLevel + j;
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -0600824 for (uint32_t k = 0; k < layer_count; k++) {
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -0700825 uint32_t layer = mem_barrier->subresourceRange.baseArrayLayer + k;
Chris Forbes399a6782017-08-18 15:00:48 -0700826 TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, VK_IMAGE_ASPECT_COLOR_BIT);
827 TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, VK_IMAGE_ASPECT_DEPTH_BIT);
828 TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, VK_IMAGE_ASPECT_STENCIL_BIT);
829 TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, VK_IMAGE_ASPECT_METADATA_BIT);
Dave Houltonb3f4b282018-02-22 16:25:16 -0700830 if (GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) {
Chris Forbes399a6782017-08-18 15:00:48 -0700831 TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR);
832 TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR);
833 TransitionImageAspectLayout(device_data, cb_state, mem_barrier, level, layer, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
Dave Houltonb3f4b282018-02-22 16:25:16 -0700834 }
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -0700835 }
836 }
837 }
838}
839
Tobin Ehlisc8266452017-04-07 12:20:30 -0600840bool VerifyImageLayout(layer_data const *device_data, GLOBAL_CB_NODE const *cb_node, IMAGE_STATE *image_state,
Tobin Ehlis2d85ec62017-03-14 15:38:48 -0600841 VkImageSubresourceLayers subLayers, VkImageLayout explicit_layout, VkImageLayout optimal_layout,
Dave Houltone0969282018-05-23 15:54:31 -0600842 const char *caller, const std::string &msg_code, bool *error) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700843 const auto report_data = core_validation::GetReportData(device_data);
Tobin Ehlis2d85ec62017-03-14 15:38:48 -0600844 const auto image = image_state->image;
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600845 bool skip = false;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700846
847 for (uint32_t i = 0; i < subLayers.layerCount; ++i) {
848 uint32_t layer = i + subLayers.baseArrayLayer;
849 VkImageSubresource sub = {subLayers.aspectMask, subLayers.mipLevel, layer};
850 IMAGE_CMD_BUF_LAYOUT_NODE node;
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600851 if (FindCmdBufLayout(device_data, cb_node, image, sub, node)) {
852 if (node.layout != explicit_layout) {
Tobin Ehlisc8266452017-04-07 12:20:30 -0600853 *error = true;
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600854 // TODO: Improve log message in the next pass
Petr Kraus13c98a62017-12-09 00:22:39 +0100855 skip |= log_msg(
856 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -0600857 HandleToUint64(cb_node->commandBuffer), DRAWSTATE_INVALID_IMAGE_LAYOUT,
Petr Kraus13c98a62017-12-09 00:22:39 +0100858 "%s: Cannot use image 0x%" PRIx64 " with specific layout %s that doesn't match the actual current layout %s.",
859 caller, HandleToUint64(image), string_VkImageLayout(explicit_layout), string_VkImageLayout(node.layout));
Tobin Ehlise35b66a2017-03-15 12:18:31 -0600860 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700861 }
862 }
Tobin Ehlis2d85ec62017-03-14 15:38:48 -0600863 // If optimal_layout is not UNDEFINED, check that layout matches optimal for this case
864 if ((VK_IMAGE_LAYOUT_UNDEFINED != optimal_layout) && (explicit_layout != optimal_layout)) {
865 if (VK_IMAGE_LAYOUT_GENERAL == explicit_layout) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700866 if (image_state->createInfo.tiling != VK_IMAGE_TILING_LINEAR) {
867 // LAYOUT_GENERAL is allowed, but may not be performance optimal, flag as perf warning.
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600868 skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600869 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(cb_node->commandBuffer),
Mark Lobodzinski88529492018-04-01 10:38:15 -0600870 DRAWSTATE_INVALID_IMAGE_LAYOUT,
Petr Kraus13c98a62017-12-09 00:22:39 +0100871 "%s: For optimal performance image 0x%" PRIx64 " layout should be %s instead of GENERAL.", caller,
872 HandleToUint64(image), string_VkImageLayout(optimal_layout));
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700873 }
Mark Lobodzinski28426ae2017-06-01 07:56:38 -0600874 } else if (GetDeviceExtensions(device_data)->vk_khr_shared_presentable_image) {
Mark Lobodzinski087380c2017-05-16 14:42:25 -0600875 if (image_state->shared_presentable) {
876 if (VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR != explicit_layout) {
877 // TODO: Add unique error id when available.
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600878 skip |=
879 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, msg_code,
Mark Lobodzinski88529492018-04-01 10:38:15 -0600880 "Layout for shared presentable image is %s but must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR.",
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600881 string_VkImageLayout(optimal_layout));
Mark Lobodzinski087380c2017-05-16 14:42:25 -0600882 }
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -0600883 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700884 } else {
Tobin Ehlisc8266452017-04-07 12:20:30 -0600885 *error = true;
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600886 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -0600887 HandleToUint64(cb_node->commandBuffer), msg_code,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600888 "%s: Layout for image 0x%" PRIx64 " is %s but can only be %s or VK_IMAGE_LAYOUT_GENERAL.", caller,
889 HandleToUint64(image), string_VkImageLayout(explicit_layout), string_VkImageLayout(optimal_layout));
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700890 }
891 }
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600892 return skip;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700893}
894
Tobin Ehlis58c884f2017-02-08 12:15:27 -0700895void TransitionFinalSubpassLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin,
896 FRAMEBUFFER_STATE *framebuffer_state) {
Tobin Ehlisb2e1e2c2017-02-08 09:16:32 -0700897 auto renderPass = GetRenderPassState(device_data, pRenderPassBegin->renderPass);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700898 if (!renderPass) return;
899
900 const VkRenderPassCreateInfo *pRenderPassInfo = renderPass->createInfo.ptr();
901 if (framebuffer_state) {
902 for (uint32_t i = 0; i < pRenderPassInfo->attachmentCount; ++i) {
903 auto image_view = framebuffer_state->createInfo.pAttachments[i];
904 SetImageViewLayout(device_data, pCB, image_view, pRenderPassInfo->pAttachments[i].finalLayout);
905 }
906 }
907}
Dave Houltone19e20d2018-02-02 16:32:41 -0700908
Tobin Ehlis58c884f2017-02-08 12:15:27 -0700909bool PreCallValidateCreateImage(layer_data *device_data, const VkImageCreateInfo *pCreateInfo,
Mark Lobodzinski90224de2017-01-26 15:23:11 -0700910 const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600911 bool skip = false;
Mark Lobodzinski90224de2017-01-26 15:23:11 -0700912 const debug_report_data *report_data = core_validation::GetReportData(device_data);
913
Jeremy Hayes96dcd812017-03-14 14:04:19 -0600914 if (pCreateInfo->format == VK_FORMAT_UNDEFINED) {
Dave Houltond8ed0212018-05-16 17:18:24 -0600915 skip |=
916 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
917 "VUID-VkImageCreateInfo-format-00943", "vkCreateImage: VkFormat for image must not be VK_FORMAT_UNDEFINED.");
Jeremy Hayes96dcd812017-03-14 14:04:19 -0600918
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600919 return skip;
Jeremy Hayes96dcd812017-03-14 14:04:19 -0600920 }
921
Dave Houlton130c0212018-01-29 13:39:56 -0700922 const char *format_string = string_VkFormat(pCreateInfo->format);
Dave Houlton130c0212018-01-29 13:39:56 -0700923
924 if ((pCreateInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) && (VK_IMAGE_TYPE_2D != pCreateInfo->imageType)) {
925 std::stringstream ss;
926 ss << "vkCreateImage: Image type must be VK_IMAGE_TYPE_2D when VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT flag bit is set";
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600927 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 -0600928 "VUID-VkImageCreateInfo-flags-00949", "%s.", ss.str().c_str());
Dave Houlton130c0212018-01-29 13:39:56 -0700929 }
930
931 const VkPhysicalDeviceLimits *device_limits = &(GetPhysicalDeviceProperties(device_data)->limits);
932 VkImageFormatProperties format_limits; // Format limits may exceed general device limits
933 VkResult err = GetImageFormatProperties(device_data, pCreateInfo, &format_limits);
934 if (VK_SUCCESS != err) {
935 std::stringstream ss;
936 ss << "vkCreateImage: The combination of format, type, tiling, usage and flags supplied in the VkImageCreateInfo struct is "
937 "reported by vkGetPhysicalDeviceImageFormatProperties() as unsupported";
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600938 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 -0600939 "VUID-VkImageCreateInfo-format-00940", "%s.", ss.str().c_str());
Dave Houlton130c0212018-01-29 13:39:56 -0700940 return skip;
941 }
942
943 if ((VK_IMAGE_TYPE_1D == pCreateInfo->imageType) &&
944 (pCreateInfo->extent.width > std::max(device_limits->maxImageDimension1D, format_limits.maxExtent.width))) {
945 std::stringstream ss;
946 ss << "vkCreateImage: 1D image width exceeds maximum supported width for format " << format_string;
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600947 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 -0600948 "VUID-VkImageCreateInfo-imageType-00951", "%s.", ss.str().c_str());
Dave Houlton130c0212018-01-29 13:39:56 -0700949 }
950
951 if (VK_IMAGE_TYPE_2D == pCreateInfo->imageType) {
952 if (0 == (pCreateInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)) {
953 if (pCreateInfo->extent.width > std::max(device_limits->maxImageDimension2D, format_limits.maxExtent.width) ||
954 pCreateInfo->extent.height > std::max(device_limits->maxImageDimension2D, format_limits.maxExtent.height)) {
Lenny Komowb79f04a2017-09-18 17:07:00 -0600955 std::stringstream ss;
Dave Houlton130c0212018-01-29 13:39:56 -0700956 ss << "vkCreateImage: 2D image extent exceeds maximum supported width or height for format " << format_string;
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600957 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 -0600958 "VUID-VkImageCreateInfo-imageType-00952", "%s.", ss.str().c_str());
Lenny Komowb79f04a2017-09-18 17:07:00 -0600959 }
Dave Houlton130c0212018-01-29 13:39:56 -0700960 } else {
961 if (pCreateInfo->extent.width > std::max(device_limits->maxImageDimensionCube, format_limits.maxExtent.width) ||
962 pCreateInfo->extent.height > std::max(device_limits->maxImageDimensionCube, format_limits.maxExtent.height)) {
Lenny Komowb79f04a2017-09-18 17:07:00 -0600963 std::stringstream ss;
Dave Houlton130c0212018-01-29 13:39:56 -0700964 ss << "vkCreateImage: 2D image extent exceeds maximum supported width or height for cube-compatible images with "
965 "format "
966 << format_string;
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600967 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 -0600968 "VUID-VkImageCreateInfo-imageType-00953", "%s.", ss.str().c_str());
Lenny Komowb79f04a2017-09-18 17:07:00 -0600969 }
Jeremy Hayes96dcd812017-03-14 14:04:19 -0600970 }
Mark Lobodzinski90224de2017-01-26 15:23:11 -0700971 }
972
Dave Houlton130c0212018-01-29 13:39:56 -0700973 if (VK_IMAGE_TYPE_3D == pCreateInfo->imageType) {
974 if ((pCreateInfo->extent.width > std::max(device_limits->maxImageDimension3D, format_limits.maxExtent.width)) ||
975 (pCreateInfo->extent.height > std::max(device_limits->maxImageDimension3D, format_limits.maxExtent.height)) ||
976 (pCreateInfo->extent.depth > std::max(device_limits->maxImageDimension3D, format_limits.maxExtent.depth))) {
977 std::stringstream ss;
978 ss << "vkCreateImage: 3D image extent exceeds maximum supported width, height, or depth for format " << format_string;
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600979 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 -0600980 "VUID-VkImageCreateInfo-imageType-00955", "%s.", ss.str().c_str());
Dave Houlton130c0212018-01-29 13:39:56 -0700981 }
Mark Lobodzinski90224de2017-01-26 15:23:11 -0700982 }
983
Dave Houlton130c0212018-01-29 13:39:56 -0700984 // NOTE: As of 1/30/2018 the spec VU language is as in the commented code below. I believe this is an
Dave Houltone19e20d2018-02-02 16:32:41 -0700985 // error in the spec, and have submitted Gitlab Vulkan issue #1151 to have it changed to match the
Dave Houlton130c0212018-01-29 13:39:56 -0700986 // implementation shown. DJH
987 //
988 // if ((pCreateInfo->mipLevels > format_limits.maxMipLevels) &&
989 // (std::max({ pCreateInfo->extent.width, pCreateInfo->extent.height, pCreateInfo->extent.depth }) >
990 // device_limits->maxImageDimension3D)) {
991 if (pCreateInfo->mipLevels > format_limits.maxMipLevels) {
992 std::stringstream ss;
993 ss << "vkCreateImage: Image mip levels exceed image format maxMipLevels for format " << format_string;
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600994 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 -0600995 "VUID-VkImageCreateInfo-extent-00959", "%s.", ss.str().c_str());
Dave Houlton130c0212018-01-29 13:39:56 -0700996 }
Mark Lobodzinski90224de2017-01-26 15:23:11 -0700997
Dave Houlton130c0212018-01-29 13:39:56 -0700998 VkImageUsageFlags attach_flags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
999 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
1000 if ((pCreateInfo->usage & attach_flags) && (pCreateInfo->extent.width > device_limits->maxFramebufferWidth)) {
1001 std::stringstream ss;
1002 ss << "vkCreateImage: Image usage flags include a frame buffer attachment bit and image width exceeds device "
1003 "maxFramebufferWidth";
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06001004 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 -06001005 "VUID-VkImageCreateInfo-usage-00964", "%s.", ss.str().c_str());
Dave Houlton130c0212018-01-29 13:39:56 -07001006 }
1007
1008 if ((pCreateInfo->usage & attach_flags) && (pCreateInfo->extent.height > device_limits->maxFramebufferHeight)) {
1009 std::stringstream ss;
1010 ss << "vkCreateImage: Image usage flags include a frame buffer attachment bit and image height exceeds device "
1011 "maxFramebufferHeight";
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06001012 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 -06001013 "VUID-VkImageCreateInfo-usage-00965", "%s.", ss.str().c_str());
Dave Houlton130c0212018-01-29 13:39:56 -07001014 }
1015
1016 uint64_t total_size = (uint64_t)pCreateInfo->extent.width * (uint64_t)pCreateInfo->extent.height *
1017 (uint64_t)pCreateInfo->extent.depth * (uint64_t)pCreateInfo->arrayLayers *
1018 (uint64_t)pCreateInfo->samples * (uint64_t)FormatSize(pCreateInfo->format);
1019
1020 // Round up to imageGranularity boundary
1021 VkDeviceSize imageGranularity = GetPhysicalDeviceProperties(device_data)->limits.bufferImageGranularity;
1022 uint64_t ig_mask = imageGranularity - 1;
1023 total_size = (total_size + ig_mask) & ~ig_mask;
1024
1025 if (total_size > format_limits.maxResourceSize) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06001026 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
Mark Lobodzinski88529492018-04-01 10:38:15 -06001027 IMAGE_INVALID_FORMAT_LIMITS_VIOLATION,
Dave Houltona9df0ce2018-02-07 10:51:23 -07001028 "CreateImage resource size exceeds allowable maximum Image resource size = 0x%" PRIxLEAST64
1029 ", maximum resource size = 0x%" PRIxLEAST64 " ",
Dave Houlton130c0212018-01-29 13:39:56 -07001030 total_size, format_limits.maxResourceSize);
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001031 }
1032
Dave Houlton130c0212018-01-29 13:39:56 -07001033 if (pCreateInfo->arrayLayers > format_limits.maxArrayLayers) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001034 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
1035 "VUID-VkImageCreateInfo-arrayLayers-00960",
1036 "CreateImage arrayLayers=%d exceeds allowable maximum supported by format of %d.", pCreateInfo->arrayLayers,
1037 format_limits.maxArrayLayers);
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001038 }
1039
Dave Houlton130c0212018-01-29 13:39:56 -07001040 if ((pCreateInfo->samples & format_limits.sampleCounts) == 0) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06001041 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
Dave Houltond8ed0212018-05-16 17:18:24 -06001042 "VUID-VkImageCreateInfo-samples-00967", "CreateImage samples %s is not supported by format 0x%.8X.",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001043 string_VkSampleCountFlagBits(pCreateInfo->samples), format_limits.sampleCounts);
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001044 }
1045
Mark Lobodzinski035a4cf2017-03-13 09:45:07 -06001046 if ((pCreateInfo->flags & VK_IMAGE_CREATE_SPARSE_ALIASED_BIT) && (!GetEnabledFeatures(device_data)->sparseResidencyAliased)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06001047 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Mark Lobodzinski88529492018-04-01 10:38:15 -06001048 DRAWSTATE_INVALID_FEATURE,
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -06001049 "vkCreateImage(): the sparseResidencyAliased device feature is disabled: Images cannot be created with the "
1050 "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT set.");
Mark Lobodzinski035a4cf2017-03-13 09:45:07 -06001051 }
1052
Lenny Komowb79f04a2017-09-18 17:07:00 -06001053 if (GetDeviceExtensions(device_data)->vk_khr_maintenance2) {
1054 if (pCreateInfo->flags & VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR) {
1055 if (!(FormatIsCompressed_BC(pCreateInfo->format) || FormatIsCompressed_ASTC_LDR(pCreateInfo->format) ||
1056 FormatIsCompressed_ETC2_EAC(pCreateInfo->format))) {
1057 // TODO: Add Maintenance2 VUID
Dave Houlton8e9f6542018-05-18 12:18:22 -06001058 skip |=
1059 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUIDUndefined,
1060 "vkCreateImage(): If pCreateInfo->flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR, "
1061 "format must be block, ETC or ASTC compressed, but is %s",
1062 string_VkFormat(pCreateInfo->format));
Lenny Komowb79f04a2017-09-18 17:07:00 -06001063 }
1064 if (!(pCreateInfo->flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT)) {
1065 // TODO: Add Maintenance2 VUID
Dave Houlton8e9f6542018-05-18 12:18:22 -06001066 skip |=
1067 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUIDUndefined,
1068 "vkCreateImage(): If pCreateInfo->flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR, "
1069 "flags must also contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT.");
Lenny Komowb79f04a2017-09-18 17:07:00 -06001070 }
1071 }
1072 }
1073
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -06001074 return skip;
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001075}
1076
Tobin Ehlis58c884f2017-02-08 12:15:27 -07001077void PostCallRecordCreateImage(layer_data *device_data, const VkImageCreateInfo *pCreateInfo, VkImage *pImage) {
Mark Lobodzinski42fe5f72017-01-11 11:36:16 -07001078 IMAGE_LAYOUT_NODE image_state;
1079 image_state.layout = pCreateInfo->initialLayout;
1080 image_state.format = pCreateInfo->format;
Mark Lobodzinski214144a2017-01-27 14:25:32 -07001081 GetImageMap(device_data)->insert(std::make_pair(*pImage, std::unique_ptr<IMAGE_STATE>(new IMAGE_STATE(*pImage, pCreateInfo))));
Mark Lobodzinski42fe5f72017-01-11 11:36:16 -07001082 ImageSubresourcePair subpair{*pImage, false, VkImageSubresource()};
Mark Lobodzinski214144a2017-01-27 14:25:32 -07001083 (*core_validation::GetImageSubresourceMap(device_data))[*pImage].push_back(subpair);
1084 (*core_validation::GetImageLayoutMap(device_data))[subpair] = image_state;
Mark Lobodzinski42fe5f72017-01-11 11:36:16 -07001085}
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001086
Tobin Ehlis58c884f2017-02-08 12:15:27 -07001087bool PreCallValidateDestroyImage(layer_data *device_data, VkImage image, IMAGE_STATE **image_state, VK_OBJECT *obj_struct) {
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001088 const CHECK_DISABLED *disabled = core_validation::GetDisables(device_data);
Tobin Ehlisb2e1e2c2017-02-08 09:16:32 -07001089 *image_state = core_validation::GetImageState(device_data, image);
Petr Krausbc7f5442017-05-14 23:43:38 +02001090 *obj_struct = {HandleToUint64(image), kVulkanObjectTypeImage};
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001091 if (disabled->destroy_image) return false;
1092 bool skip = false;
1093 if (*image_state) {
Mike Schuchardta5025652017-09-27 14:56:21 -06001094 skip |= core_validation::ValidateObjectNotInUse(device_data, *image_state, *obj_struct, "vkDestroyImage",
Dave Houltond8ed0212018-05-16 17:18:24 -06001095 "VUID-vkDestroyImage-image-01000");
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001096 }
1097 return skip;
1098}
1099
John Zulauffca05c12018-04-26 16:30:39 -06001100void PreCallRecordDestroyImage(layer_data *device_data, VkImage image, IMAGE_STATE *image_state, VK_OBJECT obj_struct) {
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001101 core_validation::invalidateCommandBuffers(device_data, image_state->cb_bindings, obj_struct);
1102 // Clean up memory mapping, bindings and range references for image
1103 for (auto mem_binding : image_state->GetBoundMemory()) {
Tobin Ehlisb2e1e2c2017-02-08 09:16:32 -07001104 auto mem_info = core_validation::GetMemObjInfo(device_data, mem_binding);
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001105 if (mem_info) {
1106 core_validation::RemoveImageMemoryRange(obj_struct.handle, mem_info);
1107 }
1108 }
Mark Lobodzinski33826372017-04-13 11:10:11 -06001109 core_validation::ClearMemoryObjectBindings(device_data, obj_struct.handle, kVulkanObjectTypeImage);
John Zulauf6b4aae82018-05-09 13:03:36 -06001110 EraseQFOReleaseBarriers<VkImageMemoryBarrier>(device_data, image);
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07001111 // Remove image from imageMap
1112 core_validation::GetImageMap(device_data)->erase(image);
1113 std::unordered_map<VkImage, std::vector<ImageSubresourcePair>> *imageSubresourceMap =
1114 core_validation::GetImageSubresourceMap(device_data);
1115
1116 const auto &sub_entry = imageSubresourceMap->find(image);
1117 if (sub_entry != imageSubresourceMap->end()) {
1118 for (const auto &pair : sub_entry->second) {
1119 core_validation::GetImageLayoutMap(device_data)->erase(pair);
1120 }
1121 imageSubresourceMap->erase(sub_entry);
1122 }
1123}
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001124
Tobin Ehlis58c884f2017-02-08 12:15:27 -07001125bool ValidateImageAttributes(layer_data *device_data, IMAGE_STATE *image_state, VkImageSubresourceRange range) {
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001126 bool skip = false;
1127 const debug_report_data *report_data = core_validation::GetReportData(device_data);
1128
1129 if (range.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) {
1130 char const str[] = "vkCmdClearColorImage aspectMasks for all subresource ranges must be set to VK_IMAGE_ASPECT_COLOR_BIT";
1131 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 -06001132 HandleToUint64(image_state->image), DRAWSTATE_INVALID_IMAGE_ASPECT, str);
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001133 }
1134
Dave Houlton1d2022c2017-03-29 11:43:58 -06001135 if (FormatIsDepthOrStencil(image_state->createInfo.format)) {
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001136 char const str[] = "vkCmdClearColorImage called with depth/stencil image.";
1137 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 -06001138 HandleToUint64(image_state->image), "VUID-vkCmdClearColorImage-image-00007", "%s.", str);
Dave Houlton1d2022c2017-03-29 11:43:58 -06001139 } else if (FormatIsCompressed(image_state->createInfo.format)) {
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001140 char const str[] = "vkCmdClearColorImage called with compressed image.";
1141 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 -06001142 HandleToUint64(image_state->image), "VUID-vkCmdClearColorImage-image-00007", "%s.", str);
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001143 }
1144
1145 if (!(image_state->createInfo.usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) {
1146 char const str[] = "vkCmdClearColorImage called with image created without VK_IMAGE_USAGE_TRANSFER_DST_BIT.";
1147 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 -06001148 HandleToUint64(image_state->image), "VUID-vkCmdClearColorImage-image-00002", "%s.", str);
Mark Lobodzinskic409a582017-01-27 15:16:01 -07001149 }
1150 return skip;
1151}
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001152
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001153uint32_t ResolveRemainingLevels(const VkImageSubresourceRange *range, uint32_t mip_levels) {
1154 // Return correct number of mip levels taking into account VK_REMAINING_MIP_LEVELS
1155 uint32_t mip_level_count = range->levelCount;
Mark Lobodzinski9c93dbd2017-02-02 08:31:18 -07001156 if (range->levelCount == VK_REMAINING_MIP_LEVELS) {
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001157 mip_level_count = mip_levels - range->baseMipLevel;
Mark Lobodzinski9c93dbd2017-02-02 08:31:18 -07001158 }
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001159 return mip_level_count;
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001160}
1161
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001162uint32_t ResolveRemainingLayers(const VkImageSubresourceRange *range, uint32_t layers) {
1163 // Return correct number of layers taking into account VK_REMAINING_ARRAY_LAYERS
1164 uint32_t array_layer_count = range->layerCount;
1165 if (range->layerCount == VK_REMAINING_ARRAY_LAYERS) {
1166 array_layer_count = layers - range->baseArrayLayer;
Mark Lobodzinski9c93dbd2017-02-02 08:31:18 -07001167 }
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001168 return array_layer_count;
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001169}
1170
Tobin Ehlis58c884f2017-02-08 12:15:27 -07001171bool VerifyClearImageLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *image_state,
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001172 VkImageSubresourceRange range, VkImageLayout dest_image_layout, const char *func_name) {
1173 bool skip = false;
1174 const debug_report_data *report_data = core_validation::GetReportData(device_data);
1175
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001176 uint32_t level_count = ResolveRemainingLevels(&range, image_state->createInfo.mipLevels);
1177 uint32_t layer_count = ResolveRemainingLayers(&range, image_state->createInfo.arrayLayers);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001178
1179 if (dest_image_layout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
1180 if (dest_image_layout == VK_IMAGE_LAYOUT_GENERAL) {
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001181 if (image_state->createInfo.tiling != VK_IMAGE_TILING_LINEAR) {
1182 // LAYOUT_GENERAL is allowed, but may not be performance optimal, flag as perf warning.
Mark Lobodzinski0827aec2017-03-21 16:41:45 -06001183 skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06001184 HandleToUint64(image_state->image), DRAWSTATE_INVALID_IMAGE_LAYOUT,
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001185 "%s: Layout for cleared image should be TRANSFER_DST_OPTIMAL instead of GENERAL.", func_name);
1186 }
Mark Lobodzinski087380c2017-05-16 14:42:25 -06001187 } else if (VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR == dest_image_layout) {
Mark Lobodzinski28426ae2017-06-01 07:56:38 -06001188 if (!GetDeviceExtensions(device_data)->vk_khr_shared_presentable_image) {
Tobin Ehlisfb0661c2017-05-11 08:52:51 -06001189 // TODO: Add unique error id when available.
Mark Lobodzinski087380c2017-05-16 14:42:25 -06001190 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 -06001191 HandleToUint64(image_state->image), 0,
Dave Houlton33c2d252017-06-09 17:08:32 -06001192 "Must enable VK_KHR_shared_presentable_image extension before creating images with a layout type "
1193 "of VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR.");
Mark Lobodzinski087380c2017-05-16 14:42:25 -06001194
1195 } else {
1196 if (image_state->shared_presentable) {
1197 skip |= log_msg(
1198 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06001199 HandleToUint64(image_state->image), 0,
Mark Lobodzinski087380c2017-05-16 14:42:25 -06001200 "Layout for shared presentable cleared image is %s but can only be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR.",
1201 string_VkImageLayout(dest_image_layout));
1202 }
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -06001203 }
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001204 } else {
Dave Houltond8ed0212018-05-16 17:18:24 -06001205 std::string error_code = "VUID-vkCmdClearColorImage-imageLayout-00005";
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001206 if (strcmp(func_name, "vkCmdClearDepthStencilImage()") == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001207 error_code = "VUID-vkCmdClearDepthStencilImage-imageLayout-00012";
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001208 } else {
1209 assert(strcmp(func_name, "vkCmdClearColorImage()") == 0);
1210 }
Mark Lobodzinski0827aec2017-03-21 16:41:45 -06001211 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 -06001212 HandleToUint64(image_state->image), error_code,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001213 "%s: Layout for cleared image is %s but can only be TRANSFER_DST_OPTIMAL or GENERAL.", func_name,
1214 string_VkImageLayout(dest_image_layout));
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001215 }
1216 }
1217
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001218 for (uint32_t level_index = 0; level_index < level_count; ++level_index) {
1219 uint32_t level = level_index + range.baseMipLevel;
1220 for (uint32_t layer_index = 0; layer_index < layer_count; ++layer_index) {
1221 uint32_t layer = layer_index + range.baseArrayLayer;
1222 VkImageSubresource sub = {range.aspectMask, level, layer};
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001223 IMAGE_CMD_BUF_LAYOUT_NODE node;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001224 if (FindCmdBufLayout(device_data, cb_node, image_state->image, sub, node)) {
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001225 if (node.layout != dest_image_layout) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001226 std::string error_code = "VUID-vkCmdClearColorImage-imageLayout-00004";
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001227 if (strcmp(func_name, "vkCmdClearDepthStencilImage()") == 0) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001228 error_code = "VUID-vkCmdClearDepthStencilImage-imageLayout-00011";
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001229 } else {
1230 assert(strcmp(func_name, "vkCmdClearColorImage()") == 0);
1231 }
Mark Lobodzinski88529492018-04-01 10:38:15 -06001232 skip |=
1233 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
1234 error_code, "%s: Cannot clear an image whose layout is %s and doesn't match the current layout %s.",
1235 func_name, string_VkImageLayout(dest_image_layout), string_VkImageLayout(node.layout));
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001236 }
1237 }
1238 }
1239 }
1240
1241 return skip;
1242}
1243
Tobin Ehlis58c884f2017-02-08 12:15:27 -07001244void RecordClearImageLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, VkImage image, VkImageSubresourceRange range,
1245 VkImageLayout dest_image_layout) {
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001246 VkImageCreateInfo *image_create_info = &(GetImageState(device_data, image)->createInfo);
1247 uint32_t level_count = ResolveRemainingLevels(&range, image_create_info->mipLevels);
1248 uint32_t layer_count = ResolveRemainingLayers(&range, image_create_info->arrayLayers);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001249
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06001250 for (uint32_t level_index = 0; level_index < level_count; ++level_index) {
1251 uint32_t level = level_index + range.baseMipLevel;
1252 for (uint32_t layer_index = 0; layer_index < layer_count; ++layer_index) {
1253 uint32_t layer = layer_index + range.baseArrayLayer;
1254 VkImageSubresource sub = {range.aspectMask, level, layer};
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001255 IMAGE_CMD_BUF_LAYOUT_NODE node;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001256 if (!FindCmdBufLayout(device_data, cb_node, image, sub, node)) {
1257 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 -07001258 }
1259 }
1260 }
1261}
1262
Tobin Ehlis58c884f2017-02-08 12:15:27 -07001263bool PreCallValidateCmdClearColorImage(layer_data *dev_data, VkCommandBuffer commandBuffer, VkImage image,
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001264 VkImageLayout imageLayout, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) {
1265 bool skip = false;
1266 // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
Tobin Ehlisb2e1e2c2017-02-08 09:16:32 -07001267 auto cb_node = GetCBNode(dev_data, commandBuffer);
1268 auto image_state = GetImageState(dev_data, image);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001269 if (cb_node && image_state) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001270 skip |=
1271 ValidateMemoryIsBoundToImage(dev_data, image_state, "vkCmdClearColorImage()", "VUID-vkCmdClearColorImage-image-00003");
Mike Schuchardt9c582402017-02-23 15:57:37 -07001272 skip |= ValidateCmdQueueFlags(dev_data, cb_node, "vkCmdClearColorImage()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT,
Dave Houltond8ed0212018-05-16 17:18:24 -06001273 "VUID-vkCmdClearColorImage-commandBuffer-cmdpool");
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001274 skip |= ValidateCmd(dev_data, cb_node, CMD_CLEARCOLORIMAGE, "vkCmdClearColorImage()");
Cort Stratton186b1a22018-05-01 20:18:06 -04001275 if (GetApiVersion(dev_data) >= VK_API_VERSION_1_1 || GetDeviceExtensions(dev_data)->vk_khr_maintenance1) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001276 skip |=
1277 ValidateImageFormatFeatureFlags(dev_data, image_state, VK_FORMAT_FEATURE_TRANSFER_DST_BIT, "vkCmdClearColorImage",
1278 "VUID-vkCmdClearColorImage-image-00001", "VUID-vkCmdClearColorImage-image-00001");
Cort Stratton186b1a22018-05-01 20:18:06 -04001279 }
Dave Houltond8ed0212018-05-16 17:18:24 -06001280 skip |= insideRenderPass(dev_data, cb_node, "vkCmdClearColorImage()", "VUID-vkCmdClearColorImage-renderpass");
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001281 for (uint32_t i = 0; i < rangeCount; ++i) {
Petr Kraus4d718682017-05-18 03:38:41 +02001282 std::string param_name = "pRanges[" + std::to_string(i) + "]";
Petr Krausffa94af2017-08-08 21:46:02 +02001283 skip |= ValidateCmdClearColorSubresourceRange(dev_data, image_state, pRanges[i], param_name.c_str());
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001284 skip |= ValidateImageAttributes(dev_data, image_state, pRanges[i]);
Mark Lobodzinski9c93dbd2017-02-02 08:31:18 -07001285 skip |= VerifyClearImageLayout(dev_data, cb_node, image_state, pRanges[i], imageLayout, "vkCmdClearColorImage()");
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001286 }
1287 }
1288 return skip;
1289}
1290
1291// This state recording routine is shared between ClearColorImage and ClearDepthStencilImage
Tobin Ehlis58c884f2017-02-08 12:15:27 -07001292void PreCallRecordCmdClearImage(layer_data *dev_data, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
Chris Forbes38c2e792017-06-16 16:42:35 -07001293 uint32_t rangeCount, const VkImageSubresourceRange *pRanges) {
Tobin Ehlisb2e1e2c2017-02-08 09:16:32 -07001294 auto cb_node = GetCBNode(dev_data, commandBuffer);
1295 auto image_state = GetImageState(dev_data, image);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001296 if (cb_node && image_state) {
1297 AddCommandBufferBindingImage(dev_data, cb_node, image_state);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001298 for (uint32_t i = 0; i < rangeCount; ++i) {
1299 RecordClearImageLayout(dev_data, cb_node, image, pRanges[i], imageLayout);
1300 }
1301 }
1302}
1303
Tobin Ehlis58c884f2017-02-08 12:15:27 -07001304bool PreCallValidateCmdClearDepthStencilImage(layer_data *device_data, VkCommandBuffer commandBuffer, VkImage image,
1305 VkImageLayout imageLayout, uint32_t rangeCount,
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001306 const VkImageSubresourceRange *pRanges) {
1307 bool skip = false;
Mark Lobodzinski1241a312017-02-01 10:57:21 -07001308 const debug_report_data *report_data = core_validation::GetReportData(device_data);
1309
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001310 // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
Tobin Ehlisb2e1e2c2017-02-08 09:16:32 -07001311 auto cb_node = GetCBNode(device_data, commandBuffer);
1312 auto image_state = GetImageState(device_data, image);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001313 if (cb_node && image_state) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001314 skip |= ValidateMemoryIsBoundToImage(device_data, image_state, "vkCmdClearDepthStencilImage()",
1315 "VUID-vkCmdClearDepthStencilImage-image-00010");
Mike Schuchardt9c582402017-02-23 15:57:37 -07001316 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdClearDepthStencilImage()", VK_QUEUE_GRAPHICS_BIT,
Dave Houltond8ed0212018-05-16 17:18:24 -06001317 "VUID-vkCmdClearDepthStencilImage-commandBuffer-cmdpool");
Mark Lobodzinski1241a312017-02-01 10:57:21 -07001318 skip |= ValidateCmd(device_data, cb_node, CMD_CLEARDEPTHSTENCILIMAGE, "vkCmdClearDepthStencilImage()");
Cort Stratton186b1a22018-05-01 20:18:06 -04001319 if (GetApiVersion(device_data) >= VK_API_VERSION_1_1 || GetDeviceExtensions(device_data)->vk_khr_maintenance1) {
1320 skip |= ValidateImageFormatFeatureFlags(device_data, image_state, VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
Dave Houltond8ed0212018-05-16 17:18:24 -06001321 "vkCmdClearDepthStencilImage", "VUID-vkCmdClearDepthStencilImage-image-00008",
1322 "VUID-vkCmdClearDepthStencilImage-image-00008");
Cort Stratton186b1a22018-05-01 20:18:06 -04001323 }
Dave Houltond8ed0212018-05-16 17:18:24 -06001324 skip |=
1325 insideRenderPass(device_data, cb_node, "vkCmdClearDepthStencilImage()", "VUID-vkCmdClearDepthStencilImage-renderpass");
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001326 for (uint32_t i = 0; i < rangeCount; ++i) {
Petr Kraus4d718682017-05-18 03:38:41 +02001327 std::string param_name = "pRanges[" + std::to_string(i) + "]";
Petr Krausffa94af2017-08-08 21:46:02 +02001328 skip |= ValidateCmdClearDepthSubresourceRange(device_data, image_state, pRanges[i], param_name.c_str());
Mark Lobodzinski9c93dbd2017-02-02 08:31:18 -07001329 skip |=
1330 VerifyClearImageLayout(device_data, cb_node, image_state, pRanges[i], imageLayout, "vkCmdClearDepthStencilImage()");
Mark Lobodzinski1241a312017-02-01 10:57:21 -07001331 // Image aspect must be depth or stencil or both
1332 if (((pRanges[i].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) &&
1333 ((pRanges[i].aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT)) {
1334 char const str[] =
Dave Houltona9df0ce2018-02-07 10:51:23 -07001335 "vkCmdClearDepthStencilImage aspectMasks for all subresource ranges must be set to VK_IMAGE_ASPECT_DEPTH_BIT "
1336 "and/or VK_IMAGE_ASPECT_STENCIL_BIT";
Mark Lobodzinski1241a312017-02-01 10:57:21 -07001337 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06001338 HandleToUint64(commandBuffer), DRAWSTATE_INVALID_IMAGE_ASPECT, str);
Mark Lobodzinski1241a312017-02-01 10:57:21 -07001339 }
1340 }
Dave Houlton1d2022c2017-03-29 11:43:58 -06001341 if (image_state && !FormatIsDepthOrStencil(image_state->createInfo.format)) {
Mark Lobodzinski1241a312017-02-01 10:57:21 -07001342 char const str[] = "vkCmdClearDepthStencilImage called without a depth/stencil image.";
Tobin Ehlis3c37fb32017-05-24 09:31:13 -06001343 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 -06001344 HandleToUint64(image), "VUID-vkCmdClearDepthStencilImage-image-00014", "%s.", str);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001345 }
Tobin Ehlis4af8c242017-11-30 13:47:11 -07001346 if (VK_IMAGE_USAGE_TRANSFER_DST_BIT != (VK_IMAGE_USAGE_TRANSFER_DST_BIT & image_state->createInfo.usage)) {
1347 char const str[] =
1348 "vkCmdClearDepthStencilImage() called with an image that was not created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT "
1349 "set.";
1350 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 -06001351 HandleToUint64(image), "VUID-vkCmdClearDepthStencilImage-image-00009", "%s.", str);
Tobin Ehlis4af8c242017-11-30 13:47:11 -07001352 }
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07001353 }
1354 return skip;
1355}
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001356
1357// Returns true if [x, xoffset] and [y, yoffset] overlap
1358static bool RangesIntersect(int32_t start, uint32_t start_offset, int32_t end, uint32_t end_offset) {
1359 bool result = false;
1360 uint32_t intersection_min = std::max(static_cast<uint32_t>(start), static_cast<uint32_t>(end));
1361 uint32_t intersection_max = std::min(static_cast<uint32_t>(start) + start_offset, static_cast<uint32_t>(end) + end_offset);
1362
1363 if (intersection_max > intersection_min) {
1364 result = true;
1365 }
1366 return result;
1367}
1368
Dave Houltonc991cc92018-03-06 11:08:51 -07001369// Returns true if source area of first copy region intersects dest area of second region
1370// It is assumed that these are copy regions within a single image (otherwise no possibility of collision)
1371static bool RegionIntersects(const VkImageCopy *rgn0, const VkImageCopy *rgn1, VkImageType type, bool is_multiplane) {
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001372 bool result = false;
Dave Houltonf5217612018-02-02 16:18:52 -07001373
Dave Houltonc991cc92018-03-06 11:08:51 -07001374 // Separate planes within a multiplane image cannot intersect
1375 if (is_multiplane && (rgn0->srcSubresource.aspectMask != rgn1->dstSubresource.aspectMask)) {
Dave Houltonf5217612018-02-02 16:18:52 -07001376 return result;
1377 }
1378
Dave Houltonc991cc92018-03-06 11:08:51 -07001379 if ((rgn0->srcSubresource.mipLevel == rgn1->dstSubresource.mipLevel) &&
1380 (RangesIntersect(rgn0->srcSubresource.baseArrayLayer, rgn0->srcSubresource.layerCount, rgn1->dstSubresource.baseArrayLayer,
1381 rgn1->dstSubresource.layerCount))) {
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001382 result = true;
1383 switch (type) {
1384 case VK_IMAGE_TYPE_3D:
Dave Houltonc991cc92018-03-06 11:08:51 -07001385 result &= RangesIntersect(rgn0->srcOffset.z, rgn0->extent.depth, rgn1->dstOffset.z, rgn1->extent.depth);
Tobin Ehlis648b1cf2018-04-13 15:24:13 -06001386 // fall through
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001387 case VK_IMAGE_TYPE_2D:
Dave Houltonc991cc92018-03-06 11:08:51 -07001388 result &= RangesIntersect(rgn0->srcOffset.y, rgn0->extent.height, rgn1->dstOffset.y, rgn1->extent.height);
Tobin Ehlis648b1cf2018-04-13 15:24:13 -06001389 // fall through
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001390 case VK_IMAGE_TYPE_1D:
Dave Houltonc991cc92018-03-06 11:08:51 -07001391 result &= RangesIntersect(rgn0->srcOffset.x, rgn0->extent.width, rgn1->dstOffset.x, rgn1->extent.width);
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001392 break;
1393 default:
1394 // Unrecognized or new IMAGE_TYPE enums will be caught in parameter_validation
1395 assert(false);
1396 }
1397 }
1398 return result;
1399}
1400
Dave Houltonfc1a4052017-04-27 14:32:45 -06001401// Returns non-zero if offset and extent exceed image extents
1402static const uint32_t x_bit = 1;
1403static const uint32_t y_bit = 2;
1404static const uint32_t z_bit = 4;
Dave Houlton1150cf52017-04-27 14:38:11 -06001405static uint32_t ExceedsBounds(const VkOffset3D *offset, const VkExtent3D *extent, const VkExtent3D *image_extent) {
Dave Houltonfc1a4052017-04-27 14:32:45 -06001406 uint32_t result = 0;
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001407 // Extents/depths cannot be negative but checks left in for clarity
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001408 if ((offset->z + extent->depth > image_extent->depth) || (offset->z < 0) ||
1409 ((offset->z + static_cast<int32_t>(extent->depth)) < 0)) {
Dave Houltonfc1a4052017-04-27 14:32:45 -06001410 result |= z_bit;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001411 }
1412 if ((offset->y + extent->height > image_extent->height) || (offset->y < 0) ||
1413 ((offset->y + static_cast<int32_t>(extent->height)) < 0)) {
Dave Houltonfc1a4052017-04-27 14:32:45 -06001414 result |= y_bit;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001415 }
1416 if ((offset->x + extent->width > image_extent->width) || (offset->x < 0) ||
1417 ((offset->x + static_cast<int32_t>(extent->width)) < 0)) {
Dave Houltonfc1a4052017-04-27 14:32:45 -06001418 result |= x_bit;
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001419 }
1420 return result;
1421}
1422
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001423// Test if two VkExtent3D structs are equivalent
1424static inline bool IsExtentEqual(const VkExtent3D *extent, const VkExtent3D *other_extent) {
1425 bool result = true;
1426 if ((extent->width != other_extent->width) || (extent->height != other_extent->height) ||
1427 (extent->depth != other_extent->depth)) {
1428 result = false;
1429 }
1430 return result;
1431}
1432
Dave Houltonee281a52017-12-08 13:51:02 -07001433// For image copies between compressed/uncompressed formats, the extent is provided in source image texels
1434// Destination image texel extents must be adjusted by block size for the dest validation checks
1435VkExtent3D GetAdjustedDestImageExtent(VkFormat src_format, VkFormat dst_format, VkExtent3D extent) {
1436 VkExtent3D adjusted_extent = extent;
1437 if ((FormatIsCompressed(src_format) && (!FormatIsCompressed(dst_format)))) {
1438 VkExtent3D block_size = FormatCompressedTexelBlockExtent(src_format);
1439 adjusted_extent.width /= block_size.width;
1440 adjusted_extent.height /= block_size.height;
1441 adjusted_extent.depth /= block_size.depth;
1442 } else if ((!FormatIsCompressed(src_format) && (FormatIsCompressed(dst_format)))) {
1443 VkExtent3D block_size = FormatCompressedTexelBlockExtent(dst_format);
1444 adjusted_extent.width *= block_size.width;
1445 adjusted_extent.height *= block_size.height;
1446 adjusted_extent.depth *= block_size.depth;
1447 }
1448 return adjusted_extent;
1449}
1450
Dave Houlton6f9059e2017-05-02 17:15:13 -06001451// Returns the effective extent of an image subresource, adjusted for mip level and array depth.
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001452static inline VkExtent3D GetImageSubresourceExtent(const IMAGE_STATE *img, const VkImageSubresourceLayers *subresource) {
1453 const uint32_t mip = subresource->mipLevel;
Dave Houltonfc1a4052017-04-27 14:32:45 -06001454
1455 // Return zero extent if mip level doesn't exist
Dave Houlton1150cf52017-04-27 14:38:11 -06001456 if (mip >= img->createInfo.mipLevels) {
1457 return VkExtent3D{0, 0, 0};
Dave Houltonfc1a4052017-04-27 14:32:45 -06001458 }
Dave Houlton1150cf52017-04-27 14:38:11 -06001459
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001460 // 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 -06001461 VkExtent3D extent = img->createInfo.extent;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001462 extent.width = (0 == extent.width ? 0 : std::max(1U, extent.width >> mip));
1463 extent.height = (0 == extent.height ? 0 : std::max(1U, extent.height >> mip));
1464 extent.depth = (0 == extent.depth ? 0 : std::max(1U, extent.depth >> mip));
Dave Houltonfc1a4052017-04-27 14:32:45 -06001465
Dave Houlton6f9059e2017-05-02 17:15:13 -06001466 // Image arrays have an effective z extent that isn't diminished by mip level
1467 if (VK_IMAGE_TYPE_3D != img->createInfo.imageType) {
Dave Houltonfc1a4052017-04-27 14:32:45 -06001468 extent.depth = img->createInfo.arrayLayers;
1469 }
1470
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001471 return extent;
1472}
1473
1474// Test if the extent argument has all dimensions set to 0.
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001475static inline bool IsExtentAllZeroes(const VkExtent3D *extent) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001476 return ((extent->width == 0) && (extent->height == 0) && (extent->depth == 0));
1477}
1478
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001479// Test if the extent argument has any dimensions set to 0.
1480static inline bool IsExtentSizeZero(const VkExtent3D *extent) {
1481 return ((extent->width == 0) || (extent->height == 0) || (extent->depth == 0));
1482}
1483
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001484// Returns the image transfer granularity for a specific image scaled by compressed block size if necessary.
1485static inline VkExtent3D GetScaledItg(layer_data *device_data, const GLOBAL_CB_NODE *cb_node, const IMAGE_STATE *img) {
1486 // Default to (0, 0, 0) granularity in case we can't find the real granularity for the physical device.
1487 VkExtent3D granularity = {0, 0, 0};
1488 auto pPool = GetCommandPoolNode(device_data, cb_node->createInfo.commandPool);
1489 if (pPool) {
1490 granularity =
1491 GetPhysDevProperties(device_data)->queue_family_properties[pPool->queueFamilyIndex].minImageTransferGranularity;
Dave Houlton1d2022c2017-03-29 11:43:58 -06001492 if (FormatIsCompressed(img->createInfo.format)) {
1493 auto block_size = FormatCompressedTexelBlockExtent(img->createInfo.format);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001494 granularity.width *= block_size.width;
1495 granularity.height *= block_size.height;
1496 }
1497 }
1498 return granularity;
1499}
1500
1501// Test elements of a VkExtent3D structure against alignment constraints contained in another VkExtent3D structure
1502static inline bool IsExtentAligned(const VkExtent3D *extent, const VkExtent3D *granularity) {
1503 bool valid = true;
Dave Houlton1d2022c2017-03-29 11:43:58 -06001504 if ((SafeModulo(extent->depth, granularity->depth) != 0) || (SafeModulo(extent->width, granularity->width) != 0) ||
1505 (SafeModulo(extent->height, granularity->height) != 0)) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001506 valid = false;
1507 }
1508 return valid;
1509}
1510
1511// Check elements of a VkOffset3D structure against a queue family's Image Transfer Granularity values
1512static inline bool CheckItgOffset(layer_data *device_data, const GLOBAL_CB_NODE *cb_node, const VkOffset3D *offset,
Cort Stratton420ebd42018-05-04 01:12:23 -04001513 const VkExtent3D *granularity, const uint32_t i, const char *function, const char *member,
Dave Houltond8ed0212018-05-16 17:18:24 -06001514 std::string vuid) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001515 const debug_report_data *report_data = core_validation::GetReportData(device_data);
1516 bool skip = false;
1517 VkExtent3D offset_extent = {};
1518 offset_extent.width = static_cast<uint32_t>(abs(offset->x));
1519 offset_extent.height = static_cast<uint32_t>(abs(offset->y));
1520 offset_extent.depth = static_cast<uint32_t>(abs(offset->z));
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001521 if (IsExtentAllZeroes(granularity)) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001522 // 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 -07001523 if (IsExtentAllZeroes(&offset_extent) == false) {
Petr Krausbc7f5442017-05-14 23:43:38 +02001524 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 -04001525 HandleToUint64(cb_node->commandBuffer), vuid,
Dave Houltona9df0ce2018-02-07 10:51:23 -07001526 "%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 "
1527 "image transfer granularity is (w=0, h=0, d=0).",
Petr Krausbc7f5442017-05-14 23:43:38 +02001528 function, i, member, offset->x, offset->y, offset->z);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001529 }
1530 } else {
1531 // If the queue family image transfer granularity is not (0, 0, 0), then the offset dimensions must always be even
1532 // integer multiples of the image transfer granularity.
1533 if (IsExtentAligned(&offset_extent, granularity) == false) {
Petr Krausbc7f5442017-05-14 23:43:38 +02001534 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 -04001535 HandleToUint64(cb_node->commandBuffer), vuid,
Dave Houltona9df0ce2018-02-07 10:51:23 -07001536 "%s: pRegion[%d].%s (x=%d, y=%d, z=%d) dimensions must be even integer multiples of this command "
1537 "buffer's queue family image transfer granularity (w=%d, h=%d, d=%d).",
Petr Krausbc7f5442017-05-14 23:43:38 +02001538 function, i, member, offset->x, offset->y, offset->z, granularity->width, granularity->height,
1539 granularity->depth);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001540 }
1541 }
1542 return skip;
1543}
1544
1545// Check elements of a VkExtent3D structure against a queue family's Image Transfer Granularity values
1546static inline bool CheckItgExtent(layer_data *device_data, const GLOBAL_CB_NODE *cb_node, const VkExtent3D *extent,
1547 const VkOffset3D *offset, const VkExtent3D *granularity, const VkExtent3D *subresource_extent,
Cort Stratton420ebd42018-05-04 01:12:23 -04001548 const VkImageType image_type, const uint32_t i, const char *function, const char *member,
Dave Houltond8ed0212018-05-16 17:18:24 -06001549 std::string vuid) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001550 const debug_report_data *report_data = core_validation::GetReportData(device_data);
1551 bool skip = false;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07001552 if (IsExtentAllZeroes(granularity)) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001553 // If the queue family image transfer granularity is (0, 0, 0), then the extent must always match the image
1554 // subresource extent.
1555 if (IsExtentEqual(extent, subresource_extent) == false) {
Petr Krausbc7f5442017-05-14 23:43:38 +02001556 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 -04001557 HandleToUint64(cb_node->commandBuffer), vuid,
Petr Krausbc7f5442017-05-14 23:43:38 +02001558 "%s: pRegion[%d].%s (w=%d, h=%d, d=%d) must match the image subresource extents (w=%d, h=%d, d=%d) "
1559 "when the command buffer's queue family image transfer granularity is (w=0, h=0, d=0).",
1560 function, i, member, extent->width, extent->height, extent->depth, subresource_extent->width,
1561 subresource_extent->height, subresource_extent->depth);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001562 }
1563 } else {
1564 // If the queue family image transfer granularity is not (0, 0, 0), then the extent dimensions must always be even
1565 // integer multiples of the image transfer granularity or the offset + extent dimensions must always match the image
1566 // subresource extent dimensions.
1567 VkExtent3D offset_extent_sum = {};
1568 offset_extent_sum.width = static_cast<uint32_t>(abs(offset->x)) + extent->width;
1569 offset_extent_sum.height = static_cast<uint32_t>(abs(offset->y)) + extent->height;
1570 offset_extent_sum.depth = static_cast<uint32_t>(abs(offset->z)) + extent->depth;
Mark Lobodzinski283ade62017-10-09 16:36:49 -06001571 bool x_ok = true;
1572 bool y_ok = true;
1573 bool z_ok = true;
1574 switch (image_type) {
1575 case VK_IMAGE_TYPE_3D:
1576 z_ok = ((0 == SafeModulo(extent->depth, granularity->depth)) ||
1577 (subresource_extent->depth == offset_extent_sum.depth));
Tobin Ehlis648b1cf2018-04-13 15:24:13 -06001578 // fall through
Mark Lobodzinski283ade62017-10-09 16:36:49 -06001579 case VK_IMAGE_TYPE_2D:
1580 y_ok = ((0 == SafeModulo(extent->height, granularity->height)) ||
1581 (subresource_extent->height == offset_extent_sum.height));
Tobin Ehlis648b1cf2018-04-13 15:24:13 -06001582 // fall through
Mark Lobodzinski283ade62017-10-09 16:36:49 -06001583 case VK_IMAGE_TYPE_1D:
1584 x_ok = ((0 == SafeModulo(extent->width, granularity->width)) ||
1585 (subresource_extent->width == offset_extent_sum.width));
1586 break;
1587 default:
1588 // Unrecognized or new IMAGE_TYPE enums will be caught in parameter_validation
1589 assert(false);
1590 }
Dave Houlton6f9059e2017-05-02 17:15:13 -06001591 if (!(x_ok && y_ok && z_ok)) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07001592 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 -04001593 HandleToUint64(cb_node->commandBuffer), vuid,
Dave Houltona9df0ce2018-02-07 10:51:23 -07001594 "%s: pRegion[%d].%s (w=%d, h=%d, d=%d) dimensions must be even integer multiples of this command "
1595 "buffer's queue family image transfer granularity (w=%d, h=%d, d=%d) or offset (x=%d, y=%d, z=%d) + "
1596 "extent (w=%d, h=%d, d=%d) must match the image subresource extents (w=%d, h=%d, d=%d).",
1597 function, i, member, extent->width, extent->height, extent->depth, granularity->width,
1598 granularity->height, granularity->depth, offset->x, offset->y, offset->z, extent->width, extent->height,
1599 extent->depth, subresource_extent->width, subresource_extent->height, subresource_extent->depth);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001600 }
1601 }
1602 return skip;
1603}
1604
Mark Lobodzinskibf0042d2018-02-26 16:01:22 -07001605// Check valid usage Image Transfer Granularity requirements for elements of a VkBufferImageCopy structure
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001606bool ValidateCopyBufferImageTransferGranularityRequirements(layer_data *device_data, const GLOBAL_CB_NODE *cb_node,
1607 const IMAGE_STATE *img, const VkBufferImageCopy *region,
Dave Houltone0969282018-05-23 15:54:31 -06001608 const uint32_t i, const char *function, const std::string &vuid) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001609 bool skip = false;
Cort Stratton420ebd42018-05-04 01:12:23 -04001610 VkExtent3D granularity = GetScaledItg(device_data, cb_node, img);
1611 skip |= CheckItgOffset(device_data, cb_node, &region->imageOffset, &granularity, i, function, "imageOffset", vuid);
1612 VkExtent3D subresource_extent = GetImageSubresourceExtent(img, &region->imageSubresource);
1613 skip |= CheckItgExtent(device_data, cb_node, &region->imageExtent, &region->imageOffset, &granularity, &subresource_extent,
1614 img->createInfo.imageType, i, function, "imageExtent", vuid);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001615 return skip;
1616}
1617
Mark Lobodzinskibf0042d2018-02-26 16:01:22 -07001618// Check valid usage Image Transfer Granularity requirements for elements of a VkImageCopy structure
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001619bool ValidateCopyImageTransferGranularityRequirements(layer_data *device_data, const GLOBAL_CB_NODE *cb_node,
Dave Houlton6f9059e2017-05-02 17:15:13 -06001620 const IMAGE_STATE *src_img, const IMAGE_STATE *dst_img,
1621 const VkImageCopy *region, const uint32_t i, const char *function) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001622 bool skip = false;
Mark Lobodzinskid0788802017-10-19 15:38:59 -06001623 // Source image checks
Dave Houlton6f9059e2017-05-02 17:15:13 -06001624 VkExtent3D granularity = GetScaledItg(device_data, cb_node, src_img);
Dave Houltond8ed0212018-05-16 17:18:24 -06001625 skip |= CheckItgOffset(device_data, cb_node, &region->srcOffset, &granularity, i, function, "srcOffset",
1626 "VUID-vkCmdCopyImage-srcOffset-01783");
Dave Houlton6f9059e2017-05-02 17:15:13 -06001627 VkExtent3D subresource_extent = GetImageSubresourceExtent(src_img, &region->srcSubresource);
Dave Houlton94a00372017-12-14 15:08:47 -07001628 const VkExtent3D extent = region->extent;
Mark Lobodzinskid0788802017-10-19 15:38:59 -06001629 skip |= CheckItgExtent(device_data, cb_node, &extent, &region->srcOffset, &granularity, &subresource_extent,
Dave Houltond8ed0212018-05-16 17:18:24 -06001630 src_img->createInfo.imageType, i, function, "extent", "VUID-vkCmdCopyImage-srcOffset-01783");
Dave Houlton6f9059e2017-05-02 17:15:13 -06001631
Mark Lobodzinskid0788802017-10-19 15:38:59 -06001632 // Destination image checks
Dave Houlton6f9059e2017-05-02 17:15:13 -06001633 granularity = GetScaledItg(device_data, cb_node, dst_img);
Dave Houltond8ed0212018-05-16 17:18:24 -06001634 skip |= CheckItgOffset(device_data, cb_node, &region->dstOffset, &granularity, i, function, "dstOffset",
1635 "VUID-vkCmdCopyImage-dstOffset-01784");
Dave Houltonee281a52017-12-08 13:51:02 -07001636 // Adjust dest extent, if necessary
Dave Houlton94a00372017-12-14 15:08:47 -07001637 const VkExtent3D dest_effective_extent =
1638 GetAdjustedDestImageExtent(src_img->createInfo.format, dst_img->createInfo.format, extent);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001639 subresource_extent = GetImageSubresourceExtent(dst_img, &region->dstSubresource);
Dave Houltonee281a52017-12-08 13:51:02 -07001640 skip |= CheckItgExtent(device_data, cb_node, &dest_effective_extent, &region->dstOffset, &granularity, &subresource_extent,
Dave Houltond8ed0212018-05-16 17:18:24 -06001641 dst_img->createInfo.imageType, i, function, "extent", "VUID-vkCmdCopyImage-dstOffset-01784");
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001642 return skip;
1643}
1644
Dave Houlton6f9059e2017-05-02 17:15:13 -06001645// Validate contents of a VkImageCopy struct
1646bool ValidateImageCopyData(const layer_data *device_data, const debug_report_data *report_data, const uint32_t regionCount,
1647 const VkImageCopy *ic_regions, const IMAGE_STATE *src_state, const IMAGE_STATE *dst_state) {
1648 bool skip = false;
1649
1650 for (uint32_t i = 0; i < regionCount; i++) {
Dave Houlton94a00372017-12-14 15:08:47 -07001651 const VkImageCopy region = ic_regions[i];
Dave Houltonee281a52017-12-08 13:51:02 -07001652
1653 // For comp<->uncomp copies, the copy extent for the dest image must be adjusted
Dave Houlton94a00372017-12-14 15:08:47 -07001654 const VkExtent3D src_copy_extent = region.extent;
1655 const VkExtent3D dst_copy_extent =
Dave Houltonee281a52017-12-08 13:51:02 -07001656 GetAdjustedDestImageExtent(src_state->createInfo.format, dst_state->createInfo.format, region.extent);
1657
Dave Houlton6f9059e2017-05-02 17:15:13 -06001658 bool slice_override = false;
1659 uint32_t depth_slices = 0;
1660
1661 // Special case for copying between a 1D/2D array and a 3D image
1662 // TBD: This seems like the only way to reconcile 3 mutually-exclusive VU checks for 2D/3D copies. Heads up.
1663 if ((VK_IMAGE_TYPE_3D == src_state->createInfo.imageType) && (VK_IMAGE_TYPE_3D != dst_state->createInfo.imageType)) {
Dave Houltonee281a52017-12-08 13:51:02 -07001664 depth_slices = region.dstSubresource.layerCount; // Slice count from 2D subresource
Dave Houlton6f9059e2017-05-02 17:15:13 -06001665 slice_override = (depth_slices != 1);
1666 } 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 -07001667 depth_slices = region.srcSubresource.layerCount; // Slice count from 2D subresource
Dave Houlton6f9059e2017-05-02 17:15:13 -06001668 slice_override = (depth_slices != 1);
1669 }
1670
1671 // Do all checks on source image
1672 //
1673 if (src_state->createInfo.imageType == VK_IMAGE_TYPE_1D) {
Dave Houltonee281a52017-12-08 13:51:02 -07001674 if ((0 != region.srcOffset.y) || (1 != src_copy_extent.height)) {
1675 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 -06001676 HandleToUint64(src_state->image), "VUID-VkImageCopy-srcImage-00146",
Dave Houltonee281a52017-12-08 13:51:02 -07001677 "vkCmdCopyImage(): pRegion[%d] srcOffset.y is %d and extent.height is %d. For 1D images these must "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001678 "be 0 and 1, respectively.",
1679 i, region.srcOffset.y, src_copy_extent.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001680 }
1681 }
1682
Dave Houlton533be9f2018-03-26 17:08:30 -06001683 // VUID-VkImageCopy-srcImage-01785
1684 if ((src_state->createInfo.imageType == VK_IMAGE_TYPE_1D) && ((0 != region.srcOffset.z) || (1 != src_copy_extent.depth))) {
1685 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 -06001686 HandleToUint64(src_state->image), "VUID-VkImageCopy-srcImage-01785",
Dave Houlton533be9f2018-03-26 17:08:30 -06001687 "vkCmdCopyImage(): pRegion[%d] srcOffset.z is %d and extent.depth is %d. For 1D images "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001688 "these must be 0 and 1, respectively.",
1689 i, region.srcOffset.z, src_copy_extent.depth);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001690 }
1691
Dave Houlton533be9f2018-03-26 17:08:30 -06001692 // VUID-VkImageCopy-srcImage-01787
1693 if ((src_state->createInfo.imageType == VK_IMAGE_TYPE_2D) && (0 != region.srcOffset.z)) {
1694 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 -06001695 HandleToUint64(src_state->image), "VUID-VkImageCopy-srcImage-01787",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001696 "vkCmdCopyImage(): pRegion[%d] srcOffset.z is %d. For 2D images the z-offset must be 0.", i,
1697 region.srcOffset.z);
Dave Houlton533be9f2018-03-26 17:08:30 -06001698 }
1699
Mark Lobodzinski28426ae2017-06-01 07:56:38 -06001700 if (GetDeviceExtensions(device_data)->vk_khr_maintenance1) {
Dave Houlton6f9059e2017-05-02 17:15:13 -06001701 if (src_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
Dave Houltonee281a52017-12-08 13:51:02 -07001702 if ((0 != region.srcSubresource.baseArrayLayer) || (1 != region.srcSubresource.layerCount)) {
Dave Houlton6f9059e2017-05-02 17:15:13 -06001703 skip |=
1704 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06001705 HandleToUint64(src_state->image), "VUID-VkImageCopy-srcImage-00141",
Dave Houlton6f9059e2017-05-02 17:15:13 -06001706 "vkCmdCopyImage(): pRegion[%d] srcSubresource.baseArrayLayer is %d and srcSubresource.layerCount "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001707 "is %d. For VK_IMAGE_TYPE_3D images these must be 0 and 1, respectively.",
1708 i, region.srcSubresource.baseArrayLayer, region.srcSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001709 }
1710 }
1711 } else { // Pre maint 1
1712 if (src_state->createInfo.imageType == VK_IMAGE_TYPE_3D || dst_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
Dave Houltonee281a52017-12-08 13:51:02 -07001713 if ((0 != region.srcSubresource.baseArrayLayer) || (1 != region.srcSubresource.layerCount)) {
Petr Kraus13c98a62017-12-09 00:22:39 +01001714 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 -06001715 HandleToUint64(src_state->image), "VUID-VkImageCopy-srcImage-00141",
Petr Kraus13c98a62017-12-09 00:22:39 +01001716 "vkCmdCopyImage(): pRegion[%d] srcSubresource.baseArrayLayer is %d and "
1717 "srcSubresource.layerCount is %d. For copies with either source or dest of type "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001718 "VK_IMAGE_TYPE_3D, these must be 0 and 1, respectively.",
1719 i, region.srcSubresource.baseArrayLayer, region.srcSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001720 }
1721 }
1722 }
1723
Dave Houltonc991cc92018-03-06 11:08:51 -07001724 // Source checks that apply only to compressed images (or to _422 images if ycbcr enabled)
1725 bool ext_ycbcr = GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion;
1726 if (FormatIsCompressed(src_state->createInfo.format) ||
1727 (ext_ycbcr && FormatIsSinglePlane_422(src_state->createInfo.format))) {
Dave Houlton94a00372017-12-14 15:08:47 -07001728 const VkExtent3D block_size = FormatCompressedTexelBlockExtent(src_state->createInfo.format);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001729 // image offsets must be multiples of block dimensions
Dave Houltonee281a52017-12-08 13:51:02 -07001730 if ((SafeModulo(region.srcOffset.x, block_size.width) != 0) ||
1731 (SafeModulo(region.srcOffset.y, block_size.height) != 0) ||
1732 (SafeModulo(region.srcOffset.z, block_size.depth) != 0)) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001733 std::string vuid = ext_ycbcr ? "VUID-VkImageCopy-srcImage-01727" : "VUID-VkImageCopy-srcOffset-00157";
Dave Houlton6f9059e2017-05-02 17:15:13 -06001734 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 -07001735 HandleToUint64(src_state->image), vuid,
Dave Houlton6f9059e2017-05-02 17:15:13 -06001736 "vkCmdCopyImage(): pRegion[%d] srcOffset (%d, %d) must be multiples of the compressed image's "
Dave Houltonc991cc92018-03-06 11:08:51 -07001737 "texel width & height (%d, %d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001738 i, region.srcOffset.x, region.srcOffset.y, block_size.width, block_size.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001739 }
1740
Dave Houlton94a00372017-12-14 15:08:47 -07001741 const VkExtent3D mip_extent = GetImageSubresourceExtent(src_state, &(region.srcSubresource));
Dave Houltonee281a52017-12-08 13:51:02 -07001742 if ((SafeModulo(src_copy_extent.width, block_size.width) != 0) &&
1743 (src_copy_extent.width + region.srcOffset.x != mip_extent.width)) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001744 std::string vuid = ext_ycbcr ? "VUID-VkImageCopy-srcImage-01728" : "VUID-VkImageCopy-extent-00158";
Dave Houlton6f9059e2017-05-02 17:15:13 -06001745 skip |=
1746 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltonc991cc92018-03-06 11:08:51 -07001747 HandleToUint64(src_state->image), vuid,
Dave Houlton6f9059e2017-05-02 17:15:13 -06001748 "vkCmdCopyImage(): pRegion[%d] extent width (%d) must be a multiple of the compressed texture block "
Dave Houltonc991cc92018-03-06 11:08:51 -07001749 "width (%d), or when added to srcOffset.x (%d) must equal the image subresource width (%d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001750 i, src_copy_extent.width, block_size.width, region.srcOffset.x, mip_extent.width);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001751 }
1752
Mark Lobodzinskid0788802017-10-19 15:38:59 -06001753 // Extent height must be a multiple of block height, or extent+offset height must equal subresource height
Dave Houltonee281a52017-12-08 13:51:02 -07001754 if ((SafeModulo(src_copy_extent.height, block_size.height) != 0) &&
1755 (src_copy_extent.height + region.srcOffset.y != mip_extent.height)) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001756 std::string vuid = ext_ycbcr ? "VUID-VkImageCopy-srcImage-01729" : "VUID-VkImageCopy-extent-00159";
Dave Houlton6f9059e2017-05-02 17:15:13 -06001757 skip |=
1758 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltonc991cc92018-03-06 11:08:51 -07001759 HandleToUint64(src_state->image), vuid,
Dave Houlton6f9059e2017-05-02 17:15:13 -06001760 "vkCmdCopyImage(): pRegion[%d] extent height (%d) must be a multiple of the compressed texture block "
Dave Houltonc991cc92018-03-06 11:08:51 -07001761 "height (%d), or when added to srcOffset.y (%d) must equal the image subresource height (%d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001762 i, src_copy_extent.height, block_size.height, region.srcOffset.y, mip_extent.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001763 }
1764
Mark Lobodzinskid0788802017-10-19 15:38:59 -06001765 // Extent depth must be a multiple of block depth, or extent+offset depth must equal subresource depth
Dave Houltonee281a52017-12-08 13:51:02 -07001766 uint32_t copy_depth = (slice_override ? depth_slices : src_copy_extent.depth);
1767 if ((SafeModulo(copy_depth, block_size.depth) != 0) && (copy_depth + region.srcOffset.z != mip_extent.depth)) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001768 std::string vuid = ext_ycbcr ? "VUID-VkImageCopy-srcImage-01730" : "VUID-VkImageCopy-extent-00160";
Dave Houlton6f9059e2017-05-02 17:15:13 -06001769 skip |=
1770 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltonc991cc92018-03-06 11:08:51 -07001771 HandleToUint64(src_state->image), vuid,
Dave Houlton6f9059e2017-05-02 17:15:13 -06001772 "vkCmdCopyImage(): pRegion[%d] extent width (%d) must be a multiple of the compressed texture block "
Dave Houltonc991cc92018-03-06 11:08:51 -07001773 "depth (%d), or when added to srcOffset.z (%d) must equal the image subresource depth (%d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001774 i, src_copy_extent.depth, block_size.depth, region.srcOffset.z, mip_extent.depth);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001775 }
1776 } // Compressed
1777
1778 // Do all checks on dest image
1779 //
1780 if (dst_state->createInfo.imageType == VK_IMAGE_TYPE_1D) {
Dave Houltonee281a52017-12-08 13:51:02 -07001781 if ((0 != region.dstOffset.y) || (1 != dst_copy_extent.height)) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07001782 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 -06001783 HandleToUint64(dst_state->image), "VUID-VkImageCopy-dstImage-00152",
Dave Houltona9df0ce2018-02-07 10:51:23 -07001784 "vkCmdCopyImage(): pRegion[%d] dstOffset.y is %d and dst_copy_extent.height is %d. For 1D images "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001785 "these must be 0 and 1, respectively.",
1786 i, region.dstOffset.y, dst_copy_extent.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001787 }
1788 }
1789
Dave Houlton533be9f2018-03-26 17:08:30 -06001790 // VUID-VkImageCopy-dstImage-01786
1791 if ((dst_state->createInfo.imageType == VK_IMAGE_TYPE_1D) && ((0 != region.dstOffset.z) || (1 != dst_copy_extent.depth))) {
1792 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 -06001793 HandleToUint64(dst_state->image), "VUID-VkImageCopy-dstImage-01786",
Dave Houlton533be9f2018-03-26 17:08:30 -06001794 "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 -06001795 "and 1, respectively.",
1796 i, region.dstOffset.z, dst_copy_extent.depth);
Dave Houlton533be9f2018-03-26 17:08:30 -06001797 }
1798
1799 // VUID-VkImageCopy-dstImage-01788
1800 if ((dst_state->createInfo.imageType == VK_IMAGE_TYPE_2D) && (0 != region.dstOffset.z)) {
1801 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 -06001802 HandleToUint64(dst_state->image), "VUID-VkImageCopy-dstImage-01788",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001803 "vkCmdCopyImage(): pRegion[%d] dstOffset.z is %d. For 2D images the z-offset must be 0.", i,
1804 region.dstOffset.z);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001805 }
1806
1807 if (dst_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
Dave Houltonee281a52017-12-08 13:51:02 -07001808 if ((0 != region.dstSubresource.baseArrayLayer) || (1 != region.dstSubresource.layerCount)) {
Dave Houlton6f9059e2017-05-02 17:15:13 -06001809 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 -06001810 HandleToUint64(dst_state->image), "VUID-VkImageCopy-srcImage-00141",
Dave Houlton6f9059e2017-05-02 17:15:13 -06001811 "vkCmdCopyImage(): pRegion[%d] dstSubresource.baseArrayLayer is %d and dstSubresource.layerCount "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001812 "is %d. For VK_IMAGE_TYPE_3D images these must be 0 and 1, respectively.",
1813 i, region.dstSubresource.baseArrayLayer, region.dstSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001814 }
1815 }
1816 // VU01199 changed with mnt1
Mark Lobodzinski28426ae2017-06-01 07:56:38 -06001817 if (GetDeviceExtensions(device_data)->vk_khr_maintenance1) {
Dave Houlton6f9059e2017-05-02 17:15:13 -06001818 if (dst_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
Dave Houltonee281a52017-12-08 13:51:02 -07001819 if ((0 != region.dstSubresource.baseArrayLayer) || (1 != region.dstSubresource.layerCount)) {
Dave Houlton6f9059e2017-05-02 17:15:13 -06001820 skip |=
1821 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06001822 HandleToUint64(dst_state->image), "VUID-VkImageCopy-srcImage-00141",
Dave Houlton6f9059e2017-05-02 17:15:13 -06001823 "vkCmdCopyImage(): pRegion[%d] dstSubresource.baseArrayLayer is %d and dstSubresource.layerCount "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001824 "is %d. For VK_IMAGE_TYPE_3D images these must be 0 and 1, respectively.",
1825 i, region.dstSubresource.baseArrayLayer, region.dstSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001826 }
1827 }
1828 } else { // Pre maint 1
1829 if (src_state->createInfo.imageType == VK_IMAGE_TYPE_3D || dst_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
Dave Houltonee281a52017-12-08 13:51:02 -07001830 if ((0 != region.dstSubresource.baseArrayLayer) || (1 != region.dstSubresource.layerCount)) {
Petr Kraus13c98a62017-12-09 00:22:39 +01001831 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 -06001832 HandleToUint64(dst_state->image), "VUID-VkImageCopy-srcImage-00141",
Petr Kraus13c98a62017-12-09 00:22:39 +01001833 "vkCmdCopyImage(): pRegion[%d] dstSubresource.baseArrayLayer is %d and "
1834 "dstSubresource.layerCount is %d. For copies with either source or dest of type "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001835 "VK_IMAGE_TYPE_3D, these must be 0 and 1, respectively.",
1836 i, region.dstSubresource.baseArrayLayer, region.dstSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001837 }
1838 }
1839 }
1840
Dave Houltonc991cc92018-03-06 11:08:51 -07001841 // Dest checks that apply only to compressed images (or to _422 images if ycbcr enabled)
1842 if (FormatIsCompressed(dst_state->createInfo.format) ||
1843 (ext_ycbcr && FormatIsSinglePlane_422(dst_state->createInfo.format))) {
Dave Houlton94a00372017-12-14 15:08:47 -07001844 const VkExtent3D block_size = FormatCompressedTexelBlockExtent(dst_state->createInfo.format);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001845
1846 // image offsets must be multiples of block dimensions
Dave Houltonee281a52017-12-08 13:51:02 -07001847 if ((SafeModulo(region.dstOffset.x, block_size.width) != 0) ||
1848 (SafeModulo(region.dstOffset.y, block_size.height) != 0) ||
1849 (SafeModulo(region.dstOffset.z, block_size.depth) != 0)) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001850 std::string vuid = ext_ycbcr ? "VUID-VkImageCopy-dstImage-01731" : "VUID-VkImageCopy-dstOffset-00162";
Dave Houlton6f9059e2017-05-02 17:15:13 -06001851 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 -07001852 HandleToUint64(dst_state->image), vuid,
Dave Houlton6f9059e2017-05-02 17:15:13 -06001853 "vkCmdCopyImage(): pRegion[%d] dstOffset (%d, %d) must be multiples of the compressed image's "
Dave Houltonc991cc92018-03-06 11:08:51 -07001854 "texel width & height (%d, %d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001855 i, region.dstOffset.x, region.dstOffset.y, block_size.width, block_size.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001856 }
1857
Dave Houlton94a00372017-12-14 15:08:47 -07001858 const VkExtent3D mip_extent = GetImageSubresourceExtent(dst_state, &(region.dstSubresource));
Dave Houltonee281a52017-12-08 13:51:02 -07001859 if ((SafeModulo(dst_copy_extent.width, block_size.width) != 0) &&
1860 (dst_copy_extent.width + region.dstOffset.x != mip_extent.width)) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001861 std::string vuid = ext_ycbcr ? "VUID-VkImageCopy-dstImage-01732" : "VUID-VkImageCopy-extent-00163";
Dave Houltona9df0ce2018-02-07 10:51:23 -07001862 skip |=
1863 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltonc991cc92018-03-06 11:08:51 -07001864 HandleToUint64(dst_state->image), vuid,
Dave Houltona9df0ce2018-02-07 10:51:23 -07001865 "vkCmdCopyImage(): pRegion[%d] dst_copy_extent width (%d) must be a multiple of the compressed texture "
Dave Houltonc991cc92018-03-06 11:08:51 -07001866 "block width (%d), or when added to dstOffset.x (%d) must equal the image subresource width (%d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001867 i, dst_copy_extent.width, block_size.width, region.dstOffset.x, mip_extent.width);
Mark Lobodzinskid0788802017-10-19 15:38:59 -06001868 }
1869
Dave Houltonee281a52017-12-08 13:51:02 -07001870 // Extent height must be a multiple of block height, or dst_copy_extent+offset height must equal subresource height
1871 if ((SafeModulo(dst_copy_extent.height, block_size.height) != 0) &&
1872 (dst_copy_extent.height + region.dstOffset.y != mip_extent.height)) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001873 std::string vuid = ext_ycbcr ? "VUID-VkImageCopy-dstImage-01733" : "VUID-VkImageCopy-extent-00164";
Dave Houltona9df0ce2018-02-07 10:51:23 -07001874 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 -07001875 HandleToUint64(dst_state->image), vuid,
Dave Houltona9df0ce2018-02-07 10:51:23 -07001876 "vkCmdCopyImage(): pRegion[%d] dst_copy_extent height (%d) must be a multiple of the compressed "
1877 "texture block height (%d), or when added to dstOffset.y (%d) must equal the image subresource "
Dave Houltonc991cc92018-03-06 11:08:51 -07001878 "height (%d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001879 i, dst_copy_extent.height, block_size.height, region.dstOffset.y, mip_extent.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001880 }
1881
Dave Houltonee281a52017-12-08 13:51:02 -07001882 // Extent depth must be a multiple of block depth, or dst_copy_extent+offset depth must equal subresource depth
1883 uint32_t copy_depth = (slice_override ? depth_slices : dst_copy_extent.depth);
1884 if ((SafeModulo(copy_depth, block_size.depth) != 0) && (copy_depth + region.dstOffset.z != mip_extent.depth)) {
Dave Houltond8ed0212018-05-16 17:18:24 -06001885 std::string vuid = ext_ycbcr ? "VUID-VkImageCopy-dstImage-01734" : "VUID-VkImageCopy-extent-00165";
Dave Houltona9df0ce2018-02-07 10:51:23 -07001886 skip |=
1887 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltonc991cc92018-03-06 11:08:51 -07001888 HandleToUint64(dst_state->image), vuid,
Dave Houltona9df0ce2018-02-07 10:51:23 -07001889 "vkCmdCopyImage(): pRegion[%d] dst_copy_extent width (%d) must be a multiple of the compressed texture "
Dave Houltonc991cc92018-03-06 11:08:51 -07001890 "block depth (%d), or when added to dstOffset.z (%d) must equal the image subresource depth (%d).",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001891 i, dst_copy_extent.depth, block_size.depth, region.dstOffset.z, mip_extent.depth);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001892 }
1893 } // Compressed
1894 }
1895 return skip;
1896}
1897
Dave Houltonc991cc92018-03-06 11:08:51 -07001898// vkCmdCopyImage checks that only apply if the multiplane extension is enabled
1899bool CopyImageMultiplaneValidation(const layer_data *dev_data, VkCommandBuffer command_buffer, const IMAGE_STATE *src_image_state,
1900 const IMAGE_STATE *dst_image_state, const VkImageCopy region) {
1901 bool skip = false;
1902 const debug_report_data *report_data = core_validation::GetReportData(dev_data);
1903
1904 // Neither image is multiplane
1905 if ((!FormatIsMultiplane(src_image_state->createInfo.format)) && (!FormatIsMultiplane(dst_image_state->createInfo.format))) {
1906 // If neither image is multi-plane the aspectMask member of src and dst must match
1907 if (region.srcSubresource.aspectMask != region.dstSubresource.aspectMask) {
1908 std::stringstream ss;
1909 ss << "vkCmdCopyImage: Copy between non-multiplane images with differing aspectMasks ( 0x" << std::hex
1910 << region.srcSubresource.aspectMask << " and 0x" << region.dstSubresource.aspectMask << " )";
1911 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 -06001912 HandleToUint64(command_buffer), "VUID-VkImageCopy-srcImage-01551", "%s.", ss.str().c_str());
Dave Houltonc991cc92018-03-06 11:08:51 -07001913 }
1914 } else {
1915 // Source image multiplane checks
1916 uint32_t planes = FormatPlaneCount(src_image_state->createInfo.format);
1917 VkImageAspectFlags aspect = region.srcSubresource.aspectMask;
1918 if ((2 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT_KHR) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT_KHR)) {
1919 std::stringstream ss;
1920 ss << "vkCmdCopyImage: Source image aspect mask (0x" << std::hex << aspect << ") is invalid for 2-plane format";
1921 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 -06001922 HandleToUint64(command_buffer), "VUID-VkImageCopy-srcImage-01552", "%s.", ss.str().c_str());
Dave Houltonc991cc92018-03-06 11:08:51 -07001923 }
1924 if ((3 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT_KHR) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT_KHR) &&
1925 (aspect != VK_IMAGE_ASPECT_PLANE_2_BIT_KHR)) {
1926 std::stringstream ss;
1927 ss << "vkCmdCopyImage: Source image aspect mask (0x" << std::hex << aspect << ") is invalid for 3-plane format";
1928 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 -06001929 HandleToUint64(command_buffer), "VUID-VkImageCopy-srcImage-01553", "%s.", ss.str().c_str());
Dave Houltonc991cc92018-03-06 11:08:51 -07001930 }
1931 // Single-plane to multi-plane
1932 if ((!FormatIsMultiplane(src_image_state->createInfo.format)) && (FormatIsMultiplane(dst_image_state->createInfo.format)) &&
1933 (VK_IMAGE_ASPECT_COLOR_BIT != aspect)) {
1934 std::stringstream ss;
1935 ss << "vkCmdCopyImage: Source image aspect mask (0x" << std::hex << aspect << ") is not VK_IMAGE_ASPECT_COLOR_BIT";
1936 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 -06001937 HandleToUint64(command_buffer), "VUID-VkImageCopy-dstImage-01557", "%s.", ss.str().c_str());
Dave Houltonc991cc92018-03-06 11:08:51 -07001938 }
1939
1940 // Dest image multiplane checks
1941 planes = FormatPlaneCount(dst_image_state->createInfo.format);
1942 aspect = region.dstSubresource.aspectMask;
1943 if ((2 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT_KHR) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT_KHR)) {
1944 std::stringstream ss;
1945 ss << "vkCmdCopyImage: Dest image aspect mask (0x" << std::hex << aspect << ") is invalid for 2-plane format";
1946 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 -06001947 HandleToUint64(command_buffer), "VUID-VkImageCopy-dstImage-01554", "%s.", ss.str().c_str());
Dave Houltonc991cc92018-03-06 11:08:51 -07001948 }
1949 if ((3 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT_KHR) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT_KHR) &&
1950 (aspect != VK_IMAGE_ASPECT_PLANE_2_BIT_KHR)) {
1951 std::stringstream ss;
1952 ss << "vkCmdCopyImage: Dest image aspect mask (0x" << std::hex << aspect << ") is invalid for 3-plane format";
1953 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 -06001954 HandleToUint64(command_buffer), "VUID-VkImageCopy-dstImage-01555", "%s.", ss.str().c_str());
Dave Houltonc991cc92018-03-06 11:08:51 -07001955 }
1956 // Multi-plane to single-plane
1957 if ((FormatIsMultiplane(src_image_state->createInfo.format)) && (!FormatIsMultiplane(dst_image_state->createInfo.format)) &&
1958 (VK_IMAGE_ASPECT_COLOR_BIT != aspect)) {
1959 std::stringstream ss;
1960 ss << "vkCmdCopyImage: Dest image aspect mask (0x" << std::hex << aspect << ") is not VK_IMAGE_ASPECT_COLOR_BIT";
1961 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 -06001962 HandleToUint64(command_buffer), "VUID-VkImageCopy-srcImage-01556", "%s.", ss.str().c_str());
Dave Houltonc991cc92018-03-06 11:08:51 -07001963 }
1964 }
1965
1966 return skip;
1967}
1968
Tobin Ehlis58c884f2017-02-08 12:15:27 -07001969bool PreCallValidateCmdCopyImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state,
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001970 IMAGE_STATE *dst_image_state, uint32_t region_count, const VkImageCopy *regions,
1971 VkImageLayout src_image_layout, VkImageLayout dst_image_layout) {
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001972 bool skip = false;
1973 const debug_report_data *report_data = core_validation::GetReportData(device_data);
Dave Houlton6f9059e2017-05-02 17:15:13 -06001974 skip = ValidateImageCopyData(device_data, report_data, region_count, regions, src_image_state, dst_image_state);
1975
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07001976 VkCommandBuffer command_buffer = cb_node->commandBuffer;
1977
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07001978 for (uint32_t i = 0; i < region_count; i++) {
Dave Houlton94a00372017-12-14 15:08:47 -07001979 const VkImageCopy region = regions[i];
Dave Houltonee281a52017-12-08 13:51:02 -07001980
1981 // For comp/uncomp copies, the copy extent for the dest image must be adjusted
1982 VkExtent3D src_copy_extent = region.extent;
1983 VkExtent3D dst_copy_extent =
1984 GetAdjustedDestImageExtent(src_image_state->createInfo.format, dst_image_state->createInfo.format, region.extent);
1985
Dave Houlton6f9059e2017-05-02 17:15:13 -06001986 bool slice_override = false;
1987 uint32_t depth_slices = 0;
1988
1989 // Special case for copying between a 1D/2D array and a 3D image
1990 // TBD: This seems like the only way to reconcile 3 mutually-exclusive VU checks for 2D/3D copies. Heads up.
1991 if ((VK_IMAGE_TYPE_3D == src_image_state->createInfo.imageType) &&
1992 (VK_IMAGE_TYPE_3D != dst_image_state->createInfo.imageType)) {
Dave Houltonee281a52017-12-08 13:51:02 -07001993 depth_slices = region.dstSubresource.layerCount; // Slice count from 2D subresource
Dave Houlton6f9059e2017-05-02 17:15:13 -06001994 slice_override = (depth_slices != 1);
1995 } else if ((VK_IMAGE_TYPE_3D == dst_image_state->createInfo.imageType) &&
1996 (VK_IMAGE_TYPE_3D != src_image_state->createInfo.imageType)) {
Dave Houltonee281a52017-12-08 13:51:02 -07001997 depth_slices = region.srcSubresource.layerCount; // Slice count from 2D subresource
Dave Houlton6f9059e2017-05-02 17:15:13 -06001998 slice_override = (depth_slices != 1);
1999 }
2000
Dave Houltonee281a52017-12-08 13:51:02 -07002001 if (region.srcSubresource.layerCount == 0) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002002 std::stringstream ss;
2003 ss << "vkCmdCopyImage: number of layers in pRegions[" << i << "] srcSubresource is zero";
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06002004 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002005 HandleToUint64(command_buffer), DRAWSTATE_INVALID_IMAGE_ASPECT, "%s", ss.str().c_str());
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002006 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002007
Dave Houltonee281a52017-12-08 13:51:02 -07002008 if (region.dstSubresource.layerCount == 0) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002009 std::stringstream ss;
2010 ss << "vkCmdCopyImage: number of layers in pRegions[" << i << "] dstSubresource is zero";
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06002011 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002012 HandleToUint64(command_buffer), DRAWSTATE_INVALID_IMAGE_ASPECT, "%s", ss.str().c_str());
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002013 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002014
Mark Lobodzinski28426ae2017-06-01 07:56:38 -06002015 if (GetDeviceExtensions(device_data)->vk_khr_maintenance1) {
Dave Houlton6f9059e2017-05-02 17:15:13 -06002016 // No chance of mismatch if we're overriding depth slice count
2017 if (!slice_override) {
2018 // The number of depth slices in srcSubresource and dstSubresource must match
2019 // Depth comes from layerCount for 1D,2D resources, from extent.depth for 3D
2020 uint32_t src_slices =
Dave Houltonee281a52017-12-08 13:51:02 -07002021 (VK_IMAGE_TYPE_3D == src_image_state->createInfo.imageType ? src_copy_extent.depth
2022 : region.srcSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002023 uint32_t dst_slices =
Dave Houltonee281a52017-12-08 13:51:02 -07002024 (VK_IMAGE_TYPE_3D == dst_image_state->createInfo.imageType ? dst_copy_extent.depth
2025 : region.dstSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002026 if (src_slices != dst_slices) {
2027 std::stringstream ss;
2028 ss << "vkCmdCopyImage: number of depth slices in source and destination subresources for pRegions[" << i
2029 << "] do not match";
2030 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 -06002031 HandleToUint64(command_buffer), "VUID-VkImageCopy-extent-00140", "%s.", ss.str().c_str());
Dave Houlton6f9059e2017-05-02 17:15:13 -06002032 }
2033 }
2034 } else {
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002035 // For each region the layerCount member of srcSubresource and dstSubresource must match
Dave Houltonee281a52017-12-08 13:51:02 -07002036 if (region.srcSubresource.layerCount != region.dstSubresource.layerCount) {
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002037 std::stringstream ss;
2038 ss << "vkCmdCopyImage: number of layers in source and destination subresources for pRegions[" << i
2039 << "] do not match";
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06002040 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 -06002041 HandleToUint64(command_buffer), "VUID-VkImageCopy-extent-00140", "%s.", ss.str().c_str());
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002042 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002043 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002044
Dave Houltonc991cc92018-03-06 11:08:51 -07002045 // Do multiplane-specific checks, if extension enabled
2046 if (GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) {
2047 skip |= CopyImageMultiplaneValidation(device_data, command_buffer, src_image_state, dst_image_state, region);
2048 }
2049
Dave Houltonf5217612018-02-02 16:18:52 -07002050 if (!GetDeviceExtensions(device_data)->vk_khr_sampler_ycbcr_conversion) {
2051 // not multi-plane, the aspectMask member of srcSubresource and dstSubresource must match
2052 if (region.srcSubresource.aspectMask != region.dstSubresource.aspectMask) {
2053 char const str[] = "vkCmdCopyImage: Src and dest aspectMasks for each region must match";
2054 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 -06002055 HandleToUint64(command_buffer), "VUID-VkImageCopy-aspectMask-00137", "%s.", str);
Dave Houltonf5217612018-02-02 16:18:52 -07002056 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002057 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002058
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06002059 // For each region, the aspectMask member of srcSubresource must be present in the source image
Dave Houltonee281a52017-12-08 13:51:02 -07002060 if (!VerifyAspectsPresent(region.srcSubresource.aspectMask, src_image_state->createInfo.format)) {
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06002061 std::stringstream ss;
2062 ss << "vkCmdCopyImage: pRegion[" << i
2063 << "] srcSubresource.aspectMask cannot specify aspects not present in source image";
2064 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 -06002065 HandleToUint64(command_buffer), "VUID-VkImageCopy-aspectMask-00142", "%s.", ss.str().c_str());
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06002066 }
2067
2068 // For each region, the aspectMask member of dstSubresource must be present in the destination image
Dave Houltonee281a52017-12-08 13:51:02 -07002069 if (!VerifyAspectsPresent(region.dstSubresource.aspectMask, dst_image_state->createInfo.format)) {
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06002070 std::stringstream ss;
2071 ss << "vkCmdCopyImage: pRegion[" << i << "] dstSubresource.aspectMask cannot specify aspects not present in dest image";
2072 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 -06002073 HandleToUint64(command_buffer), "VUID-VkImageCopy-aspectMask-00143", "%s.", ss.str().c_str());
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06002074 }
2075
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002076 // AspectMask must not contain VK_IMAGE_ASPECT_METADATA_BIT
Dave Houltonee281a52017-12-08 13:51:02 -07002077 if ((region.srcSubresource.aspectMask & VK_IMAGE_ASPECT_METADATA_BIT) ||
2078 (region.dstSubresource.aspectMask & VK_IMAGE_ASPECT_METADATA_BIT)) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002079 std::stringstream ss;
2080 ss << "vkCmdCopyImage: pRegions[" << i << "] may not specify aspectMask containing VK_IMAGE_ASPECT_METADATA_BIT";
Dave Houltond8ed0212018-05-16 17:18:24 -06002081 skip |=
2082 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2083 HandleToUint64(command_buffer), "VUID-VkImageSubresourceLayers-aspectMask-00168", "%s.", ss.str().c_str());
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002084 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002085
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002086 // For each region, if aspectMask contains VK_IMAGE_ASPECT_COLOR_BIT, it must not contain either of
2087 // VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT
Dave Houltonee281a52017-12-08 13:51:02 -07002088 if ((region.srcSubresource.aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) &&
2089 (region.srcSubresource.aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002090 char const str[] = "vkCmdCopyImage aspectMask cannot specify both COLOR and DEPTH/STENCIL aspects";
2091 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 -06002092 HandleToUint64(command_buffer), "VUID-VkImageSubresourceLayers-aspectMask-00167", "%s.", str);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002093 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002094
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002095 // MipLevel must be less than the mipLevels specified in VkImageCreateInfo when the image was created
Dave Houltonee281a52017-12-08 13:51:02 -07002096 if (region.srcSubresource.mipLevel >= src_image_state->createInfo.mipLevels) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002097 std::stringstream ss;
2098 ss << "vkCmdCopyImage: pRegions[" << i
2099 << "] specifies a src mipLevel greater than the number specified when the srcImage was created.";
2100 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 -06002101 HandleToUint64(command_buffer), "VUID-vkCmdCopyImage-srcSubresource-01696", "%s.", ss.str().c_str());
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002102 }
Dave Houltonee281a52017-12-08 13:51:02 -07002103 if (region.dstSubresource.mipLevel >= dst_image_state->createInfo.mipLevels) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002104 std::stringstream ss;
2105 ss << "vkCmdCopyImage: pRegions[" << i
2106 << "] specifies a dst mipLevel greater than the number specified when the dstImage was created.";
2107 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 -06002108 HandleToUint64(command_buffer), "VUID-vkCmdCopyImage-dstSubresource-01697", "%s.", ss.str().c_str());
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002109 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002110
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002111 // (baseArrayLayer + layerCount) must be less than or equal to the arrayLayers specified in VkImageCreateInfo when the
2112 // image was created
Dave Houltonee281a52017-12-08 13:51:02 -07002113 if ((region.srcSubresource.baseArrayLayer + region.srcSubresource.layerCount) > src_image_state->createInfo.arrayLayers) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002114 std::stringstream ss;
2115 ss << "vkCmdCopyImage: srcImage arrayLayers was " << src_image_state->createInfo.arrayLayers << " but subRegion[" << i
Dave Houltonee281a52017-12-08 13:51:02 -07002116 << "] baseArrayLayer + layerCount is " << (region.srcSubresource.baseArrayLayer + region.srcSubresource.layerCount);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002117 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 -06002118 HandleToUint64(command_buffer), "VUID-vkCmdCopyImage-srcSubresource-01698", "%s.", ss.str().c_str());
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002119 }
Dave Houltonee281a52017-12-08 13:51:02 -07002120 if ((region.dstSubresource.baseArrayLayer + region.dstSubresource.layerCount) > dst_image_state->createInfo.arrayLayers) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002121 std::stringstream ss;
2122 ss << "vkCmdCopyImage: dstImage arrayLayers was " << dst_image_state->createInfo.arrayLayers << " but subRegion[" << i
Dave Houltonee281a52017-12-08 13:51:02 -07002123 << "] baseArrayLayer + layerCount is " << (region.dstSubresource.baseArrayLayer + region.dstSubresource.layerCount);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002124 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 -06002125 HandleToUint64(command_buffer), "VUID-vkCmdCopyImage-dstSubresource-01699", "%s.", ss.str().c_str());
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002126 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002127
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002128 // Check region extents for 1D-1D, 2D-2D, and 3D-3D copies
2129 if (src_image_state->createInfo.imageType == dst_image_state->createInfo.imageType) {
2130 // 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 -07002131 VkExtent3D img_extent = GetImageSubresourceExtent(src_image_state, &(region.srcSubresource));
2132 if (0 != ExceedsBounds(&region.srcOffset, &src_copy_extent, &img_extent)) {
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002133 std::stringstream ss;
Dave Houltonee281a52017-12-08 13:51:02 -07002134 ss << "vkCmdCopyImage: Source pRegion[" << i << "] with mipLevel [ " << region.srcSubresource.mipLevel
2135 << " ], offset [ " << region.srcOffset.x << ", " << region.srcOffset.y << ", " << region.srcOffset.z
2136 << " ], extent [ " << src_copy_extent.width << ", " << src_copy_extent.height << ", " << src_copy_extent.depth
2137 << " ] exceeds the source image dimensions";
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06002138 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 -06002139 HandleToUint64(command_buffer), "VUID-vkCmdCopyImage-pRegions-00122", "%s.", ss.str().c_str());
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002140 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002141
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002142 // 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 -07002143 img_extent = GetImageSubresourceExtent(dst_image_state, &(region.dstSubresource));
2144 if (0 != ExceedsBounds(&region.dstOffset, &dst_copy_extent, &img_extent)) {
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002145 std::stringstream ss;
Dave Houltonee281a52017-12-08 13:51:02 -07002146 ss << "vkCmdCopyImage: Dest pRegion[" << i << "] with mipLevel [ " << region.dstSubresource.mipLevel
2147 << " ], offset [ " << region.dstOffset.x << ", " << region.dstOffset.y << ", " << region.dstOffset.z
2148 << " ], extent [ " << dst_copy_extent.width << ", " << dst_copy_extent.height << ", " << dst_copy_extent.depth
2149 << " ] exceeds the destination image dimensions";
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06002150 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 -06002151 HandleToUint64(command_buffer), "VUID-vkCmdCopyImage-pRegions-00123", "%s.", ss.str().c_str());
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002152 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002153 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002154
Dave Houltonfc1a4052017-04-27 14:32:45 -06002155 // Each dimension offset + extent limits must fall with image subresource extent
Dave Houltonee281a52017-12-08 13:51:02 -07002156 VkExtent3D subresource_extent = GetImageSubresourceExtent(src_image_state, &(region.srcSubresource));
2157 if (slice_override) src_copy_extent.depth = depth_slices;
2158 uint32_t extent_check = ExceedsBounds(&(region.srcOffset), &src_copy_extent, &subresource_extent);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002159 if (extent_check & x_bit) {
2160 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 -06002161 HandleToUint64(command_buffer), "VUID-VkImageCopy-srcOffset-00144",
Dave Houltonfc1a4052017-04-27 14:32:45 -06002162 "vkCmdCopyImage: Source image pRegion %1d x-dimension offset [%1d] + extent [%1d] exceeds subResource "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002163 "width [%1d].",
2164 i, region.srcOffset.x, src_copy_extent.width, subresource_extent.width);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002165 }
2166
2167 if (extent_check & y_bit) {
2168 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 -06002169 HandleToUint64(command_buffer), "VUID-VkImageCopy-srcOffset-00145",
Dave Houltonfc1a4052017-04-27 14:32:45 -06002170 "vkCmdCopyImage: Source image pRegion %1d y-dimension offset [%1d] + extent [%1d] exceeds subResource "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002171 "height [%1d].",
2172 i, region.srcOffset.y, src_copy_extent.height, subresource_extent.height);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002173 }
2174 if (extent_check & z_bit) {
2175 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 -06002176 HandleToUint64(command_buffer), "VUID-VkImageCopy-srcOffset-00147",
Dave Houltonfc1a4052017-04-27 14:32:45 -06002177 "vkCmdCopyImage: Source image pRegion %1d z-dimension offset [%1d] + extent [%1d] exceeds subResource "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002178 "depth [%1d].",
2179 i, region.srcOffset.z, src_copy_extent.depth, subresource_extent.depth);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002180 }
2181
Dave Houltonee281a52017-12-08 13:51:02 -07002182 // Adjust dest extent if necessary
2183 subresource_extent = GetImageSubresourceExtent(dst_image_state, &(region.dstSubresource));
2184 if (slice_override) dst_copy_extent.depth = depth_slices;
2185
2186 extent_check = ExceedsBounds(&(region.dstOffset), &dst_copy_extent, &subresource_extent);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002187 if (extent_check & x_bit) {
2188 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 -06002189 HandleToUint64(command_buffer), "VUID-VkImageCopy-dstOffset-00150",
Dave Houltonfc1a4052017-04-27 14:32:45 -06002190 "vkCmdCopyImage: Dest image pRegion %1d x-dimension offset [%1d] + extent [%1d] exceeds subResource "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002191 "width [%1d].",
2192 i, region.dstOffset.x, dst_copy_extent.width, subresource_extent.width);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002193 }
2194 if (extent_check & y_bit) {
2195 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 -06002196 HandleToUint64(command_buffer), "VUID-VkImageCopy-dstOffset-00151",
Dave Houltonfc1a4052017-04-27 14:32:45 -06002197 "vkCmdCopyImage: Dest image pRegion %1d y-dimension offset [%1d] + extent [%1d] exceeds subResource "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002198 "height [%1d].",
2199 i, region.dstOffset.y, dst_copy_extent.height, subresource_extent.height);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002200 }
2201 if (extent_check & z_bit) {
2202 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 -06002203 HandleToUint64(command_buffer), "VUID-VkImageCopy-dstOffset-00153",
Dave Houltonfc1a4052017-04-27 14:32:45 -06002204 "vkCmdCopyImage: Dest image pRegion %1d z-dimension offset [%1d] + extent [%1d] exceeds subResource "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002205 "depth [%1d].",
2206 i, region.dstOffset.z, dst_copy_extent.depth, subresource_extent.depth);
Dave Houltonfc1a4052017-04-27 14:32:45 -06002207 }
2208
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002209 // The union of all source regions, and the union of all destination regions, specified by the elements of regions,
2210 // must not overlap in memory
2211 if (src_image_state->image == dst_image_state->image) {
2212 for (uint32_t j = 0; j < region_count; j++) {
Dave Houltonf5217612018-02-02 16:18:52 -07002213 if (RegionIntersects(&region, &regions[j], src_image_state->createInfo.imageType,
2214 FormatIsMultiplane(src_image_state->createInfo.format))) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002215 std::stringstream ss;
2216 ss << "vkCmdCopyImage: pRegions[" << i << "] src overlaps with pRegions[" << j << "].";
2217 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 -06002218 HandleToUint64(command_buffer), "VUID-vkCmdCopyImage-pRegions-00124", "%s.", ss.str().c_str());
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002219 }
2220 }
2221 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002222 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002223
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002224 // The formats of src_image and dst_image must be compatible. Formats are considered compatible if their texel size in bytes
2225 // is the same between both formats. For example, VK_FORMAT_R8G8B8A8_UNORM is compatible with VK_FORMAT_R32_UINT because
2226 // because both texels are 4 bytes in size. Depth/stencil formats must match exactly.
Dave Houlton1150cf52017-04-27 14:38:11 -06002227 if (FormatIsDepthOrStencil(src_image_state->createInfo.format) || FormatIsDepthOrStencil(dst_image_state->createInfo.format)) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002228 if (src_image_state->createInfo.format != dst_image_state->createInfo.format) {
2229 char const str[] = "vkCmdCopyImage called with unmatched source and dest image depth/stencil formats.";
Petr Krausbc7f5442017-05-14 23:43:38 +02002230 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002231 HandleToUint64(command_buffer), DRAWSTATE_MISMATCHED_IMAGE_FORMAT, str);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002232 }
2233 } else {
Dave Houlton1d2022c2017-03-29 11:43:58 -06002234 size_t srcSize = FormatSize(src_image_state->createInfo.format);
2235 size_t destSize = FormatSize(dst_image_state->createInfo.format);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002236 if (srcSize != destSize) {
2237 char const str[] = "vkCmdCopyImage called with unmatched source and dest image format sizes.";
2238 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 -06002239 HandleToUint64(command_buffer), "VUID-vkCmdCopyImage-srcImage-00135", "%s.", str);
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002240 }
2241 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002242
Dave Houlton33c22b72017-02-28 13:16:02 -07002243 // Source and dest image sample counts must match
2244 if (src_image_state->createInfo.samples != dst_image_state->createInfo.samples) {
2245 char const str[] = "vkCmdCopyImage() called on image pair with non-identical sample counts.";
2246 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 -06002247 HandleToUint64(command_buffer), "VUID-vkCmdCopyImage-srcImage-00136", "%s", str);
Dave Houlton33c22b72017-02-28 13:16:02 -07002248 }
2249
Dave Houltond8ed0212018-05-16 17:18:24 -06002250 skip |= ValidateMemoryIsBoundToImage(device_data, src_image_state, "vkCmdCopyImage()", "VUID-vkCmdCopyImage-srcImage-00127");
2251 skip |= ValidateMemoryIsBoundToImage(device_data, dst_image_state, "vkCmdCopyImage()", "VUID-vkCmdCopyImage-dstImage-00132");
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002252 // Validate that SRC & DST images have correct usage flags set
Dave Houltond8ed0212018-05-16 17:18:24 -06002253 skip |= ValidateImageUsageFlags(device_data, src_image_state, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true,
2254 "VUID-vkCmdCopyImage-srcImage-00126", "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
2255 skip |= ValidateImageUsageFlags(device_data, dst_image_state, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true,
2256 "VUID-vkCmdCopyImage-dstImage-00131", "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
Cort Stratton186b1a22018-05-01 20:18:06 -04002257 if (GetApiVersion(device_data) >= VK_API_VERSION_1_1 || GetDeviceExtensions(device_data)->vk_khr_maintenance1) {
Dave Houltond8ed0212018-05-16 17:18:24 -06002258 skip |=
2259 ValidateImageFormatFeatureFlags(device_data, src_image_state, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, "vkCmdCopyImage()",
2260 "VUID-vkCmdCopyImage-srcImage-00125", "VUID-vkCmdCopyImage-srcImage-00125");
2261 skip |=
2262 ValidateImageFormatFeatureFlags(device_data, dst_image_state, VK_FORMAT_FEATURE_TRANSFER_DST_BIT, "vkCmdCopyImage()",
2263 "VUID-vkCmdCopyImage-dstImage-00130", "VUID-vkCmdCopyImage-dstImage-00130");
Cort Stratton186b1a22018-05-01 20:18:06 -04002264 }
Mike Schuchardt9c582402017-02-23 15:57:37 -07002265 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdCopyImage()",
Dave Houltond8ed0212018-05-16 17:18:24 -06002266 VK_QUEUE_TRANSFER_BIT | VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT,
2267 "VUID-vkCmdCopyImage-commandBuffer-cmdpool");
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002268 skip |= ValidateCmd(device_data, cb_node, CMD_COPYIMAGE, "vkCmdCopyImage()");
Dave Houltond8ed0212018-05-16 17:18:24 -06002269 skip |= insideRenderPass(device_data, cb_node, "vkCmdCopyImage()", "VUID-vkCmdCopyImage-renderpass");
Tobin Ehlisc8266452017-04-07 12:20:30 -06002270 bool hit_error = false;
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002271 for (uint32_t i = 0; i < region_count; ++i) {
Tobin Ehlis2d85ec62017-03-14 15:38:48 -06002272 skip |= VerifyImageLayout(device_data, cb_node, src_image_state, regions[i].srcSubresource, src_image_layout,
Dave Houltond8ed0212018-05-16 17:18:24 -06002273 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, "vkCmdCopyImage()",
2274 "VUID-vkCmdCopyImage-srcImageLayout-00129", &hit_error);
Tobin Ehlis2d85ec62017-03-14 15:38:48 -06002275 skip |= VerifyImageLayout(device_data, cb_node, dst_image_state, regions[i].dstSubresource, dst_image_layout,
Dave Houltond8ed0212018-05-16 17:18:24 -06002276 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, "vkCmdCopyImage()",
2277 "VUID-vkCmdCopyImage-dstImageLayout-00134", &hit_error);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002278 skip |= ValidateCopyImageTransferGranularityRequirements(device_data, cb_node, src_image_state, dst_image_state,
2279 &regions[i], i, "vkCmdCopyImage()");
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002280 }
2281
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002282 return skip;
2283}
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002284
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002285void PreCallRecordCmdCopyImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state,
Tobin Ehlise35b66a2017-03-15 12:18:31 -06002286 IMAGE_STATE *dst_image_state, uint32_t region_count, const VkImageCopy *regions,
2287 VkImageLayout src_image_layout, VkImageLayout dst_image_layout) {
2288 // Make sure that all image slices are updated to correct layout
2289 for (uint32_t i = 0; i < region_count; ++i) {
2290 SetImageLayout(device_data, cb_node, src_image_state, regions[i].srcSubresource, src_image_layout);
2291 SetImageLayout(device_data, cb_node, dst_image_state, regions[i].dstSubresource, dst_image_layout);
2292 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002293 // Update bindings between images and cmd buffer
2294 AddCommandBufferBindingImage(device_data, cb_node, src_image_state);
2295 AddCommandBufferBindingImage(device_data, cb_node, dst_image_state);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002296}
2297
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002298// Returns true if sub_rect is entirely contained within rect
2299static inline bool ContainsRect(VkRect2D rect, VkRect2D sub_rect) {
2300 if ((sub_rect.offset.x < rect.offset.x) || (sub_rect.offset.x + sub_rect.extent.width > rect.offset.x + rect.extent.width) ||
2301 (sub_rect.offset.y < rect.offset.y) || (sub_rect.offset.y + sub_rect.extent.height > rect.offset.y + rect.extent.height))
2302 return false;
2303 return true;
2304}
2305
Tobin Ehlis58c884f2017-02-08 12:15:27 -07002306bool PreCallValidateCmdClearAttachments(layer_data *device_data, VkCommandBuffer commandBuffer, uint32_t attachmentCount,
2307 const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects) {
Tobin Ehlisb2e1e2c2017-02-08 09:16:32 -07002308 GLOBAL_CB_NODE *cb_node = GetCBNode(device_data, commandBuffer);
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002309 const debug_report_data *report_data = core_validation::GetReportData(device_data);
2310
2311 bool skip = false;
2312 if (cb_node) {
Tobin Ehlis3c37fb32017-05-24 09:31:13 -06002313 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdClearAttachments()", VK_QUEUE_GRAPHICS_BIT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002314 "VUID-vkCmdClearAttachments-commandBuffer-cmdpool");
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002315 skip |= ValidateCmd(device_data, cb_node, CMD_CLEARATTACHMENTS, "vkCmdClearAttachments()");
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002316 // Warn if this is issued prior to Draw Cmd and clearing the entire attachment
Chris Forbes05375e72017-04-21 13:15:15 -07002317 if (!cb_node->hasDrawCmd && (cb_node->activeRenderPassBeginInfo.renderArea.extent.width == pRects[0].rect.extent.width) &&
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002318 (cb_node->activeRenderPassBeginInfo.renderArea.extent.height == pRects[0].rect.extent.height)) {
2319 // 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 -07002320 // This warning should be made more specific. It'd be best to avoid triggering this test if it's a use that must call
2321 // CmdClearAttachments.
Dave Houltona9df0ce2018-02-07 10:51:23 -07002322 skip |= log_msg(
2323 report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002324 HandleToUint64(commandBuffer), DRAWSTATE_CLEAR_CMD_BEFORE_DRAW,
Dave Houltona9df0ce2018-02-07 10:51:23 -07002325 "vkCmdClearAttachments() issued on command buffer object 0x%" PRIx64
2326 " prior to any Draw Cmds. It is recommended you use RenderPass LOAD_OP_CLEAR on Attachments prior to any Draw.",
2327 HandleToUint64(commandBuffer));
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002328 }
Dave Houltond8ed0212018-05-16 17:18:24 -06002329 skip |= outsideRenderPass(device_data, cb_node, "vkCmdClearAttachments()", "VUID-vkCmdClearAttachments-renderpass");
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002330 }
2331
2332 // Validate that attachment is in reference list of active subpass
2333 if (cb_node->activeRenderPass) {
2334 const VkRenderPassCreateInfo *renderpass_create_info = cb_node->activeRenderPass->createInfo.ptr();
2335 const VkSubpassDescription *subpass_desc = &renderpass_create_info->pSubpasses[cb_node->activeSubpass];
Tobin Ehlisb2e1e2c2017-02-08 09:16:32 -07002336 auto framebuffer = GetFramebufferState(device_data, cb_node->activeFramebuffer);
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002337
2338 for (uint32_t i = 0; i < attachmentCount; i++) {
2339 auto clear_desc = &pAttachments[i];
2340 VkImageView image_view = VK_NULL_HANDLE;
2341
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002342 if (0 == clear_desc->aspectMask) {
2343 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 -06002344 HandleToUint64(commandBuffer), "VUID-VkClearAttachment-aspectMask-requiredbitmask", " ");
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002345 } else if (clear_desc->aspectMask & VK_IMAGE_ASPECT_METADATA_BIT) {
2346 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 -06002347 HandleToUint64(commandBuffer), "VUID-VkClearAttachment-aspectMask-00020", " ");
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002348 } else if (clear_desc->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) {
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002349 if (clear_desc->colorAttachment >= subpass_desc->colorAttachmentCount) {
Tobin Ehlis3c37fb32017-05-24 09:31:13 -06002350 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 -06002351 HandleToUint64(commandBuffer), "VUID-vkCmdClearAttachments-aspectMask-00015",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002352 "vkCmdClearAttachments() color attachment index %d out of range for active subpass %d.",
2353 clear_desc->colorAttachment, cb_node->activeSubpass);
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002354 } else if (subpass_desc->pColorAttachments[clear_desc->colorAttachment].attachment == VK_ATTACHMENT_UNUSED) {
2355 skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06002356 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(commandBuffer),
Mark Lobodzinski88529492018-04-01 10:38:15 -06002357 DRAWSTATE_MISSING_ATTACHMENT_REFERENCE,
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002358 "vkCmdClearAttachments() color attachment index %d is VK_ATTACHMENT_UNUSED; ignored.",
2359 clear_desc->colorAttachment);
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002360 } else {
2361 image_view = framebuffer->createInfo
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002362 .pAttachments[subpass_desc->pColorAttachments[clear_desc->colorAttachment].attachment];
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002363 }
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002364 if ((clear_desc->aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) ||
2365 (clear_desc->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT)) {
2366 char const str[] =
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002367 "vkCmdClearAttachments() aspectMask [%d] must set only VK_IMAGE_ASPECT_COLOR_BIT of a color attachment.";
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002368 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 -06002369 HandleToUint64(commandBuffer), "VUID-VkClearAttachment-aspectMask-00019", str, i);
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002370 }
2371 } else { // Must be depth and/or stencil
2372 if (((clear_desc->aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) &&
2373 ((clear_desc->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT)) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002374 char const str[] = "vkCmdClearAttachments() aspectMask [%d] is not a valid combination of bits.";
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002375 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 -06002376 HandleToUint64(commandBuffer), "VUID-VkClearAttachment-aspectMask-parameter", str, i);
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002377 }
2378 if (!subpass_desc->pDepthStencilAttachment ||
2379 (subpass_desc->pDepthStencilAttachment->attachment == VK_ATTACHMENT_UNUSED)) {
2380 skip |= log_msg(
2381 report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002382 HandleToUint64(commandBuffer), DRAWSTATE_MISSING_ATTACHMENT_REFERENCE,
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002383 "vkCmdClearAttachments() depth/stencil clear with no depth/stencil attachment in subpass; ignored");
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002384 } else {
2385 image_view = framebuffer->createInfo.pAttachments[subpass_desc->pDepthStencilAttachment->attachment];
2386 }
2387 }
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002388 if (image_view) {
Tobin Ehlisb2e1e2c2017-02-08 09:16:32 -07002389 auto image_view_state = GetImageViewState(device_data, image_view);
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002390 for (uint32_t j = 0; j < rectCount; j++) {
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002391 // The rectangular region specified by a given element of pRects must be contained within the render area of
2392 // the current render pass instance
Tobin Ehlis37ec75a2018-03-12 11:26:39 -06002393 if (cb_node->createInfo.level == VK_COMMAND_BUFFER_LEVEL_PRIMARY) {
2394 if (false == ContainsRect(cb_node->activeRenderPassBeginInfo.renderArea, pRects[j].rect)) {
2395 skip |=
2396 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 -06002397 HandleToUint64(commandBuffer), "VUID-vkCmdClearAttachments-pRects-00016",
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07002398 "vkCmdClearAttachments(): The area defined by pRects[%d] is not contained in the area of "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002399 "the current render pass instance.",
2400 j);
Tobin Ehlis37ec75a2018-03-12 11:26:39 -06002401 }
2402 } else {
Tobin Ehlis3faf8b32018-04-17 16:14:26 -06002403 const auto local_rect =
2404 pRects[j].rect; // local copy of rect captured by value below to preserve original contents
Tobin Ehlis37ec75a2018-03-12 11:26:39 -06002405 cb_node->cmd_execute_commands_functions.emplace_back([=](GLOBAL_CB_NODE *prim_cb, VkFramebuffer fb) {
Tobin Ehlis3faf8b32018-04-17 16:14:26 -06002406 if (false == ContainsRect(prim_cb->activeRenderPassBeginInfo.renderArea, local_rect)) {
Tobin Ehlis37ec75a2018-03-12 11:26:39 -06002407 return log_msg(
2408 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002409 HandleToUint64(commandBuffer), "VUID-vkCmdClearAttachments-pRects-00016",
Tobin Ehlis37ec75a2018-03-12 11:26:39 -06002410 "vkCmdClearAttachments(): The area defined by pRects[%d] is not contained in the area of "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002411 "the current render pass instance.",
2412 j);
Tobin Ehlis37ec75a2018-03-12 11:26:39 -06002413 }
2414 return false;
2415 });
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002416 }
2417 // The layers specified by a given element of pRects must be contained within every attachment that
2418 // pAttachments refers to
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002419 auto attachment_layer_count = image_view_state->create_info.subresourceRange.layerCount;
Dave Houlton8e157032017-05-22 16:16:27 -06002420 if ((pRects[j].baseArrayLayer >= attachment_layer_count) ||
2421 (pRects[j].baseArrayLayer + pRects[j].layerCount > attachment_layer_count)) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07002422 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 -06002423 HandleToUint64(commandBuffer), "VUID-vkCmdClearAttachments-pRects-00017",
Dave Houltona9df0ce2018-02-07 10:51:23 -07002424 "vkCmdClearAttachments(): The layers defined in pRects[%d] are not contained in the layers "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002425 "of pAttachment[%d].",
2426 j, i);
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07002427 }
2428 }
2429 }
2430 }
2431 }
2432 return skip;
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002433}
2434
Tobin Ehlis58c884f2017-02-08 12:15:27 -07002435bool PreCallValidateCmdResolveImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state,
Mark Lobodzinski50fbef12017-02-06 15:31:33 -07002436 IMAGE_STATE *dst_image_state, uint32_t regionCount, const VkImageResolve *pRegions) {
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002437 const debug_report_data *report_data = core_validation::GetReportData(device_data);
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002438 bool skip = false;
2439 if (cb_node && src_image_state && dst_image_state) {
Dave Houltond8ed0212018-05-16 17:18:24 -06002440 skip |= ValidateMemoryIsBoundToImage(device_data, src_image_state, "vkCmdResolveImage()",
2441 "VUID-vkCmdResolveImage-srcImage-00256");
2442 skip |= ValidateMemoryIsBoundToImage(device_data, dst_image_state, "vkCmdResolveImage()",
2443 "VUID-vkCmdResolveImage-dstImage-00258");
2444 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdResolveImage()", VK_QUEUE_GRAPHICS_BIT,
2445 "VUID-vkCmdResolveImage-commandBuffer-cmdpool");
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002446 skip |= ValidateCmd(device_data, cb_node, CMD_RESOLVEIMAGE, "vkCmdResolveImage()");
Dave Houltond8ed0212018-05-16 17:18:24 -06002447 skip |= insideRenderPass(device_data, cb_node, "vkCmdResolveImage()", "VUID-vkCmdResolveImage-renderpass");
Cort Stratton186b1a22018-05-01 20:18:06 -04002448 skip |= ValidateImageFormatFeatureFlags(device_data, dst_image_state, VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002449 "vkCmdResolveImage()", "VUID-vkCmdResolveImage-dstImage-00264",
2450 "VUID-vkCmdResolveImage-dstImage-00265");
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002451
2452 // For each region, the number of layers in the image subresource should not be zero
2453 // For each region, src and dest image aspect must be color only
2454 for (uint32_t i = 0; i < regionCount; i++) {
2455 if (pRegions[i].srcSubresource.layerCount == 0) {
2456 char const str[] = "vkCmdResolveImage: number of layers in source subresource is zero";
Mark Lobodzinski50fbef12017-02-06 15:31:33 -07002457 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002458 HandleToUint64(cb_node->commandBuffer), DRAWSTATE_MISMATCHED_IMAGE_ASPECT, str);
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002459 }
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002460 if (pRegions[i].dstSubresource.layerCount == 0) {
2461 char const str[] = "vkCmdResolveImage: number of layers in destination subresource is zero";
Mark Lobodzinski50fbef12017-02-06 15:31:33 -07002462 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002463 HandleToUint64(cb_node->commandBuffer), DRAWSTATE_MISMATCHED_IMAGE_ASPECT, str);
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002464 }
Mark Lobodzinski50fbef12017-02-06 15:31:33 -07002465 if (pRegions[i].srcSubresource.layerCount != pRegions[i].dstSubresource.layerCount) {
2466 skip |= log_msg(
2467 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002468 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageResolve-layerCount-00267",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002469 "vkCmdResolveImage: layerCount in source and destination subresource of pRegions[%d] does not match.", i);
Mark Lobodzinski50fbef12017-02-06 15:31:33 -07002470 }
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002471 if ((pRegions[i].srcSubresource.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) ||
2472 (pRegions[i].dstSubresource.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT)) {
2473 char const str[] =
2474 "vkCmdResolveImage: src and dest aspectMasks for each region must specify only VK_IMAGE_ASPECT_COLOR_BIT";
2475 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 -06002476 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageResolve-aspectMask-00266", "%s.", str);
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002477 }
2478 }
2479
2480 if (src_image_state->createInfo.format != dst_image_state->createInfo.format) {
2481 char const str[] = "vkCmdResolveImage called with unmatched source and dest formats.";
Mark Lobodzinski50fbef12017-02-06 15:31:33 -07002482 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002483 HandleToUint64(cb_node->commandBuffer), DRAWSTATE_MISMATCHED_IMAGE_FORMAT, str);
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002484 }
2485 if (src_image_state->createInfo.imageType != dst_image_state->createInfo.imageType) {
2486 char const str[] = "vkCmdResolveImage called with unmatched source and dest image types.";
Mark Lobodzinski50fbef12017-02-06 15:31:33 -07002487 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002488 HandleToUint64(cb_node->commandBuffer), DRAWSTATE_MISMATCHED_IMAGE_TYPE, str);
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002489 }
2490 if (src_image_state->createInfo.samples == VK_SAMPLE_COUNT_1_BIT) {
2491 char const str[] = "vkCmdResolveImage called with source sample count less than 2.";
2492 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 -06002493 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdResolveImage-srcImage-00257", "%s.", str);
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002494 }
2495 if (dst_image_state->createInfo.samples != VK_SAMPLE_COUNT_1_BIT) {
2496 char const str[] = "vkCmdResolveImage called with dest sample count greater than 1.";
2497 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 -06002498 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdResolveImage-dstImage-00259", "%s.", str);
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07002499 }
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -06002500 // TODO: Need to validate image layouts, which will include layout validation for shared presentable images
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002501 } else {
2502 assert(0);
2503 }
2504 return skip;
2505}
2506
Tobin Ehlis58c884f2017-02-08 12:15:27 -07002507void PreCallRecordCmdResolveImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state,
2508 IMAGE_STATE *dst_image_state) {
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002509 // Update bindings between images and cmd buffer
2510 AddCommandBufferBindingImage(device_data, cb_node, src_image_state);
2511 AddCommandBufferBindingImage(device_data, cb_node, dst_image_state);
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002512}
2513
Tobin Ehlis58c884f2017-02-08 12:15:27 -07002514bool PreCallValidateCmdBlitImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state,
Norbert Garnys7bd4c2c2017-11-16 10:58:04 +01002515 IMAGE_STATE *dst_image_state, uint32_t region_count, const VkImageBlit *regions,
2516 VkImageLayout src_image_layout, VkImageLayout dst_image_layout, VkFilter filter) {
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07002517 const debug_report_data *report_data = core_validation::GetReportData(device_data);
2518
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002519 bool skip = false;
John Zulauf5c2750c2018-01-30 15:04:56 -07002520 if (cb_node) {
2521 skip |= ValidateCmd(device_data, cb_node, CMD_BLITIMAGE, "vkCmdBlitImage()");
2522 }
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002523 if (cb_node && src_image_state && dst_image_state) {
2524 skip |= ValidateImageSampleCount(device_data, src_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdBlitImage(): srcImage",
Dave Houltond8ed0212018-05-16 17:18:24 -06002525 "VUID-vkCmdBlitImage-srcImage-00233");
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002526 skip |= ValidateImageSampleCount(device_data, dst_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdBlitImage(): dstImage",
Dave Houltond8ed0212018-05-16 17:18:24 -06002527 "VUID-vkCmdBlitImage-dstImage-00234");
2528 skip |=
2529 ValidateMemoryIsBoundToImage(device_data, src_image_state, "vkCmdBlitImage()", "VUID-vkCmdBlitImage-srcImage-00220");
2530 skip |=
2531 ValidateMemoryIsBoundToImage(device_data, dst_image_state, "vkCmdBlitImage()", "VUID-vkCmdBlitImage-dstImage-00225");
2532 skip |=
2533 ValidateImageUsageFlags(device_data, src_image_state, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true,
2534 "VUID-vkCmdBlitImage-srcImage-00219", "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
2535 skip |=
2536 ValidateImageUsageFlags(device_data, dst_image_state, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true,
2537 "VUID-vkCmdBlitImage-dstImage-00224", "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
2538 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdBlitImage()", VK_QUEUE_GRAPHICS_BIT,
2539 "VUID-vkCmdBlitImage-commandBuffer-cmdpool");
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002540 skip |= ValidateCmd(device_data, cb_node, CMD_BLITIMAGE, "vkCmdBlitImage()");
Dave Houltond8ed0212018-05-16 17:18:24 -06002541 skip |= insideRenderPass(device_data, cb_node, "vkCmdBlitImage()", "VUID-vkCmdBlitImage-renderpass");
Cort Stratton186b1a22018-05-01 20:18:06 -04002542 skip |= ValidateImageFormatFeatureFlags(device_data, src_image_state, VK_FORMAT_FEATURE_BLIT_SRC_BIT, "vkCmdBlitImage()",
Dave Houltond8ed0212018-05-16 17:18:24 -06002543 "VUID-vkCmdBlitImage-srcImage-00218", "VUID-vkCmdBlitImage-srcImage-00218");
Cort Stratton186b1a22018-05-01 20:18:06 -04002544 skip |= ValidateImageFormatFeatureFlags(device_data, dst_image_state, VK_FORMAT_FEATURE_BLIT_DST_BIT, "vkCmdBlitImage()",
Dave Houltond8ed0212018-05-16 17:18:24 -06002545 "VUID-vkCmdBlitImage-dstImage-00223", "VUID-vkCmdBlitImage-dstImage-00223");
Cort Stratton186b1a22018-05-01 20:18:06 -04002546
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -06002547 // TODO: Need to validate image layouts, which will include layout validation for shared presentable images
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07002548
Dave Houlton33c2d252017-06-09 17:08:32 -06002549 VkFormat src_format = src_image_state->createInfo.format;
2550 VkFormat dst_format = dst_image_state->createInfo.format;
2551 VkImageType src_type = src_image_state->createInfo.imageType;
2552 VkImageType dst_type = dst_image_state->createInfo.imageType;
2553
Cort Stratton186b1a22018-05-01 20:18:06 -04002554 if (VK_FILTER_LINEAR == filter) {
2555 skip |= ValidateImageFormatFeatureFlags(device_data, src_image_state, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002556 "vkCmdBlitImage()", "VUID-vkCmdBlitImage-filter-00235",
2557 "VUID-vkCmdBlitImage-filter-00235");
Cort Stratton186b1a22018-05-01 20:18:06 -04002558 } else if (VK_FILTER_CUBIC_IMG == filter) {
Dave Houltond8ed0212018-05-16 17:18:24 -06002559 skip |= ValidateImageFormatFeatureFlags(device_data, src_image_state,
2560 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, "vkCmdBlitImage()",
2561 "VUID-vkCmdBlitImage-filter-00236", "VUID-vkCmdBlitImage-filter-00236");
Dave Houlton33c2d252017-06-09 17:08:32 -06002562 }
2563
2564 if ((VK_FILTER_CUBIC_IMG == filter) && (VK_IMAGE_TYPE_3D != src_type)) {
2565 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 -06002566 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-filter-00237",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002567 "vkCmdBlitImage: source image type must be VK_IMAGE_TYPE_3D when cubic filtering is specified.");
Dave Houlton33c2d252017-06-09 17:08:32 -06002568 }
2569
Dave Houlton33c2d252017-06-09 17:08:32 -06002570 if ((VK_SAMPLE_COUNT_1_BIT != src_image_state->createInfo.samples) ||
2571 (VK_SAMPLE_COUNT_1_BIT != dst_image_state->createInfo.samples)) {
2572 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(cb_node->commandBuffer), "VUID-vkCmdBlitImage-srcImage-00228",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002574 "vkCmdBlitImage: source or dest image has sample count other than VK_SAMPLE_COUNT_1_BIT.");
Dave Houlton33c2d252017-06-09 17:08:32 -06002575 }
2576
2577 // Validate consistency for unsigned formats
2578 if (FormatIsUInt(src_format) != FormatIsUInt(dst_format)) {
2579 std::stringstream ss;
2580 ss << "vkCmdBlitImage: If one of srcImage and dstImage images has unsigned integer format, "
2581 << "the other one must also have unsigned integer format. "
2582 << "Source format is " << string_VkFormat(src_format) << " Destination format is " << string_VkFormat(dst_format);
2583 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 -06002584 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-srcImage-00230", "%s.", ss.str().c_str());
Dave Houlton33c2d252017-06-09 17:08:32 -06002585 }
2586
2587 // Validate consistency for signed formats
2588 if (FormatIsSInt(src_format) != FormatIsSInt(dst_format)) {
2589 std::stringstream ss;
2590 ss << "vkCmdBlitImage: If one of srcImage and dstImage images has signed integer format, "
2591 << "the other one must also have signed integer format. "
2592 << "Source format is " << string_VkFormat(src_format) << " Destination format is " << string_VkFormat(dst_format);
2593 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 -06002594 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-srcImage-00229", "%s.", ss.str().c_str());
Dave Houlton33c2d252017-06-09 17:08:32 -06002595 }
2596
2597 // Validate filter for Depth/Stencil formats
2598 if (FormatIsDepthOrStencil(src_format) && (filter != VK_FILTER_NEAREST)) {
2599 std::stringstream ss;
2600 ss << "vkCmdBlitImage: If the format of srcImage is a depth, stencil, or depth stencil "
2601 << "then filter must be VK_FILTER_NEAREST.";
2602 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 -06002603 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-srcImage-00232", "%s.", ss.str().c_str());
Dave Houlton33c2d252017-06-09 17:08:32 -06002604 }
2605
2606 // Validate aspect bits and formats for depth/stencil images
2607 if (FormatIsDepthOrStencil(src_format) || FormatIsDepthOrStencil(dst_format)) {
2608 if (src_format != dst_format) {
2609 std::stringstream ss;
2610 ss << "vkCmdBlitImage: If one of srcImage and dstImage images has a format of depth, stencil or depth "
2611 << "stencil, the other one must have exactly the same format. "
2612 << "Source format is " << string_VkFormat(src_format) << " Destination format is "
2613 << string_VkFormat(dst_format);
Dave Houltond8ed0212018-05-16 17:18:24 -06002614 skip |=
2615 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2616 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-srcImage-00231", "%s.", ss.str().c_str());
Dave Houlton33c2d252017-06-09 17:08:32 -06002617 }
2618
2619#if 0 // TODO: Cannot find VU statements or spec language for these in CmdBlitImage. Verify or remove.
2620 for (uint32_t i = 0; i < regionCount; i++) {
2621 VkImageAspectFlags srcAspect = pRegions[i].srcSubresource.aspectMask;
2622
2623 if (FormatIsDepthAndStencil(src_format)) {
2624 if ((srcAspect != VK_IMAGE_ASPECT_DEPTH_BIT) && (srcAspect != VK_IMAGE_ASPECT_STENCIL_BIT)) {
2625 std::stringstream ss;
Dave Houltona9df0ce2018-02-07 10:51:23 -07002626 ss << "vkCmdBlitImage: Combination depth/stencil image formats must have only one of VK_IMAGE_ASPECT_DEPTH_BIT "
Dave Houlton33c2d252017-06-09 17:08:32 -06002627 << "and VK_IMAGE_ASPECT_STENCIL_BIT set in srcImage and dstImage";
2628 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002629 HandleToUint64(cb_node->commandBuffer), DRAWSTATE_INVALID_IMAGE_ASPECT,
Dave Houlton33c2d252017-06-09 17:08:32 -06002630 "%s", ss.str().c_str());
2631 }
2632 }
2633 else if (FormatIsStencilOnly(src_format)) {
2634 if (srcAspect != VK_IMAGE_ASPECT_STENCIL_BIT) {
2635 std::stringstream ss;
2636 ss << "vkCmdBlitImage: Stencil-only image formats must have only the VK_IMAGE_ASPECT_STENCIL_BIT "
2637 << "set in both the srcImage and dstImage";
2638 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002639 HandleToUint64(cb_node->commandBuffer), DRAWSTATE_INVALID_IMAGE_ASPECT,
Dave Houlton33c2d252017-06-09 17:08:32 -06002640 "%s", ss.str().c_str());
2641 }
2642 }
2643 else if (FormatIsDepthOnly(src_format)) {
2644 if (srcAspect != VK_IMAGE_ASPECT_DEPTH_BIT) {
2645 std::stringstream ss;
2646 ss << "vkCmdBlitImage: Depth-only image formats must have only the VK_IMAGE_ASPECT_DEPTH "
2647 << "set in both the srcImage and dstImage";
2648 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002649 HandleToUint64(cb_node->commandBuffer), DRAWSTATE_INVALID_IMAGE_ASPECT,
Dave Houlton33c2d252017-06-09 17:08:32 -06002650 "%s", ss.str().c_str());
2651 }
2652 }
2653 }
2654#endif
2655 } // Depth or Stencil
2656
2657 // Do per-region checks
Norbert Garnys7bd4c2c2017-11-16 10:58:04 +01002658 for (uint32_t i = 0; i < region_count; i++) {
2659 const VkImageBlit rgn = regions[i];
2660 bool hit_error = false;
Dave Houltond8ed0212018-05-16 17:18:24 -06002661 skip |= VerifyImageLayout(device_data, cb_node, src_image_state, rgn.srcSubresource, src_image_layout,
2662 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, "vkCmdBlitImage()",
2663 "VUID-vkCmdBlitImage-srcImageLayout-00222", &hit_error);
2664 skip |= VerifyImageLayout(device_data, cb_node, dst_image_state, rgn.dstSubresource, dst_image_layout,
2665 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, "vkCmdBlitImage()",
2666 "VUID-vkCmdBlitImage-dstImageLayout-00227", &hit_error);
Dave Houlton48989f32017-05-26 15:01:46 -06002667
Mark Lobodzinski23c81142017-02-06 15:04:23 -07002668 // Warn for zero-sized regions
Dave Houlton48989f32017-05-26 15:01:46 -06002669 if ((rgn.srcOffsets[0].x == rgn.srcOffsets[1].x) || (rgn.srcOffsets[0].y == rgn.srcOffsets[1].y) ||
2670 (rgn.srcOffsets[0].z == rgn.srcOffsets[1].z)) {
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07002671 std::stringstream ss;
2672 ss << "vkCmdBlitImage: pRegions[" << i << "].srcOffsets specify a zero-volume area.";
2673 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002674 HandleToUint64(cb_node->commandBuffer), DRAWSTATE_INVALID_EXTENTS, "%s", ss.str().c_str());
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07002675 }
Dave Houlton48989f32017-05-26 15:01:46 -06002676 if ((rgn.dstOffsets[0].x == rgn.dstOffsets[1].x) || (rgn.dstOffsets[0].y == rgn.dstOffsets[1].y) ||
2677 (rgn.dstOffsets[0].z == rgn.dstOffsets[1].z)) {
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07002678 std::stringstream ss;
2679 ss << "vkCmdBlitImage: pRegions[" << i << "].dstOffsets specify a zero-volume area.";
2680 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002681 HandleToUint64(cb_node->commandBuffer), DRAWSTATE_INVALID_EXTENTS, "%s", ss.str().c_str());
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07002682 }
Dave Houlton48989f32017-05-26 15:01:46 -06002683 if (rgn.srcSubresource.layerCount == 0) {
Mark Lobodzinski23c81142017-02-06 15:04:23 -07002684 char const str[] = "vkCmdBlitImage: number of layers in source subresource is zero";
2685 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002686 HandleToUint64(cb_node->commandBuffer), DRAWSTATE_MISMATCHED_IMAGE_ASPECT, str);
Mark Lobodzinski23c81142017-02-06 15:04:23 -07002687 }
Dave Houlton48989f32017-05-26 15:01:46 -06002688 if (rgn.dstSubresource.layerCount == 0) {
Mark Lobodzinski23c81142017-02-06 15:04:23 -07002689 char const str[] = "vkCmdBlitImage: number of layers in destination subresource is zero";
2690 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002691 HandleToUint64(cb_node->commandBuffer), DRAWSTATE_MISMATCHED_IMAGE_ASPECT, str);
Mark Lobodzinski23c81142017-02-06 15:04:23 -07002692 }
2693
2694 // Check that src/dst layercounts match
Dave Houlton48989f32017-05-26 15:01:46 -06002695 if (rgn.srcSubresource.layerCount != rgn.dstSubresource.layerCount) {
Mark Lobodzinski23c81142017-02-06 15:04:23 -07002696 skip |=
2697 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 -06002698 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-layerCount-00239",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002699 "vkCmdBlitImage: layerCount in source and destination subresource of pRegions[%d] does not match.", i);
Mark Lobodzinski23c81142017-02-06 15:04:23 -07002700 }
Mark Lobodzinskie7e85fd2017-02-07 13:44:57 -07002701
Dave Houlton48989f32017-05-26 15:01:46 -06002702 if (rgn.srcSubresource.aspectMask != rgn.dstSubresource.aspectMask) {
Mark Lobodzinskie7e85fd2017-02-07 13:44:57 -07002703 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 -06002704 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-aspectMask-00238",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002705 "vkCmdBlitImage: aspectMask members for pRegion[%d] do not match.", i);
Mark Lobodzinskie7e85fd2017-02-07 13:44:57 -07002706 }
Dave Houlton48989f32017-05-26 15:01:46 -06002707
Dave Houlton33c2d252017-06-09 17:08:32 -06002708 if (!VerifyAspectsPresent(rgn.srcSubresource.aspectMask, src_format)) {
2709 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 -06002710 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-aspectMask-00241",
Dave Houlton33c2d252017-06-09 17:08:32 -06002711 "vkCmdBlitImage: region [%d] source aspectMask (0x%x) specifies aspects not present in source "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002712 "image format %s.",
2713 i, rgn.srcSubresource.aspectMask, string_VkFormat(src_format));
Dave Houlton33c2d252017-06-09 17:08:32 -06002714 }
2715
2716 if (!VerifyAspectsPresent(rgn.dstSubresource.aspectMask, dst_format)) {
2717 skip |= log_msg(
2718 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002719 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-aspectMask-00242",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002720 "vkCmdBlitImage: region [%d] dest aspectMask (0x%x) specifies aspects not present in dest image format %s.", i,
2721 rgn.dstSubresource.aspectMask, string_VkFormat(dst_format));
Dave Houlton33c2d252017-06-09 17:08:32 -06002722 }
2723
Dave Houlton48989f32017-05-26 15:01:46 -06002724 // Validate source image offsets
2725 VkExtent3D src_extent = GetImageSubresourceExtent(src_image_state, &(rgn.srcSubresource));
Dave Houlton33c2d252017-06-09 17:08:32 -06002726 if (VK_IMAGE_TYPE_1D == src_type) {
Dave Houlton48989f32017-05-26 15:01:46 -06002727 if ((0 != rgn.srcOffsets[0].y) || (1 != rgn.srcOffsets[1].y)) {
2728 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 -06002729 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-srcImage-00245",
Dave Houlton48989f32017-05-26 15:01:46 -06002730 "vkCmdBlitImage: region [%d], source image of type VK_IMAGE_TYPE_1D with srcOffset[].y values "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002731 "of (%1d, %1d). These must be (0, 1).",
2732 i, rgn.srcOffsets[0].y, rgn.srcOffsets[1].y);
Dave Houlton48989f32017-05-26 15:01:46 -06002733 }
2734 }
2735
Dave Houlton33c2d252017-06-09 17:08:32 -06002736 if ((VK_IMAGE_TYPE_1D == src_type) || (VK_IMAGE_TYPE_2D == src_type)) {
Dave Houlton48989f32017-05-26 15:01:46 -06002737 if ((0 != rgn.srcOffsets[0].z) || (1 != rgn.srcOffsets[1].z)) {
2738 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 -06002739 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-srcImage-00247",
Dave Houlton48989f32017-05-26 15:01:46 -06002740 "vkCmdBlitImage: region [%d], source image of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D with "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002741 "srcOffset[].z values of (%1d, %1d). These must be (0, 1).",
2742 i, rgn.srcOffsets[0].z, rgn.srcOffsets[1].z);
Dave Houlton48989f32017-05-26 15:01:46 -06002743 }
2744 }
2745
Dave Houlton33c2d252017-06-09 17:08:32 -06002746 bool oob = false;
Dave Houlton48989f32017-05-26 15:01:46 -06002747 if ((rgn.srcOffsets[0].x < 0) || (rgn.srcOffsets[0].x > static_cast<int32_t>(src_extent.width)) ||
2748 (rgn.srcOffsets[1].x < 0) || (rgn.srcOffsets[1].x > static_cast<int32_t>(src_extent.width))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06002749 oob = true;
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002750 skip |=
2751 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 -06002752 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-srcOffset-00243",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002753 "vkCmdBlitImage: region [%d] srcOffset[].x values (%1d, %1d) exceed srcSubresource width extent (%1d).",
2754 i, rgn.srcOffsets[0].x, rgn.srcOffsets[1].x, src_extent.width);
Dave Houlton48989f32017-05-26 15:01:46 -06002755 }
2756 if ((rgn.srcOffsets[0].y < 0) || (rgn.srcOffsets[0].y > static_cast<int32_t>(src_extent.height)) ||
2757 (rgn.srcOffsets[1].y < 0) || (rgn.srcOffsets[1].y > static_cast<int32_t>(src_extent.height))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06002758 oob = true;
Dave Houlton48989f32017-05-26 15:01:46 -06002759 skip |= log_msg(
2760 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002761 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-srcOffset-00244",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002762 "vkCmdBlitImage: region [%d] srcOffset[].y values (%1d, %1d) exceed srcSubresource height extent (%1d).", i,
2763 rgn.srcOffsets[0].y, rgn.srcOffsets[1].y, src_extent.height);
Dave Houlton48989f32017-05-26 15:01:46 -06002764 }
2765 if ((rgn.srcOffsets[0].z < 0) || (rgn.srcOffsets[0].z > static_cast<int32_t>(src_extent.depth)) ||
2766 (rgn.srcOffsets[1].z < 0) || (rgn.srcOffsets[1].z > static_cast<int32_t>(src_extent.depth))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06002767 oob = true;
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002768 skip |=
2769 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 -06002770 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-srcOffset-00246",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002771 "vkCmdBlitImage: region [%d] srcOffset[].z values (%1d, %1d) exceed srcSubresource depth extent (%1d).",
2772 i, rgn.srcOffsets[0].z, rgn.srcOffsets[1].z, src_extent.depth);
Dave Houlton48989f32017-05-26 15:01:46 -06002773 }
Dave Houlton33c2d252017-06-09 17:08:32 -06002774 if (rgn.srcSubresource.mipLevel >= src_image_state->createInfo.mipLevels) {
2775 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 -06002776 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-pRegions-00215",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002777 "vkCmdBlitImage: region [%d] source image, attempt to access a non-existant mip level %1d.", i,
2778 rgn.srcSubresource.mipLevel);
Dave Houlton33c2d252017-06-09 17:08:32 -06002779 } else if (oob) {
2780 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 -06002781 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-pRegions-00215",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002782 "vkCmdBlitImage: region [%d] source image blit region exceeds image dimensions.", i);
Dave Houlton33c2d252017-06-09 17:08:32 -06002783 }
Dave Houlton48989f32017-05-26 15:01:46 -06002784
2785 // Validate dest image offsets
2786 VkExtent3D dst_extent = GetImageSubresourceExtent(dst_image_state, &(rgn.dstSubresource));
Dave Houlton33c2d252017-06-09 17:08:32 -06002787 if (VK_IMAGE_TYPE_1D == dst_type) {
Dave Houlton48989f32017-05-26 15:01:46 -06002788 if ((0 != rgn.dstOffsets[0].y) || (1 != rgn.dstOffsets[1].y)) {
2789 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 -06002790 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-dstImage-00250",
Dave Houlton48989f32017-05-26 15:01:46 -06002791 "vkCmdBlitImage: region [%d], dest image of type VK_IMAGE_TYPE_1D with dstOffset[].y values of "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002792 "(%1d, %1d). These must be (0, 1).",
2793 i, rgn.dstOffsets[0].y, rgn.dstOffsets[1].y);
Dave Houlton48989f32017-05-26 15:01:46 -06002794 }
2795 }
2796
Dave Houlton33c2d252017-06-09 17:08:32 -06002797 if ((VK_IMAGE_TYPE_1D == dst_type) || (VK_IMAGE_TYPE_2D == dst_type)) {
Dave Houlton48989f32017-05-26 15:01:46 -06002798 if ((0 != rgn.dstOffsets[0].z) || (1 != rgn.dstOffsets[1].z)) {
2799 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 -06002800 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-dstImage-00252",
Dave Houlton48989f32017-05-26 15:01:46 -06002801 "vkCmdBlitImage: region [%d], dest image of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D with "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002802 "dstOffset[].z values of (%1d, %1d). These must be (0, 1).",
2803 i, rgn.dstOffsets[0].z, rgn.dstOffsets[1].z);
Dave Houlton48989f32017-05-26 15:01:46 -06002804 }
2805 }
2806
Dave Houlton33c2d252017-06-09 17:08:32 -06002807 oob = false;
Dave Houlton48989f32017-05-26 15:01:46 -06002808 if ((rgn.dstOffsets[0].x < 0) || (rgn.dstOffsets[0].x > static_cast<int32_t>(dst_extent.width)) ||
2809 (rgn.dstOffsets[1].x < 0) || (rgn.dstOffsets[1].x > static_cast<int32_t>(dst_extent.width))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06002810 oob = true;
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002811 skip |=
2812 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 -06002813 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-dstOffset-00248",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002814 "vkCmdBlitImage: region [%d] dstOffset[].x values (%1d, %1d) exceed dstSubresource width extent (%1d).",
2815 i, rgn.dstOffsets[0].x, rgn.dstOffsets[1].x, dst_extent.width);
Dave Houlton48989f32017-05-26 15:01:46 -06002816 }
2817 if ((rgn.dstOffsets[0].y < 0) || (rgn.dstOffsets[0].y > static_cast<int32_t>(dst_extent.height)) ||
2818 (rgn.dstOffsets[1].y < 0) || (rgn.dstOffsets[1].y > static_cast<int32_t>(dst_extent.height))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06002819 oob = true;
Dave Houlton48989f32017-05-26 15:01:46 -06002820 skip |= log_msg(
2821 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06002822 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-dstOffset-00249",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002823 "vkCmdBlitImage: region [%d] dstOffset[].y values (%1d, %1d) exceed dstSubresource height extent (%1d).", i,
2824 rgn.dstOffsets[0].y, rgn.dstOffsets[1].y, dst_extent.height);
Dave Houlton48989f32017-05-26 15:01:46 -06002825 }
2826 if ((rgn.dstOffsets[0].z < 0) || (rgn.dstOffsets[0].z > static_cast<int32_t>(dst_extent.depth)) ||
2827 (rgn.dstOffsets[1].z < 0) || (rgn.dstOffsets[1].z > static_cast<int32_t>(dst_extent.depth))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06002828 oob = true;
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002829 skip |=
2830 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 -06002831 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-dstOffset-00251",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002832 "vkCmdBlitImage: region [%d] dstOffset[].z values (%1d, %1d) exceed dstSubresource depth extent (%1d).",
2833 i, rgn.dstOffsets[0].z, rgn.dstOffsets[1].z, dst_extent.depth);
Dave Houlton48989f32017-05-26 15:01:46 -06002834 }
Dave Houlton33c2d252017-06-09 17:08:32 -06002835 if (rgn.dstSubresource.mipLevel >= dst_image_state->createInfo.mipLevels) {
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07002836 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 -06002837 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-pRegions-00216",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002838 "vkCmdBlitImage: region [%d] destination image, attempt to access a non-existant mip level %1d.", i,
2839 rgn.dstSubresource.mipLevel);
Dave Houlton33c2d252017-06-09 17:08:32 -06002840 } else if (oob) {
2841 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 -06002842 HandleToUint64(cb_node->commandBuffer), "VUID-vkCmdBlitImage-pRegions-00216",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002843 "vkCmdBlitImage: region [%d] destination image blit region exceeds image dimensions.", i);
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07002844 }
2845
Dave Houlton33c2d252017-06-09 17:08:32 -06002846 if ((VK_IMAGE_TYPE_3D == src_type) || (VK_IMAGE_TYPE_3D == dst_type)) {
2847 if ((0 != rgn.srcSubresource.baseArrayLayer) || (1 != rgn.srcSubresource.layerCount) ||
2848 (0 != rgn.dstSubresource.baseArrayLayer) || (1 != rgn.dstSubresource.layerCount)) {
2849 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 -06002850 HandleToUint64(cb_node->commandBuffer), "VUID-VkImageBlit-srcImage-00240",
Dave Houlton33c2d252017-06-09 17:08:32 -06002851 "vkCmdBlitImage: region [%d] blit to/from a 3D image type with a non-zero baseArrayLayer, or a "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002852 "layerCount other than 1.",
2853 i);
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07002854 }
2855 }
Dave Houlton33c2d252017-06-09 17:08:32 -06002856 } // per-region checks
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002857 } else {
2858 assert(0);
2859 }
2860 return skip;
2861}
2862
Tobin Ehlis58c884f2017-02-08 12:15:27 -07002863void PreCallRecordCmdBlitImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state,
Norbert Garnys7bd4c2c2017-11-16 10:58:04 +01002864 IMAGE_STATE *dst_image_state, uint32_t region_count, const VkImageBlit *regions,
2865 VkImageLayout src_image_layout, VkImageLayout dst_image_layout) {
2866 // Make sure that all image slices are updated to correct layout
2867 for (uint32_t i = 0; i < region_count; ++i) {
2868 SetImageLayout(device_data, cb_node, src_image_state, regions[i].srcSubresource, src_image_layout);
2869 SetImageLayout(device_data, cb_node, dst_image_state, regions[i].dstSubresource, dst_image_layout);
2870 }
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002871 // Update bindings between images and cmd buffer
2872 AddCommandBufferBindingImage(device_data, cb_node, src_image_state);
2873 AddCommandBufferBindingImage(device_data, cb_node, dst_image_state);
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07002874}
2875
Tony Barbourdf013b92017-01-25 12:53:48 -07002876// This validates that the initial layout specified in the command buffer for
2877// the IMAGE is the same
2878// as the global IMAGE layout
Tony Barboure0c5cc92017-02-08 13:53:39 -07002879bool ValidateCmdBufImageLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB,
Dave Houltona9df0ce2018-02-07 10:51:23 -07002880 std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_NODE> const &globalImageLayoutMap,
2881 std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_NODE> &overlayLayoutMap) {
Mark Lobodzinskib0dd9472017-02-07 16:38:17 -07002882 bool skip = false;
Tony Barbourdf013b92017-01-25 12:53:48 -07002883 const debug_report_data *report_data = core_validation::GetReportData(device_data);
Mark Lobodzinski4a3065e2017-02-07 16:36:03 -07002884 for (auto cb_image_data : pCB->imageLayoutMap) {
2885 VkImageLayout imageLayout;
Tony Barbourdf013b92017-01-25 12:53:48 -07002886
Dave Houltonb3f4b282018-02-22 16:25:16 -07002887 if (FindLayout(device_data, overlayLayoutMap, cb_image_data.first, imageLayout) ||
2888 FindLayout(device_data, globalImageLayoutMap, cb_image_data.first, imageLayout)) {
Mark Lobodzinski4a3065e2017-02-07 16:36:03 -07002889 if (cb_image_data.second.initialLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
2890 // TODO: Set memory invalid which is in mem_tracker currently
2891 } else if (imageLayout != cb_image_data.second.initialLayout) {
2892 if (cb_image_data.first.hasSubresource) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07002893 skip |= log_msg(
2894 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002895 HandleToUint64(pCB->commandBuffer), DRAWSTATE_INVALID_IMAGE_LAYOUT,
Dave Houltona9df0ce2018-02-07 10:51:23 -07002896 "Cannot submit cmd buffer using image (0x%" PRIx64
2897 ") [sub-resource: aspectMask 0x%X array layer %u, mip level %u], with layout %s when first use is %s.",
2898 HandleToUint64(cb_image_data.first.image), cb_image_data.first.subresource.aspectMask,
2899 cb_image_data.first.subresource.arrayLayer, cb_image_data.first.subresource.mipLevel,
2900 string_VkImageLayout(imageLayout), string_VkImageLayout(cb_image_data.second.initialLayout));
Mark Lobodzinski4a3065e2017-02-07 16:36:03 -07002901 } else {
Petr Krausbc7f5442017-05-14 23:43:38 +02002902 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002903 HandleToUint64(pCB->commandBuffer), DRAWSTATE_INVALID_IMAGE_LAYOUT,
Dave Houltona9df0ce2018-02-07 10:51:23 -07002904 "Cannot submit cmd buffer using image (0x%" PRIx64 ") with layout %s when first use is %s.",
Petr Krausbc7f5442017-05-14 23:43:38 +02002905 HandleToUint64(cb_image_data.first.image), string_VkImageLayout(imageLayout),
2906 string_VkImageLayout(cb_image_data.second.initialLayout));
Mark Lobodzinski4a3065e2017-02-07 16:36:03 -07002907 }
2908 }
Chris Forbesf9d7acd2017-06-26 17:57:39 -07002909 SetLayout(overlayLayoutMap, cb_image_data.first, cb_image_data.second.layout);
Mark Lobodzinski4a3065e2017-02-07 16:36:03 -07002910 }
2911 }
Mark Lobodzinskib0dd9472017-02-07 16:38:17 -07002912 return skip;
Mark Lobodzinski4a3065e2017-02-07 16:36:03 -07002913}
Mark Lobodzinskib3829a52017-02-07 16:55:53 -07002914
Tony Barbourdf013b92017-01-25 12:53:48 -07002915void UpdateCmdBufImageLayouts(layer_data *device_data, GLOBAL_CB_NODE *pCB) {
2916 for (auto cb_image_data : pCB->imageLayoutMap) {
2917 VkImageLayout imageLayout;
2918 FindGlobalLayout(device_data, cb_image_data.first, imageLayout);
2919 SetGlobalLayout(device_data, cb_image_data.first, cb_image_data.second.layout);
2920 }
2921}
2922
Mark Lobodzinskib3829a52017-02-07 16:55:53 -07002923// Print readable FlagBits in FlagMask
2924static std::string string_VkAccessFlags(VkAccessFlags accessMask) {
2925 std::string result;
2926 std::string separator;
2927
2928 if (accessMask == 0) {
2929 result = "[None]";
2930 } else {
2931 result = "[";
2932 for (auto i = 0; i < 32; i++) {
2933 if (accessMask & (1 << i)) {
2934 result = result + separator + string_VkAccessFlagBits((VkAccessFlagBits)(1 << i));
2935 separator = " | ";
2936 }
2937 }
2938 result = result + "]";
2939 }
2940 return result;
2941}
2942
Mark Lobodzinski9a8d40f2017-02-07 17:00:12 -07002943// AccessFlags MUST have 'required_bit' set, and may have one or more of 'optional_bits' set. If required_bit is zero, accessMask
2944// must have at least one of 'optional_bits' set
Mark Lobodzinskib3829a52017-02-07 16:55:53 -07002945// TODO: Add tracking to ensure that at least one barrier has been set for these layout transitions
Mark Lobodzinski9a8d40f2017-02-07 17:00:12 -07002946static bool ValidateMaskBits(core_validation::layer_data *device_data, VkCommandBuffer cmdBuffer, const VkAccessFlags &accessMask,
2947 const VkImageLayout &layout, VkAccessFlags required_bit, VkAccessFlags optional_bits,
2948 const char *type) {
2949 const debug_report_data *report_data = core_validation::GetReportData(device_data);
2950 bool skip = false;
Mark Lobodzinskib3829a52017-02-07 16:55:53 -07002951
2952 if ((accessMask & required_bit) || (!required_bit && (accessMask & optional_bits))) {
2953 if (accessMask & ~(required_bit | optional_bits)) {
2954 // TODO: Verify against Valid Use
Mark Lobodzinski0827aec2017-03-21 16:41:45 -06002955 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002956 HandleToUint64(cmdBuffer), DRAWSTATE_INVALID_BARRIER,
Mark Lobodzinski9a8d40f2017-02-07 17:00:12 -07002957 "Additional bits in %s accessMask 0x%X %s are specified when layout is %s.", type, accessMask,
2958 string_VkAccessFlags(accessMask).c_str(), string_VkImageLayout(layout));
Mark Lobodzinskib3829a52017-02-07 16:55:53 -07002959 }
2960 } else {
2961 if (!required_bit) {
Mark Lobodzinski0827aec2017-03-21 16:41:45 -06002962 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002963 HandleToUint64(cmdBuffer), DRAWSTATE_INVALID_BARRIER,
Dave Houltona9df0ce2018-02-07 10:51:23 -07002964 "%s AccessMask %d %s must contain at least one of access bits %d %s when layout is %s, unless the app "
2965 "has previously added a barrier for this transition.",
Mark Lobodzinski9a8d40f2017-02-07 17:00:12 -07002966 type, accessMask, string_VkAccessFlags(accessMask).c_str(), optional_bits,
2967 string_VkAccessFlags(optional_bits).c_str(), string_VkImageLayout(layout));
Mark Lobodzinskib3829a52017-02-07 16:55:53 -07002968 } else {
2969 std::string opt_bits;
2970 if (optional_bits != 0) {
2971 std::stringstream ss;
2972 ss << optional_bits;
2973 opt_bits = "and may have optional bits " + ss.str() + ' ' + string_VkAccessFlags(optional_bits);
2974 }
Mark Lobodzinski0827aec2017-03-21 16:41:45 -06002975 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06002976 HandleToUint64(cmdBuffer), DRAWSTATE_INVALID_BARRIER,
Dave Houltona9df0ce2018-02-07 10:51:23 -07002977 "%s AccessMask %d %s must have required access bit %d %s %s when layout is %s, unless the app has "
2978 "previously added a barrier for this transition.",
Mark Lobodzinski9a8d40f2017-02-07 17:00:12 -07002979 type, accessMask, string_VkAccessFlags(accessMask).c_str(), required_bit,
2980 string_VkAccessFlags(required_bit).c_str(), opt_bits.c_str(), string_VkImageLayout(layout));
Mark Lobodzinskib3829a52017-02-07 16:55:53 -07002981 }
2982 }
Mark Lobodzinski9a8d40f2017-02-07 17:00:12 -07002983 return skip;
Mark Lobodzinskib3829a52017-02-07 16:55:53 -07002984}
2985
Mark Lobodzinskic679b032017-02-07 17:11:55 -07002986// ValidateLayoutVsAttachmentDescription is a general function where we can validate various state associated with the
Mark Lobodzinski552e4402017-02-07 17:14:53 -07002987// VkAttachmentDescription structs that are used by the sub-passes of a renderpass. Initial check is to make sure that READ_ONLY
2988// layout attachments don't have CLEAR as their loadOp.
Mark Lobodzinskic679b032017-02-07 17:11:55 -07002989bool ValidateLayoutVsAttachmentDescription(const debug_report_data *report_data, const VkImageLayout first_layout,
Mark Lobodzinski552e4402017-02-07 17:14:53 -07002990 const uint32_t attachment, const VkAttachmentDescription &attachment_description) {
2991 bool skip = false;
Mark Lobodzinskic679b032017-02-07 17:11:55 -07002992 // Verify that initial loadOp on READ_ONLY attachments is not CLEAR
2993 if (attachment_description.loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) {
2994 if ((first_layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL) ||
2995 (first_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)) {
Dave Houltond8ed0212018-05-16 17:18:24 -06002996 skip |=
2997 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
2998 "VUID-VkRenderPassCreateInfo-pAttachments-00836",
2999 "Cannot clear attachment %d with invalid first layout %s.", attachment, string_VkImageLayout(first_layout));
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003000 }
3001 }
Slawomir Cyganadf2b552018-04-24 17:18:26 +02003002 if (attachment_description.loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) {
3003 if (first_layout == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL) {
Dave Houltond8ed0212018-05-16 17:18:24 -06003004 skip |=
3005 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3006 "VUID-VkRenderPassCreateInfo-pAttachments-01566",
3007 "Cannot clear attachment %d with invalid first layout %s.", attachment, string_VkImageLayout(first_layout));
Slawomir Cyganadf2b552018-04-24 17:18:26 +02003008 }
3009 }
3010
3011 if (attachment_description.stencilLoadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) {
3012 if (first_layout == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL) {
Dave Houltond8ed0212018-05-16 17:18:24 -06003013 skip |=
3014 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3015 "VUID-VkRenderPassCreateInfo-pAttachments-01567",
3016 "Cannot clear attachment %d with invalid first layout %s.", attachment, string_VkImageLayout(first_layout));
Slawomir Cyganadf2b552018-04-24 17:18:26 +02003017 }
3018 }
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003019 return skip;
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003020}
3021
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003022bool ValidateLayouts(core_validation::layer_data *device_data, VkDevice device, const VkRenderPassCreateInfo *pCreateInfo) {
3023 const debug_report_data *report_data = core_validation::GetReportData(device_data);
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003024 bool skip = false;
3025
Jason Ekstranda1906302017-12-03 20:16:32 -08003026 for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
3027 VkFormat format = pCreateInfo->pAttachments[i].format;
3028 if (pCreateInfo->pAttachments[i].initialLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
3029 if ((FormatIsColor(format) || FormatHasDepth(format)) &&
3030 pCreateInfo->pAttachments[i].loadOp == VK_ATTACHMENT_LOAD_OP_LOAD) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003031 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Mark Lobodzinski88529492018-04-01 10:38:15 -06003032 DRAWSTATE_INVALID_RENDERPASS,
Dave Houltona9df0ce2018-02-07 10:51:23 -07003033 "Render pass has an attachment with loadOp == VK_ATTACHMENT_LOAD_OP_LOAD and initialLayout == "
3034 "VK_IMAGE_LAYOUT_UNDEFINED. This is probably not what you intended. Consider using "
3035 "VK_ATTACHMENT_LOAD_OP_DONT_CARE instead if the image truely is undefined at the start of the "
3036 "render pass.");
Jason Ekstranda1906302017-12-03 20:16:32 -08003037 }
Dave Houltona9df0ce2018-02-07 10:51:23 -07003038 if (FormatHasStencil(format) && pCreateInfo->pAttachments[i].stencilLoadOp == VK_ATTACHMENT_LOAD_OP_LOAD) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003039 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Mark Lobodzinski88529492018-04-01 10:38:15 -06003040 DRAWSTATE_INVALID_RENDERPASS,
Dave Houltona9df0ce2018-02-07 10:51:23 -07003041 "Render pass has an attachment with stencilLoadOp == VK_ATTACHMENT_LOAD_OP_LOAD and initialLayout "
3042 "== VK_IMAGE_LAYOUT_UNDEFINED. This is probably not what you intended. Consider using "
3043 "VK_ATTACHMENT_LOAD_OP_DONT_CARE instead if the image truely is undefined at the start of the "
3044 "render pass.");
Jason Ekstranda1906302017-12-03 20:16:32 -08003045 }
3046 }
3047 }
3048
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003049 // Track when we're observing the first use of an attachment
3050 std::vector<bool> attach_first_use(pCreateInfo->attachmentCount, true);
3051 for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) {
3052 const VkSubpassDescription &subpass = pCreateInfo->pSubpasses[i];
Cort Stratton7547f772017-05-04 15:18:52 -07003053
3054 // Check input attachments first, so we can detect first-use-as-input for VU #00349
3055 for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) {
3056 auto attach_index = subpass.pInputAttachments[j].attachment;
3057 if (attach_index == VK_ATTACHMENT_UNUSED) continue;
3058
3059 switch (subpass.pInputAttachments[j].layout) {
3060 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
3061 case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
3062 // These are ideal.
3063 break;
3064
3065 case VK_IMAGE_LAYOUT_GENERAL:
3066 // May not be optimal. TODO: reconsider this warning based on other constraints.
3067 skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06003068 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT,
Cort Stratton7547f772017-05-04 15:18:52 -07003069 "Layout for input attachment is GENERAL but should be READ_ONLY_OPTIMAL.");
3070 break;
3071
3072 default:
3073 // No other layouts are acceptable
3074 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Mark Lobodzinski88529492018-04-01 10:38:15 -06003075 DRAWSTATE_INVALID_IMAGE_LAYOUT,
Cort Stratton7547f772017-05-04 15:18:52 -07003076 "Layout for input attachment is %s but can only be READ_ONLY_OPTIMAL or GENERAL.",
3077 string_VkImageLayout(subpass.pInputAttachments[j].layout));
3078 }
3079
Cort Stratton7547f772017-05-04 15:18:52 -07003080 if (attach_first_use[attach_index]) {
3081 skip |= ValidateLayoutVsAttachmentDescription(report_data, subpass.pInputAttachments[j].layout, attach_index,
3082 pCreateInfo->pAttachments[attach_index]);
3083
3084 bool used_as_depth =
3085 (subpass.pDepthStencilAttachment != NULL && subpass.pDepthStencilAttachment->attachment == attach_index);
3086 bool used_as_color = false;
3087 for (uint32_t k = 0; !used_as_depth && !used_as_color && k < subpass.colorAttachmentCount; ++k) {
3088 used_as_color = (subpass.pColorAttachments[k].attachment == attach_index);
3089 }
3090 if (!used_as_depth && !used_as_color &&
3091 pCreateInfo->pAttachments[attach_index].loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) {
3092 skip |= log_msg(
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003093 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houltond8ed0212018-05-16 17:18:24 -06003094 "VUID-VkSubpassDescription-loadOp-00846",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003095 "CreateRenderPass: attachment %u is first used as an input attachment in subpass %u with loadOp=CLEAR.",
3096 attach_index, attach_index);
Cort Stratton7547f772017-05-04 15:18:52 -07003097 }
3098 }
3099 attach_first_use[attach_index] = false;
3100 }
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003101 for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) {
3102 auto attach_index = subpass.pColorAttachments[j].attachment;
3103 if (attach_index == VK_ATTACHMENT_UNUSED) continue;
3104
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -06003105 // TODO: Need a way to validate shared presentable images here, currently just allowing
3106 // VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
3107 // as an acceptable layout, but need to make sure shared presentable images ONLY use that layout
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003108 switch (subpass.pColorAttachments[j].layout) {
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003109 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
Dave Houlton33c2d252017-06-09 17:08:32 -06003110 // This is ideal.
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -06003111 case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR:
3112 // TODO: See note above, just assuming that attachment is shared presentable and allowing this for now.
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003113 break;
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003114
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003115 case VK_IMAGE_LAYOUT_GENERAL:
3116 // May not be optimal; TODO: reconsider this warning based on other constraints?
3117 skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06003118 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT,
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003119 "Layout for color attachment is GENERAL but should be COLOR_ATTACHMENT_OPTIMAL.");
3120 break;
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003121
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003122 default:
3123 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Mark Lobodzinski88529492018-04-01 10:38:15 -06003124 DRAWSTATE_INVALID_IMAGE_LAYOUT,
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003125 "Layout for color attachment is %s but can only be COLOR_ATTACHMENT_OPTIMAL or GENERAL.",
3126 string_VkImageLayout(subpass.pColorAttachments[j].layout));
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003127 }
3128
3129 if (attach_first_use[attach_index]) {
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003130 skip |= ValidateLayoutVsAttachmentDescription(report_data, subpass.pColorAttachments[j].layout, attach_index,
3131 pCreateInfo->pAttachments[attach_index]);
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003132 }
3133 attach_first_use[attach_index] = false;
3134 }
Lenny Komowb79f04a2017-09-18 17:07:00 -06003135
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003136 if (subpass.pDepthStencilAttachment && subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) {
3137 switch (subpass.pDepthStencilAttachment->layout) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07003138 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
3139 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
3140 // These are ideal.
Lenny Komowb79f04a2017-09-18 17:07:00 -06003141 break;
Lenny Komowb79f04a2017-09-18 17:07:00 -06003142
Dave Houltona9df0ce2018-02-07 10:51:23 -07003143 case VK_IMAGE_LAYOUT_GENERAL:
3144 // May not be optimal; TODO: reconsider this warning based on other constraints? GENERAL can be better than
3145 // doing a bunch of transitions.
3146 skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06003147 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT,
Dave Houltona9df0ce2018-02-07 10:51:23 -07003148 "GENERAL layout for depth attachment may not give optimal performance.");
3149 break;
3150
3151 case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR:
3152 case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR:
3153 if (GetDeviceExtensions(device_data)->vk_khr_maintenance2) {
3154 break;
3155 } else {
3156 // Intentionally fall through to generic error message
3157 }
Tobin Ehlis648b1cf2018-04-13 15:24:13 -06003158 // fall through
Dave Houltona9df0ce2018-02-07 10:51:23 -07003159 default:
3160 // No other layouts are acceptable
3161 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Mark Lobodzinski88529492018-04-01 10:38:15 -06003162 DRAWSTATE_INVALID_IMAGE_LAYOUT,
Dave Houltona9df0ce2018-02-07 10:51:23 -07003163 "Layout for depth attachment is %s but can only be DEPTH_STENCIL_ATTACHMENT_OPTIMAL, "
3164 "DEPTH_STENCIL_READ_ONLY_OPTIMAL or GENERAL.",
3165 string_VkImageLayout(subpass.pDepthStencilAttachment->layout));
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003166 }
3167
3168 auto attach_index = subpass.pDepthStencilAttachment->attachment;
3169 if (attach_first_use[attach_index]) {
Mark Lobodzinski552e4402017-02-07 17:14:53 -07003170 skip |= ValidateLayoutVsAttachmentDescription(report_data, subpass.pDepthStencilAttachment->layout, attach_index,
3171 pCreateInfo->pAttachments[attach_index]);
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003172 }
3173 attach_first_use[attach_index] = false;
3174 }
Mark Lobodzinskic679b032017-02-07 17:11:55 -07003175 }
3176 return skip;
3177}
Mark Lobodzinski08f14fa2017-02-07 17:20:06 -07003178
3179// For any image objects that overlap mapped memory, verify that their layouts are PREINIT or GENERAL
Mark Lobodzinskiac23ec82017-02-07 17:21:55 -07003180bool ValidateMapImageLayouts(core_validation::layer_data *device_data, VkDevice device, DEVICE_MEM_INFO const *mem_info,
3181 VkDeviceSize offset, VkDeviceSize end_offset) {
3182 const debug_report_data *report_data = core_validation::GetReportData(device_data);
3183 bool skip = false;
3184 // Iterate over all bound image ranges and verify that for any that overlap the map ranges, the layouts are
3185 // VK_IMAGE_LAYOUT_PREINITIALIZED or VK_IMAGE_LAYOUT_GENERAL
Mark Lobodzinski08f14fa2017-02-07 17:20:06 -07003186 // TODO : This can be optimized if we store ranges based on starting address and early exit when we pass our range
3187 for (auto image_handle : mem_info->bound_images) {
3188 auto img_it = mem_info->bound_ranges.find(image_handle);
3189 if (img_it != mem_info->bound_ranges.end()) {
Mark Lobodzinskiac23ec82017-02-07 17:21:55 -07003190 if (rangesIntersect(device_data, &img_it->second, offset, end_offset)) {
Mark Lobodzinski08f14fa2017-02-07 17:20:06 -07003191 std::vector<VkImageLayout> layouts;
Mark Lobodzinskiac23ec82017-02-07 17:21:55 -07003192 if (FindLayouts(device_data, VkImage(image_handle), layouts)) {
Mark Lobodzinski08f14fa2017-02-07 17:20:06 -07003193 for (auto layout : layouts) {
3194 if (layout != VK_IMAGE_LAYOUT_PREINITIALIZED && layout != VK_IMAGE_LAYOUT_GENERAL) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003195 skip |=
3196 log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
Mark Lobodzinski88529492018-04-01 10:38:15 -06003197 HandleToUint64(mem_info->mem), DRAWSTATE_INVALID_IMAGE_LAYOUT,
Dave Houltona9df0ce2018-02-07 10:51:23 -07003198 "Mapping an image with layout %s can result in undefined behavior if this memory is used "
3199 "by the device. Only GENERAL or PREINITIALIZED should be used.",
Petr Krausbc7f5442017-05-14 23:43:38 +02003200 string_VkImageLayout(layout));
Mark Lobodzinski08f14fa2017-02-07 17:20:06 -07003201 }
3202 }
3203 }
3204 }
3205 }
3206 }
Mark Lobodzinskiac23ec82017-02-07 17:21:55 -07003207 return skip;
Mark Lobodzinski08f14fa2017-02-07 17:20:06 -07003208}
Mark Lobodzinski96210742017-02-09 10:33:46 -07003209
3210// Helper function to validate correct usage bits set for buffers or images. Verify that (actual & desired) flags != 0 or, if strict
3211// is true, verify that (actual & desired) flags == desired
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07003212static bool validate_usage_flags(layer_data *device_data, VkFlags actual, VkFlags desired, VkBool32 strict, uint64_t obj_handle,
Dave Houltond8ed0212018-05-16 17:18:24 -06003213 VulkanObjectType obj_type, std::string msgCode, char const *func_name, char const *usage_str) {
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07003214 const debug_report_data *report_data = core_validation::GetReportData(device_data);
Mark Lobodzinski96210742017-02-09 10:33:46 -07003215
3216 bool correct_usage = false;
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07003217 bool skip = false;
Mark Lobodzinski33826372017-04-13 11:10:11 -06003218 const char *type_str = object_string[obj_type];
Mark Lobodzinski96210742017-02-09 10:33:46 -07003219 if (strict) {
3220 correct_usage = ((actual & desired) == desired);
3221 } else {
3222 correct_usage = ((actual & desired) != 0);
3223 }
3224 if (!correct_usage) {
Dave Houlton8e9f6542018-05-18 12:18:22 -06003225 if (msgCode == kVUIDUndefined) {
Mark Lobodzinski96210742017-02-09 10:33:46 -07003226 // TODO: Fix callers with msgCode == -1 to use correct validation checks.
Dave Houltona9df0ce2018-02-07 10:51:23 -07003227 skip =
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003228 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, get_debug_report_enum[obj_type], obj_handle,
Mark Lobodzinski88529492018-04-01 10:38:15 -06003229 MEMTRACK_INVALID_USAGE_FLAG,
Dave Houltona9df0ce2018-02-07 10:51:23 -07003230 "Invalid usage flag for %s 0x%" PRIx64 " used by %s. In this case, %s should have %s set during creation.",
3231 type_str, obj_handle, func_name, type_str, usage_str);
Mark Lobodzinski96210742017-02-09 10:33:46 -07003232 } else {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003233 skip =
Mark Lobodzinski88529492018-04-01 10:38:15 -06003234 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, get_debug_report_enum[obj_type], obj_handle, msgCode,
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003235 "Invalid usage flag for %s 0x%" PRIx64 " used by %s. In this case, %s should have %s set during creation.",
3236 type_str, obj_handle, func_name, type_str, usage_str);
Mark Lobodzinski96210742017-02-09 10:33:46 -07003237 }
3238 }
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07003239 return skip;
Mark Lobodzinski96210742017-02-09 10:33:46 -07003240}
3241
3242// Helper function to validate usage flags for buffers. For given buffer_state send actual vs. desired usage off to helper above
3243// where an error will be flagged if usage is not correct
Chris Forbes8fdba302017-04-24 18:34:28 -07003244bool ValidateImageUsageFlags(layer_data *device_data, IMAGE_STATE const *image_state, VkFlags desired, bool strict,
Dave Houltone0969282018-05-23 15:54:31 -06003245 const std::string &msgCode, char const *func_name, char const *usage_string) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003246 return validate_usage_flags(device_data, image_state->createInfo.usage, desired, strict, HandleToUint64(image_state->image),
3247 kVulkanObjectTypeImage, msgCode, func_name, usage_string);
Mark Lobodzinski96210742017-02-09 10:33:46 -07003248}
3249
Cort Stratton186b1a22018-05-01 20:18:06 -04003250bool ValidateImageFormatFeatureFlags(layer_data *dev_data, IMAGE_STATE const *image_state, VkFormatFeatureFlags desired,
Dave Houltone0969282018-05-23 15:54:31 -06003251 char const *func_name, const std::string &linear_vuid, const std::string &optimal_vuid) {
Cort Stratton186b1a22018-05-01 20:18:06 -04003252 VkFormatProperties format_properties = GetFormatProperties(dev_data, image_state->createInfo.format);
3253 const debug_report_data *report_data = core_validation::GetReportData(dev_data);
3254 bool skip = false;
3255 if (image_state->createInfo.tiling == VK_IMAGE_TILING_LINEAR) {
3256 if ((format_properties.linearTilingFeatures & desired) != desired) {
3257 skip |=
3258 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3259 HandleToUint64(image_state->image), linear_vuid,
3260 "In %s, invalid linearTilingFeatures (0x%08X) for format %u used by image %" PRIx64 ".", func_name,
3261 format_properties.linearTilingFeatures, image_state->createInfo.format, HandleToUint64(image_state->image));
3262 }
3263 } else if (image_state->createInfo.tiling == VK_IMAGE_TILING_OPTIMAL) {
3264 if ((format_properties.optimalTilingFeatures & desired) != desired) {
3265 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3266 HandleToUint64(image_state->image), optimal_vuid,
3267 "In %s, invalid optimalTilingFeatures (0x%08X) for format %u used by image %" PRIx64 ".", func_name,
3268 format_properties.optimalTilingFeatures, image_state->createInfo.format,
3269 HandleToUint64(image_state->image));
3270 }
3271 }
3272 return skip;
3273}
3274
Mark Lobodzinski96210742017-02-09 10:33:46 -07003275// Helper function to validate usage flags for buffers. For given buffer_state send actual vs. desired usage off to helper above
3276// where an error will be flagged if usage is not correct
Chris Forbes8fdba302017-04-24 18:34:28 -07003277bool ValidateBufferUsageFlags(layer_data *device_data, BUFFER_STATE const *buffer_state, VkFlags desired, bool strict,
Dave Houltone0969282018-05-23 15:54:31 -06003278 const std::string &msgCode, char const *func_name, char const *usage_string) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003279 return validate_usage_flags(device_data, buffer_state->createInfo.usage, desired, strict, HandleToUint64(buffer_state->buffer),
3280 kVulkanObjectTypeBuffer, msgCode, func_name, usage_string);
Mark Lobodzinski96210742017-02-09 10:33:46 -07003281}
3282
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07003283bool PreCallValidateCreateBuffer(layer_data *device_data, const VkBufferCreateInfo *pCreateInfo) {
Mark Lobodzinski96210742017-02-09 10:33:46 -07003284 bool skip = false;
Mark Lobodzinski847b60c2017-03-13 09:32:45 -06003285 const debug_report_data *report_data = core_validation::GetReportData(device_data);
3286
Dave Houltond8ed0212018-05-16 17:18:24 -06003287 // TODO: Add check for "VUID-vkCreateBuffer-flags-00911" (sparse address space accounting)
Mark Lobodzinski847b60c2017-03-13 09:32:45 -06003288
3289 if ((pCreateInfo->flags & VK_BUFFER_CREATE_SPARSE_BINDING_BIT) && (!GetEnabledFeatures(device_data)->sparseBinding)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003290 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 -06003291 "VUID-VkBufferCreateInfo-flags-00915",
Mark Lobodzinski847b60c2017-03-13 09:32:45 -06003292 "vkCreateBuffer(): the sparseBinding device feature is disabled: Buffers cannot be created with the "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003293 "VK_BUFFER_CREATE_SPARSE_BINDING_BIT set.");
Mark Lobodzinski847b60c2017-03-13 09:32:45 -06003294 }
Mark Lobodzinskiaf355062017-03-13 09:35:01 -06003295
3296 if ((pCreateInfo->flags & VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT) && (!GetEnabledFeatures(device_data)->sparseResidencyBuffer)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003297 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 -06003298 "VUID-VkBufferCreateInfo-flags-00916",
Dave Houltona9df0ce2018-02-07 10:51:23 -07003299 "vkCreateBuffer(): the sparseResidencyBuffer device feature is disabled: Buffers cannot be created with "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003300 "the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT set.");
Mark Lobodzinskiaf355062017-03-13 09:35:01 -06003301 }
Mark Lobodzinski035a4cf2017-03-13 09:45:07 -06003302
3303 if ((pCreateInfo->flags & VK_BUFFER_CREATE_SPARSE_ALIASED_BIT) && (!GetEnabledFeatures(device_data)->sparseResidencyAliased)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003304 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 -06003305 "VUID-VkBufferCreateInfo-flags-00917",
Dave Houltona9df0ce2018-02-07 10:51:23 -07003306 "vkCreateBuffer(): the sparseResidencyAliased device feature is disabled: Buffers cannot be created with "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003307 "the VK_BUFFER_CREATE_SPARSE_ALIASED_BIT set.");
Mark Lobodzinski035a4cf2017-03-13 09:45:07 -06003308 }
Mark Lobodzinski96210742017-02-09 10:33:46 -07003309 return skip;
3310}
3311
3312void PostCallRecordCreateBuffer(layer_data *device_data, const VkBufferCreateInfo *pCreateInfo, VkBuffer *pBuffer) {
3313 // TODO : This doesn't create deep copy of pQueueFamilyIndices so need to fix that if/when we want that data to be valid
3314 GetBufferMap(device_data)
3315 ->insert(std::make_pair(*pBuffer, std::unique_ptr<BUFFER_STATE>(new BUFFER_STATE(*pBuffer, pCreateInfo))));
3316}
3317
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07003318bool PreCallValidateCreateBufferView(layer_data *device_data, const VkBufferViewCreateInfo *pCreateInfo) {
3319 bool skip = false;
3320 BUFFER_STATE *buffer_state = GetBufferState(device_data, pCreateInfo->buffer);
Mark Lobodzinski96210742017-02-09 10:33:46 -07003321 // If this isn't a sparse buffer, it needs to have memory backing it at CreateBufferView time
3322 if (buffer_state) {
Dave Houltond8ed0212018-05-16 17:18:24 -06003323 skip |= ValidateMemoryIsBoundToBuffer(device_data, buffer_state, "vkCreateBufferView()",
3324 "VUID-VkBufferViewCreateInfo-buffer-00935");
Mark Lobodzinski96210742017-02-09 10:33:46 -07003325 // In order to create a valid buffer view, the buffer must have been created with at least one of the following flags:
3326 // UNIFORM_TEXEL_BUFFER_BIT or STORAGE_TEXEL_BUFFER_BIT
Dave Houltond8ed0212018-05-16 17:18:24 -06003327 skip |= ValidateBufferUsageFlags(device_data, buffer_state,
3328 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, false,
3329 "VUID-VkBufferViewCreateInfo-buffer-00932", "vkCreateBufferView()",
3330 "VK_BUFFER_USAGE_[STORAGE|UNIFORM]_TEXEL_BUFFER_BIT");
Mark Lobodzinski96210742017-02-09 10:33:46 -07003331 }
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07003332 return skip;
Mark Lobodzinski96210742017-02-09 10:33:46 -07003333}
3334
3335void PostCallRecordCreateBufferView(layer_data *device_data, const VkBufferViewCreateInfo *pCreateInfo, VkBufferView *pView) {
3336 (*GetBufferViewMap(device_data))[*pView] = std::unique_ptr<BUFFER_VIEW_STATE>(new BUFFER_VIEW_STATE(*pView, pCreateInfo));
3337}
Mark Lobodzinski602de982017-02-09 11:01:33 -07003338
3339// For the given format verify that the aspect masks make sense
3340bool ValidateImageAspectMask(layer_data *device_data, VkImage image, VkFormat format, VkImageAspectFlags aspect_mask,
3341 const char *func_name) {
3342 const debug_report_data *report_data = core_validation::GetReportData(device_data);
3343 bool skip = false;
Dave Houlton1d2022c2017-03-29 11:43:58 -06003344 if (FormatIsColor(format)) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07003345 if ((aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != VK_IMAGE_ASPECT_COLOR_BIT) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003346 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 -06003347 HandleToUint64(image), "VUID-VkImageSubresource-aspectMask-parameter",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003348 "%s: Color image formats must have the VK_IMAGE_ASPECT_COLOR_BIT set.", func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07003349 } else if ((aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != aspect_mask) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003350 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 -06003351 HandleToUint64(image), "VUID-VkImageSubresource-aspectMask-parameter",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003352 "%s: Color image formats must have ONLY the VK_IMAGE_ASPECT_COLOR_BIT set.", func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07003353 }
Dave Houlton1d2022c2017-03-29 11:43:58 -06003354 } else if (FormatIsDepthAndStencil(format)) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07003355 if ((aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) == 0) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003356 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 -06003357 HandleToUint64(image), "VUID-VkImageSubresource-aspectMask-parameter",
Dave Houltona9df0ce2018-02-07 10:51:23 -07003358 "%s: Depth/stencil image formats must have at least one of VK_IMAGE_ASPECT_DEPTH_BIT and "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003359 "VK_IMAGE_ASPECT_STENCIL_BIT set.",
3360 func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07003361 } else if ((aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) != aspect_mask) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003362 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 -06003363 HandleToUint64(image), "VUID-VkImageSubresource-aspectMask-parameter",
Mark Lobodzinski602de982017-02-09 11:01:33 -07003364 "%s: Combination depth/stencil image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT and "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003365 "VK_IMAGE_ASPECT_STENCIL_BIT set.",
3366 func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07003367 }
Dave Houlton1d2022c2017-03-29 11:43:58 -06003368 } else if (FormatIsDepthOnly(format)) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07003369 if ((aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003370 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 -06003371 HandleToUint64(image), "VUID-VkImageSubresource-aspectMask-parameter",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003372 "%s: Depth-only image formats must have the VK_IMAGE_ASPECT_DEPTH_BIT set.", func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07003373 } else if ((aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) != aspect_mask) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003374 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 -06003375 HandleToUint64(image), "VUID-VkImageSubresource-aspectMask-parameter",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003376 "%s: Depth-only image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT set.", func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07003377 }
Dave Houlton1d2022c2017-03-29 11:43:58 -06003378 } else if (FormatIsStencilOnly(format)) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07003379 if ((aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003380 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 -06003381 HandleToUint64(image), "VUID-VkImageSubresource-aspectMask-parameter",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003382 "%s: Stencil-only image formats must have the VK_IMAGE_ASPECT_STENCIL_BIT set.", func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07003383 } else if ((aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) != aspect_mask) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003384 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 -06003385 HandleToUint64(image), "VUID-VkImageSubresource-aspectMask-parameter",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003386 "%s: Stencil-only image formats can have only the VK_IMAGE_ASPECT_STENCIL_BIT set.", func_name);
Mark Lobodzinski602de982017-02-09 11:01:33 -07003387 }
Dave Houlton501b15b2018-03-30 15:07:41 -06003388 } else if (FormatIsMultiplane(format)) {
3389 VkImageAspectFlags valid_flags = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT;
3390 if (3 == FormatPlaneCount(format)) {
3391 valid_flags = valid_flags | VK_IMAGE_ASPECT_PLANE_2_BIT;
3392 }
3393 if ((aspect_mask & valid_flags) != aspect_mask) {
3394 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 -06003395 HandleToUint64(image), "VUID-VkImageSubresource-aspectMask-parameter",
Dave Houlton501b15b2018-03-30 15:07:41 -06003396 "%s: Multi-plane image formats may have only VK_IMAGE_ASPECT_COLOR_BIT or VK_IMAGE_ASPECT_PLANE_n_BITs "
3397 "set, where n = [0, 1, 2].",
3398 func_name);
3399 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07003400 }
3401 return skip;
3402}
3403
Petr Krausffa94af2017-08-08 21:46:02 +02003404struct SubresourceRangeErrorCodes {
Dave Houltond8ed0212018-05-16 17:18:24 -06003405 std::string base_mip_err, mip_count_err, base_layer_err, layer_count_err;
Petr Krausffa94af2017-08-08 21:46:02 +02003406};
3407
3408bool ValidateImageSubresourceRange(const layer_data *device_data, const uint32_t image_mip_count, const uint32_t image_layer_count,
3409 const VkImageSubresourceRange &subresourceRange, const char *cmd_name, const char *param_name,
3410 const char *image_layer_count_var_name, const uint64_t image_handle,
3411 SubresourceRangeErrorCodes errorCodes) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07003412 const debug_report_data *report_data = core_validation::GetReportData(device_data);
3413 bool skip = false;
Petr Kraus4d718682017-05-18 03:38:41 +02003414
3415 // Validate mip levels
Petr Krausffa94af2017-08-08 21:46:02 +02003416 if (subresourceRange.baseMipLevel >= image_mip_count) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003417 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 -06003418 errorCodes.base_mip_err,
Petr Krausffa94af2017-08-08 21:46:02 +02003419 "%s: %s.baseMipLevel (= %" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003420 ") is greater or equal to the mip level count of the image (i.e. greater or equal to %" PRIu32 ").",
3421 cmd_name, param_name, subresourceRange.baseMipLevel, image_mip_count);
Petr Krausffa94af2017-08-08 21:46:02 +02003422 }
Petr Kraus4d718682017-05-18 03:38:41 +02003423
Petr Krausffa94af2017-08-08 21:46:02 +02003424 if (subresourceRange.levelCount != VK_REMAINING_MIP_LEVELS) {
3425 if (subresourceRange.levelCount == 0) {
3426 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 -06003427 errorCodes.mip_count_err, "%s: %s.levelCount is 0.", cmd_name, param_name);
Petr Krausffa94af2017-08-08 21:46:02 +02003428 } else {
3429 const uint64_t necessary_mip_count = uint64_t{subresourceRange.baseMipLevel} + uint64_t{subresourceRange.levelCount};
Petr Kraus4d718682017-05-18 03:38:41 +02003430
Petr Krausffa94af2017-08-08 21:46:02 +02003431 if (necessary_mip_count > image_mip_count) {
3432 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 -06003433 errorCodes.mip_count_err,
Petr Krausffa94af2017-08-08 21:46:02 +02003434 "%s: %s.baseMipLevel + .levelCount (= %" PRIu32 " + %" PRIu32 " = %" PRIu64
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003435 ") is greater than the mip level count of the image (i.e. greater than %" PRIu32 ").",
Petr Krausffa94af2017-08-08 21:46:02 +02003436 cmd_name, param_name, subresourceRange.baseMipLevel, subresourceRange.levelCount,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003437 necessary_mip_count, image_mip_count);
Petr Krausffa94af2017-08-08 21:46:02 +02003438 }
Petr Kraus4d718682017-05-18 03:38:41 +02003439 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07003440 }
Petr Kraus4d718682017-05-18 03:38:41 +02003441
3442 // Validate array layers
Petr Krausffa94af2017-08-08 21:46:02 +02003443 if (subresourceRange.baseArrayLayer >= image_layer_count) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003444 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 -06003445 errorCodes.base_layer_err,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003446 "%s: %s.baseArrayLayer (= %" PRIu32
3447 ") is greater or equal to the %s of the image when it was created (i.e. greater or equal to %" PRIu32 ").",
3448 cmd_name, param_name, subresourceRange.baseArrayLayer, image_layer_count_var_name, image_layer_count);
Petr Krausffa94af2017-08-08 21:46:02 +02003449 }
Petr Kraus4d718682017-05-18 03:38:41 +02003450
Petr Krausffa94af2017-08-08 21:46:02 +02003451 if (subresourceRange.layerCount != VK_REMAINING_ARRAY_LAYERS) {
3452 if (subresourceRange.layerCount == 0) {
3453 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 -06003454 errorCodes.layer_count_err, "%s: %s.layerCount is 0.", cmd_name, param_name);
Petr Krausffa94af2017-08-08 21:46:02 +02003455 } else {
3456 const uint64_t necessary_layer_count =
3457 uint64_t{subresourceRange.baseArrayLayer} + uint64_t{subresourceRange.layerCount};
Petr Kraus8423f152017-05-26 01:20:04 +02003458
Petr Krausffa94af2017-08-08 21:46:02 +02003459 if (necessary_layer_count > image_layer_count) {
3460 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 -06003461 errorCodes.layer_count_err,
Petr Krausffa94af2017-08-08 21:46:02 +02003462 "%s: %s.baseArrayLayer + .layerCount (= %" PRIu32 " + %" PRIu32 " = %" PRIu64
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003463 ") is greater than the %s of the image when it was created (i.e. greater than %" PRIu32 ").",
Petr Krausffa94af2017-08-08 21:46:02 +02003464 cmd_name, param_name, subresourceRange.baseArrayLayer, subresourceRange.layerCount,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003465 necessary_layer_count, image_layer_count_var_name, image_layer_count);
Petr Krausffa94af2017-08-08 21:46:02 +02003466 }
Petr Kraus4d718682017-05-18 03:38:41 +02003467 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07003468 }
Petr Kraus4d718682017-05-18 03:38:41 +02003469
Mark Lobodzinski602de982017-02-09 11:01:33 -07003470 return skip;
3471}
3472
Petr Krausffa94af2017-08-08 21:46:02 +02003473bool ValidateCreateImageViewSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state,
3474 bool is_imageview_2d_type, const VkImageSubresourceRange &subresourceRange) {
3475 bool is_khr_maintenance1 = GetDeviceExtensions(device_data)->vk_khr_maintenance1;
3476 bool is_image_slicable = image_state->createInfo.imageType == VK_IMAGE_TYPE_3D &&
3477 (image_state->createInfo.flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR);
3478 bool is_3D_to_2D_map = is_khr_maintenance1 && is_image_slicable && is_imageview_2d_type;
3479
3480 const auto image_layer_count = is_3D_to_2D_map ? image_state->createInfo.extent.depth : image_state->createInfo.arrayLayers;
3481 const auto image_layer_count_var_name = is_3D_to_2D_map ? "extent.depth" : "arrayLayers";
3482
3483 SubresourceRangeErrorCodes subresourceRangeErrorCodes = {};
Dave Houltond8ed0212018-05-16 17:18:24 -06003484 subresourceRangeErrorCodes.base_mip_err = "VUID-VkImageViewCreateInfo-subresourceRange-01478";
3485 subresourceRangeErrorCodes.mip_count_err = "VUID-VkImageViewCreateInfo-subresourceRange-01718";
3486 subresourceRangeErrorCodes.base_layer_err = is_khr_maintenance1 ? (is_3D_to_2D_map ? "VUID-VkImageViewCreateInfo-image-01484"
3487 : "VUID-VkImageViewCreateInfo-image-01482")
3488 : "VUID-VkImageViewCreateInfo-subresourceRange-01480";
3489 subresourceRangeErrorCodes.layer_count_err = is_khr_maintenance1
3490 ? (is_3D_to_2D_map ? "VUID-VkImageViewCreateInfo-subresourceRange-01485"
3491 : "VUID-VkImageViewCreateInfo-subresourceRange-01483")
3492 : "VUID-VkImageViewCreateInfo-subresourceRange-01719";
Petr Krausffa94af2017-08-08 21:46:02 +02003493
3494 return ValidateImageSubresourceRange(device_data, image_state->createInfo.mipLevels, image_layer_count, subresourceRange,
3495 "vkCreateImageView", "pCreateInfo->subresourceRange", image_layer_count_var_name,
3496 HandleToUint64(image_state->image), subresourceRangeErrorCodes);
3497}
3498
3499bool ValidateCmdClearColorSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state,
3500 const VkImageSubresourceRange &subresourceRange, const char *param_name) {
3501 SubresourceRangeErrorCodes subresourceRangeErrorCodes = {};
Dave Houltond8ed0212018-05-16 17:18:24 -06003502 subresourceRangeErrorCodes.base_mip_err = "VUID-vkCmdClearColorImage-baseMipLevel-01470";
3503 subresourceRangeErrorCodes.mip_count_err = "VUID-vkCmdClearColorImage-pRanges-01692";
3504 subresourceRangeErrorCodes.base_layer_err = "VUID-vkCmdClearColorImage-baseArrayLayer-01472";
3505 subresourceRangeErrorCodes.layer_count_err = "VUID-vkCmdClearColorImage-pRanges-01693";
Petr Krausffa94af2017-08-08 21:46:02 +02003506
3507 return ValidateImageSubresourceRange(device_data, image_state->createInfo.mipLevels, image_state->createInfo.arrayLayers,
3508 subresourceRange, "vkCmdClearColorImage", param_name, "arrayLayers",
3509 HandleToUint64(image_state->image), subresourceRangeErrorCodes);
3510}
3511
3512bool ValidateCmdClearDepthSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state,
3513 const VkImageSubresourceRange &subresourceRange, const char *param_name) {
3514 SubresourceRangeErrorCodes subresourceRangeErrorCodes = {};
Dave Houltond8ed0212018-05-16 17:18:24 -06003515 subresourceRangeErrorCodes.base_mip_err = "VUID-vkCmdClearDepthStencilImage-baseMipLevel-01474";
3516 subresourceRangeErrorCodes.mip_count_err = "VUID-vkCmdClearDepthStencilImage-pRanges-01694";
3517 subresourceRangeErrorCodes.base_layer_err = "VUID-vkCmdClearDepthStencilImage-baseArrayLayer-01476";
3518 subresourceRangeErrorCodes.layer_count_err = "VUID-vkCmdClearDepthStencilImage-pRanges-01695";
Petr Krausffa94af2017-08-08 21:46:02 +02003519
3520 return ValidateImageSubresourceRange(device_data, image_state->createInfo.mipLevels, image_state->createInfo.arrayLayers,
3521 subresourceRange, "vkCmdClearDepthStencilImage", param_name, "arrayLayers",
3522 HandleToUint64(image_state->image), subresourceRangeErrorCodes);
3523}
3524
3525bool ValidateImageBarrierSubresourceRange(const layer_data *device_data, const IMAGE_STATE *image_state,
3526 const VkImageSubresourceRange &subresourceRange, const char *cmd_name,
3527 const char *param_name) {
3528 SubresourceRangeErrorCodes subresourceRangeErrorCodes = {};
Dave Houltond8ed0212018-05-16 17:18:24 -06003529 subresourceRangeErrorCodes.base_mip_err = "VUID-VkImageMemoryBarrier-subresourceRange-01486";
3530 subresourceRangeErrorCodes.mip_count_err = "VUID-VkImageMemoryBarrier-subresourceRange-01724";
3531 subresourceRangeErrorCodes.base_layer_err = "VUID-VkImageMemoryBarrier-subresourceRange-01488";
3532 subresourceRangeErrorCodes.layer_count_err = "VUID-VkImageMemoryBarrier-subresourceRange-01725";
Petr Krausffa94af2017-08-08 21:46:02 +02003533
3534 return ValidateImageSubresourceRange(device_data, image_state->createInfo.mipLevels, image_state->createInfo.arrayLayers,
3535 subresourceRange, cmd_name, param_name, "arrayLayers", HandleToUint64(image_state->image),
3536 subresourceRangeErrorCodes);
3537}
3538
Mark Lobodzinski602de982017-02-09 11:01:33 -07003539bool PreCallValidateCreateImageView(layer_data *device_data, const VkImageViewCreateInfo *create_info) {
3540 const debug_report_data *report_data = core_validation::GetReportData(device_data);
3541 bool skip = false;
3542 IMAGE_STATE *image_state = GetImageState(device_data, create_info->image);
3543 if (image_state) {
3544 skip |= ValidateImageUsageFlags(
3545 device_data, image_state,
3546 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT |
Dave Houltona9df0ce2018-02-07 10:51:23 -07003547 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
Dave Houlton8e9f6542018-05-18 12:18:22 -06003548 false, kVUIDUndefined, "vkCreateImageView()",
Mark Lobodzinski602de982017-02-09 11:01:33 -07003549 "VK_IMAGE_USAGE_[SAMPLED|STORAGE|COLOR_ATTACHMENT|DEPTH_STENCIL_ATTACHMENT|INPUT_ATTACHMENT]_BIT");
3550 // If this isn't a sparse image, it needs to have memory backing it at CreateImageView time
Dave Houltond8ed0212018-05-16 17:18:24 -06003551 skip |=
3552 ValidateMemoryIsBoundToImage(device_data, image_state, "vkCreateImageView()", "VUID-VkImageViewCreateInfo-image-01020");
Mark Lobodzinski602de982017-02-09 11:01:33 -07003553 // Checks imported from image layer
Petr Krausffa94af2017-08-08 21:46:02 +02003554 skip |= ValidateCreateImageViewSubresourceRange(
3555 device_data, image_state,
3556 create_info->viewType == VK_IMAGE_VIEW_TYPE_2D || create_info->viewType == VK_IMAGE_VIEW_TYPE_2D_ARRAY,
3557 create_info->subresourceRange);
Mark Lobodzinski602de982017-02-09 11:01:33 -07003558
3559 VkImageCreateFlags image_flags = image_state->createInfo.flags;
3560 VkFormat image_format = image_state->createInfo.format;
Jeremy Kniagercef491c2017-07-18 11:10:28 -06003561 VkImageUsageFlags image_usage = image_state->createInfo.usage;
3562 VkImageTiling image_tiling = image_state->createInfo.tiling;
Mark Lobodzinski602de982017-02-09 11:01:33 -07003563 VkFormat view_format = create_info->format;
3564 VkImageAspectFlags aspect_mask = create_info->subresourceRange.aspectMask;
Jeremy Kniager846ab732017-07-10 13:12:04 -06003565 VkImageType image_type = image_state->createInfo.imageType;
3566 VkImageViewType view_type = create_info->viewType;
Mark Lobodzinski602de982017-02-09 11:01:33 -07003567
Dave Houltonbd2e2622018-04-10 16:41:14 -06003568 // If there's a chained VkImageViewUsageCreateInfo struct, modify image_usage to match
3569 auto chained_ivuci_struct = lvl_find_in_chain<VkImageViewUsageCreateInfoKHR>(create_info->pNext);
3570 if (chained_ivuci_struct) {
3571 if (chained_ivuci_struct->usage & ~image_usage) {
3572 std::stringstream ss;
3573 ss << "vkCreateImageView(): Chained VkImageViewUsageCreateInfo usage field (0x" << std::hex
Dave Houlton0f3795b2018-04-13 15:04:35 -06003574 << chained_ivuci_struct->usage << ") must not include flags not present in underlying image's usage (0x"
Dave Houltonbd2e2622018-04-10 16:41:14 -06003575 << image_usage << ").";
Mark Young9d1ac312018-05-21 16:28:27 -06003576 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3577 HandleToUint64(create_info->image), "VUID-VkImageViewUsageCreateInfo-usage-01587", "%s",
3578 ss.str().c_str());
Dave Houltonbd2e2622018-04-10 16:41:14 -06003579 }
3580
3581 image_usage = chained_ivuci_struct->usage;
3582 }
3583
Dave Houlton6f5f20a2018-05-04 12:37:44 -06003584 // Validate VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT state, if view/image formats differ
3585 if ((image_flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) && (image_format != view_format)) {
Dave Houltonc7988072018-04-16 11:46:56 -06003586 if (FormatIsMultiplane(image_format)) {
3587 // View format must match the multiplane compatible format
3588 uint32_t plane = 3; // invalid
3589 switch (aspect_mask) {
3590 case VK_IMAGE_ASPECT_PLANE_0_BIT:
3591 plane = 0;
3592 break;
3593 case VK_IMAGE_ASPECT_PLANE_1_BIT:
3594 plane = 1;
3595 break;
3596 case VK_IMAGE_ASPECT_PLANE_2_BIT:
3597 plane = 2;
3598 break;
3599 default:
3600 break;
3601 }
3602
3603 VkFormat compat_format = FindMultiplaneCompatibleFormat(image_format, plane);
3604 if (view_format != compat_format) {
Lenny Komowb79f04a2017-09-18 17:07:00 -06003605 std::stringstream ss;
3606 ss << "vkCreateImageView(): ImageView format " << string_VkFormat(view_format)
Dave Houltonc7988072018-04-16 11:46:56 -06003607 << " is not compatible with plane " << plane << " of underlying image format "
3608 << string_VkFormat(image_format) << ", must be " << string_VkFormat(compat_format) << ".";
Mark Young9d1ac312018-05-21 16:28:27 -06003609 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3610 HandleToUint64(create_info->image), "VUID-VkImageViewCreateInfo-image-01586", "%s",
3611 ss.str().c_str());
Dave Houltonc7988072018-04-16 11:46:56 -06003612 }
3613 } else {
3614 if ((!GetDeviceExtensions(device_data)->vk_khr_maintenance2 ||
3615 !(image_flags & VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR))) {
3616 // Format MUST be compatible (in the same format compatibility class) as the format the image was created with
3617 if (FormatCompatibilityClass(image_format) != FormatCompatibilityClass(view_format)) {
3618 std::stringstream ss;
3619 ss << "vkCreateImageView(): ImageView format " << string_VkFormat(view_format)
3620 << " is not in the same format compatibility class as image (" << HandleToUint64(create_info->image)
3621 << ") format " << string_VkFormat(image_format)
3622 << ". Images created with the VK_IMAGE_CREATE_MUTABLE_FORMAT BIT "
3623 << "can support ImageViews with differing formats but they must be in the same compatibility class.";
Mark Young9d1ac312018-05-21 16:28:27 -06003624 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3625 HandleToUint64(create_info->image), "VUID-VkImageViewCreateInfo-image-01018", "%s",
3626 ss.str().c_str());
Dave Houltonc7988072018-04-16 11:46:56 -06003627 }
Lenny Komowb79f04a2017-09-18 17:07:00 -06003628 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07003629 }
3630 } else {
3631 // Format MUST be IDENTICAL to the format the image was created with
3632 if (image_format != view_format) {
3633 std::stringstream ss;
3634 ss << "vkCreateImageView() format " << string_VkFormat(view_format) << " differs from image "
Petr Krausbc7f5442017-05-14 23:43:38 +02003635 << HandleToUint64(create_info->image) << " format " << string_VkFormat(image_format)
Mark Lobodzinski602de982017-02-09 11:01:33 -07003636 << ". Formats MUST be IDENTICAL unless VK_IMAGE_CREATE_MUTABLE_FORMAT BIT was set on image creation.";
Mark Young9d1ac312018-05-21 16:28:27 -06003637 skip |=
3638 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3639 HandleToUint64(create_info->image), "VUID-VkImageViewCreateInfo-image-01019", "%s", ss.str().c_str());
Mark Lobodzinski602de982017-02-09 11:01:33 -07003640 }
3641 }
3642
3643 // Validate correct image aspect bits for desired formats and format consistency
3644 skip |= ValidateImageAspectMask(device_data, image_state->image, image_format, aspect_mask, "vkCreateImageView()");
Jeremy Kniager846ab732017-07-10 13:12:04 -06003645
3646 switch (image_type) {
3647 case VK_IMAGE_TYPE_1D:
3648 if (view_type != VK_IMAGE_VIEW_TYPE_1D && view_type != VK_IMAGE_VIEW_TYPE_1D_ARRAY) {
Mark Young9d1ac312018-05-21 16:28:27 -06003649 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3650 HandleToUint64(create_info->image), "VUID-VkImageViewCreateInfo-subResourceRange-01021",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003651 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
3652 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06003653 }
3654 break;
3655 case VK_IMAGE_TYPE_2D:
3656 if (view_type != VK_IMAGE_VIEW_TYPE_2D && view_type != VK_IMAGE_VIEW_TYPE_2D_ARRAY) {
3657 if ((view_type == VK_IMAGE_VIEW_TYPE_CUBE || view_type == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) &&
3658 !(image_flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)) {
Mark Young9d1ac312018-05-21 16:28:27 -06003659 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3660 HandleToUint64(create_info->image), "VUID-VkImageViewCreateInfo-image-01003",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003661 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
3662 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06003663 } else if (view_type != VK_IMAGE_VIEW_TYPE_CUBE && view_type != VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) {
Mark Young9d1ac312018-05-21 16:28:27 -06003664 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3665 HandleToUint64(create_info->image), "VUID-VkImageViewCreateInfo-subResourceRange-01021",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003666 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
3667 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06003668 }
3669 }
3670 break;
3671 case VK_IMAGE_TYPE_3D:
3672 if (GetDeviceExtensions(device_data)->vk_khr_maintenance1) {
3673 if (view_type != VK_IMAGE_VIEW_TYPE_3D) {
3674 if ((view_type == VK_IMAGE_VIEW_TYPE_2D || view_type == VK_IMAGE_VIEW_TYPE_2D_ARRAY)) {
3675 if (!(image_flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR)) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003676 skip |=
Mark Young9d1ac312018-05-21 16:28:27 -06003677 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3678 HandleToUint64(create_info->image), "VUID-VkImageViewCreateInfo-image-01005",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003679 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
3680 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06003681 } else if ((image_flags & (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT |
3682 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT))) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07003683 skip |=
Mark Young9d1ac312018-05-21 16:28:27 -06003684 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3685 HandleToUint64(create_info->image), "VUID-VkImageViewCreateInfo-subResourceRange-01021",
Dave Houltona9df0ce2018-02-07 10:51:23 -07003686 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s "
3687 "when the VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003688 "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT flags are enabled.",
3689 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06003690 }
3691 } else {
Mark Young9d1ac312018-05-21 16:28:27 -06003692 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3693 HandleToUint64(create_info->image), "VUID-VkImageViewCreateInfo-subResourceRange-01021",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003694 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
3695 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06003696 }
3697 }
3698 } else {
3699 if (view_type != VK_IMAGE_VIEW_TYPE_3D) {
Mark Young9d1ac312018-05-21 16:28:27 -06003700 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3701 HandleToUint64(create_info->image), "VUID-VkImageViewCreateInfo-subResourceRange-01021",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003702 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
3703 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06003704 }
3705 }
3706 break;
3707 default:
3708 break;
3709 }
Jeremy Kniagercef491c2017-07-18 11:10:28 -06003710
Jeremy Kniager7ec550f2017-08-16 14:57:42 -06003711 VkFormatProperties format_properties = GetFormatProperties(device_data, view_format);
Jeremy Kniagercef491c2017-07-18 11:10:28 -06003712 bool check_tiling_features = false;
3713 VkFormatFeatureFlags tiling_features = 0;
Dave Houltond8ed0212018-05-16 17:18:24 -06003714 std::string linear_error_codes[] = {
3715 "VUID-VkImageViewCreateInfo-image-01006", "VUID-VkImageViewCreateInfo-image-01008",
3716 "VUID-VkImageViewCreateInfo-image-01009", "VUID-VkImageViewCreateInfo-image-01010",
3717 "VUID-VkImageViewCreateInfo-image-01011",
Jeremy Kniagercef491c2017-07-18 11:10:28 -06003718 };
Dave Houltond8ed0212018-05-16 17:18:24 -06003719 std::string optimal_error_codes[] = {
3720 "VUID-VkImageViewCreateInfo-image-01012", "VUID-VkImageViewCreateInfo-image-01013",
3721 "VUID-VkImageViewCreateInfo-image-01014", "VUID-VkImageViewCreateInfo-image-01015",
3722 "VUID-VkImageViewCreateInfo-image-01016",
Jeremy Kniagercef491c2017-07-18 11:10:28 -06003723 };
Dave Houltond8ed0212018-05-16 17:18:24 -06003724 std::string *error_codes = nullptr;
Jeremy Kniagercef491c2017-07-18 11:10:28 -06003725 if (image_tiling == VK_IMAGE_TILING_LINEAR) {
Jeremy Kniager7ec550f2017-08-16 14:57:42 -06003726 tiling_features = format_properties.linearTilingFeatures;
Jeremy Kniagercef491c2017-07-18 11:10:28 -06003727 error_codes = linear_error_codes;
3728 check_tiling_features = true;
3729 } else if (image_tiling == VK_IMAGE_TILING_OPTIMAL) {
Jeremy Kniager7ec550f2017-08-16 14:57:42 -06003730 tiling_features = format_properties.optimalTilingFeatures;
Jeremy Kniagercef491c2017-07-18 11:10:28 -06003731 error_codes = optimal_error_codes;
3732 check_tiling_features = true;
3733 }
3734
3735 if (check_tiling_features) {
3736 if (tiling_features == 0) {
Mark Young9d1ac312018-05-21 16:28:27 -06003737 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3738 HandleToUint64(create_info->image), error_codes[0],
3739 "vkCreateImageView() pCreateInfo->format %s cannot be used with an image having the %s flag set.",
3740 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
Jeremy Kniagercef491c2017-07-18 11:10:28 -06003741 } else if ((image_usage & VK_IMAGE_USAGE_SAMPLED_BIT) && !(tiling_features & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
Mark Young9d1ac312018-05-21 16:28:27 -06003742 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3743 HandleToUint64(create_info->image), error_codes[1],
3744 "vkCreateImageView() pCreateInfo->format %s cannot be used with an image having the %s and "
3745 "VK_IMAGE_USAGE_SAMPLED_BIT flags set.",
3746 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
Jeremy Kniagercef491c2017-07-18 11:10:28 -06003747 } else if ((image_usage & VK_IMAGE_USAGE_STORAGE_BIT) && !(tiling_features & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)) {
Mark Young9d1ac312018-05-21 16:28:27 -06003748 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3749 HandleToUint64(create_info->image), error_codes[2],
3750 "vkCreateImageView() pCreateInfo->format %s cannot be used with an image having the %s and "
3751 "VK_IMAGE_USAGE_STORAGE_BIT flags set.",
3752 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
Jeremy Kniagercef491c2017-07-18 11:10:28 -06003753 } else if ((image_usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) &&
3754 !(tiling_features & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) {
Mark Young9d1ac312018-05-21 16:28:27 -06003755 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3756 HandleToUint64(create_info->image), error_codes[3],
3757 "vkCreateImageView() pCreateInfo->format %s cannot be used with an image having the %s and "
3758 "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT flags set.",
3759 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
Jeremy Kniagercef491c2017-07-18 11:10:28 -06003760 } else if ((image_usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) &&
3761 !(tiling_features & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
Mark Young9d1ac312018-05-21 16:28:27 -06003762 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3763 HandleToUint64(create_info->image), error_codes[4],
3764 "vkCreateImageView() pCreateInfo->format %s cannot be used with an image having the %s and "
3765 "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT flags set.",
3766 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
Jeremy Kniagercef491c2017-07-18 11:10:28 -06003767 }
3768 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07003769 }
3770 return skip;
3771}
3772
Mark Lobodzinskiefd933b2017-02-10 12:09:23 -07003773void PostCallRecordCreateImageView(layer_data *device_data, const VkImageViewCreateInfo *create_info, VkImageView view) {
3774 auto image_view_map = GetImageViewMap(device_data);
3775 (*image_view_map)[view] = std::unique_ptr<IMAGE_VIEW_STATE>(new IMAGE_VIEW_STATE(view, create_info));
3776
3777 auto image_state = GetImageState(device_data, create_info->image);
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06003778 auto &sub_res_range = (*image_view_map)[view].get()->create_info.subresourceRange;
Mark Lobodzinski903e5ff2017-03-23 09:43:35 -06003779 sub_res_range.levelCount = ResolveRemainingLevels(&sub_res_range, image_state->createInfo.mipLevels);
3780 sub_res_range.layerCount = ResolveRemainingLayers(&sub_res_range, image_state->createInfo.arrayLayers);
Mark Lobodzinski602de982017-02-09 11:01:33 -07003781}
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07003782
Mark Lobodzinski680421d2017-02-09 13:06:56 -07003783bool PreCallValidateCmdCopyBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *src_buffer_state,
3784 BUFFER_STATE *dst_buffer_state) {
3785 bool skip = false;
Dave Houltond8ed0212018-05-16 17:18:24 -06003786 skip |=
3787 ValidateMemoryIsBoundToBuffer(device_data, src_buffer_state, "vkCmdCopyBuffer()", "VUID-vkCmdCopyBuffer-srcBuffer-00119");
3788 skip |=
3789 ValidateMemoryIsBoundToBuffer(device_data, dst_buffer_state, "vkCmdCopyBuffer()", "VUID-vkCmdCopyBuffer-dstBuffer-00121");
Mark Lobodzinski680421d2017-02-09 13:06:56 -07003790 // Validate that SRC & DST buffers have correct usage flags set
Dave Houltond8ed0212018-05-16 17:18:24 -06003791 skip |=
3792 ValidateBufferUsageFlags(device_data, src_buffer_state, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true,
3793 "VUID-vkCmdCopyBuffer-srcBuffer-00118", "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_SRC_BIT");
3794 skip |=
3795 ValidateBufferUsageFlags(device_data, dst_buffer_state, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true,
3796 "VUID-vkCmdCopyBuffer-dstBuffer-00120", "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
Mike Schuchardt9c582402017-02-23 15:57:37 -07003797 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdCopyBuffer()",
Dave Houltond8ed0212018-05-16 17:18:24 -06003798 VK_QUEUE_TRANSFER_BIT | VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT,
3799 "VUID-vkCmdCopyBuffer-commandBuffer-cmdpool");
Mark Lobodzinski680421d2017-02-09 13:06:56 -07003800 skip |= ValidateCmd(device_data, cb_node, CMD_COPYBUFFER, "vkCmdCopyBuffer()");
Dave Houltond8ed0212018-05-16 17:18:24 -06003801 skip |= insideRenderPass(device_data, cb_node, "vkCmdCopyBuffer()", "VUID-vkCmdCopyBuffer-renderpass");
Mark Lobodzinski680421d2017-02-09 13:06:56 -07003802 return skip;
3803}
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07003804
Mark Lobodzinski680421d2017-02-09 13:06:56 -07003805void PreCallRecordCmdCopyBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *src_buffer_state,
3806 BUFFER_STATE *dst_buffer_state) {
3807 // Update bindings between buffers and cmd buffer
3808 AddCommandBufferBindingBuffer(device_data, cb_node, src_buffer_state);
3809 AddCommandBufferBindingBuffer(device_data, cb_node, dst_buffer_state);
Mark Lobodzinski680421d2017-02-09 13:06:56 -07003810}
Mark Lobodzinski306441e2017-02-10 13:48:38 -07003811
3812static bool validateIdleBuffer(layer_data *device_data, VkBuffer buffer) {
3813 const debug_report_data *report_data = core_validation::GetReportData(device_data);
3814 bool skip = false;
3815 auto buffer_state = GetBufferState(device_data, buffer);
3816 if (!buffer_state) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003817 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, HandleToUint64(buffer),
Mark Lobodzinski88529492018-04-01 10:38:15 -06003818 DRAWSTATE_DOUBLE_DESTROY, "Cannot free buffer 0x%" PRIx64 " that has not been allocated.",
Petr Kraus13c98a62017-12-09 00:22:39 +01003819 HandleToUint64(buffer));
Mark Lobodzinski306441e2017-02-10 13:48:38 -07003820 } else {
3821 if (buffer_state->in_use.load()) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003822 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 -06003823 HandleToUint64(buffer), "VUID-vkDestroyBuffer-buffer-00922",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003824 "Cannot free buffer 0x%" PRIx64 " that is in use by a command buffer.", HandleToUint64(buffer));
Mark Lobodzinski306441e2017-02-10 13:48:38 -07003825 }
3826 }
3827 return skip;
3828}
3829
3830bool PreCallValidateDestroyImageView(layer_data *device_data, VkImageView image_view, IMAGE_VIEW_STATE **image_view_state,
3831 VK_OBJECT *obj_struct) {
3832 *image_view_state = GetImageViewState(device_data, image_view);
Petr Krausbc7f5442017-05-14 23:43:38 +02003833 *obj_struct = {HandleToUint64(image_view), kVulkanObjectTypeImageView};
Mark Lobodzinski306441e2017-02-10 13:48:38 -07003834 if (GetDisables(device_data)->destroy_image_view) return false;
3835 bool skip = false;
3836 if (*image_view_state) {
Dave Houltond8ed0212018-05-16 17:18:24 -06003837 skip |= ValidateObjectNotInUse(device_data, *image_view_state, *obj_struct, "vkDestroyImageView",
3838 "VUID-vkDestroyImageView-imageView-01026");
Mark Lobodzinski306441e2017-02-10 13:48:38 -07003839 }
3840 return skip;
3841}
3842
John Zulauffca05c12018-04-26 16:30:39 -06003843void PreCallRecordDestroyImageView(layer_data *device_data, VkImageView image_view, IMAGE_VIEW_STATE *image_view_state,
3844 VK_OBJECT obj_struct) {
Mark Lobodzinski306441e2017-02-10 13:48:38 -07003845 // Any bound cmd buffers are now invalid
3846 invalidateCommandBuffers(device_data, image_view_state->cb_bindings, obj_struct);
3847 (*GetImageViewMap(device_data)).erase(image_view);
3848}
3849
3850bool PreCallValidateDestroyBuffer(layer_data *device_data, VkBuffer buffer, BUFFER_STATE **buffer_state, VK_OBJECT *obj_struct) {
3851 *buffer_state = GetBufferState(device_data, buffer);
Petr Krausbc7f5442017-05-14 23:43:38 +02003852 *obj_struct = {HandleToUint64(buffer), kVulkanObjectTypeBuffer};
Mark Lobodzinski306441e2017-02-10 13:48:38 -07003853 if (GetDisables(device_data)->destroy_buffer) return false;
3854 bool skip = false;
3855 if (*buffer_state) {
3856 skip |= validateIdleBuffer(device_data, buffer);
3857 }
3858 return skip;
3859}
3860
John Zulauffca05c12018-04-26 16:30:39 -06003861void PreCallRecordDestroyBuffer(layer_data *device_data, VkBuffer buffer, BUFFER_STATE *buffer_state, VK_OBJECT obj_struct) {
Mark Lobodzinski306441e2017-02-10 13:48:38 -07003862 invalidateCommandBuffers(device_data, buffer_state->cb_bindings, obj_struct);
3863 for (auto mem_binding : buffer_state->GetBoundMemory()) {
3864 auto mem_info = GetMemObjInfo(device_data, mem_binding);
3865 if (mem_info) {
Petr Krausbc7f5442017-05-14 23:43:38 +02003866 core_validation::RemoveBufferMemoryRange(HandleToUint64(buffer), mem_info);
Mark Lobodzinski306441e2017-02-10 13:48:38 -07003867 }
3868 }
Petr Krausbc7f5442017-05-14 23:43:38 +02003869 ClearMemoryObjectBindings(device_data, HandleToUint64(buffer), kVulkanObjectTypeBuffer);
John Zulauf6b4aae82018-05-09 13:03:36 -06003870 EraseQFOReleaseBarriers<VkBufferMemoryBarrier>(device_data, buffer);
Mark Lobodzinski306441e2017-02-10 13:48:38 -07003871 GetBufferMap(device_data)->erase(buffer_state->buffer);
3872}
3873
3874bool PreCallValidateDestroyBufferView(layer_data *device_data, VkBufferView buffer_view, BUFFER_VIEW_STATE **buffer_view_state,
3875 VK_OBJECT *obj_struct) {
3876 *buffer_view_state = GetBufferViewState(device_data, buffer_view);
Petr Krausbc7f5442017-05-14 23:43:38 +02003877 *obj_struct = {HandleToUint64(buffer_view), kVulkanObjectTypeBufferView};
Mark Lobodzinski306441e2017-02-10 13:48:38 -07003878 if (GetDisables(device_data)->destroy_buffer_view) return false;
3879 bool skip = false;
3880 if (*buffer_view_state) {
Dave Houltond8ed0212018-05-16 17:18:24 -06003881 skip |= ValidateObjectNotInUse(device_data, *buffer_view_state, *obj_struct, "vkDestroyBufferView",
3882 "VUID-vkDestroyBufferView-bufferView-00936");
Mark Lobodzinski306441e2017-02-10 13:48:38 -07003883 }
3884 return skip;
3885}
3886
John Zulauffca05c12018-04-26 16:30:39 -06003887void PreCallRecordDestroyBufferView(layer_data *device_data, VkBufferView buffer_view, BUFFER_VIEW_STATE *buffer_view_state,
3888 VK_OBJECT obj_struct) {
Mark Lobodzinski306441e2017-02-10 13:48:38 -07003889 // Any bound cmd buffers are now invalid
3890 invalidateCommandBuffers(device_data, buffer_view_state->cb_bindings, obj_struct);
3891 GetBufferViewMap(device_data)->erase(buffer_view);
3892}
Mark Lobodzinskidf0acbf2017-02-10 14:01:27 -07003893
3894bool PreCallValidateCmdFillBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *buffer_state) {
3895 bool skip = false;
Dave Houltond8ed0212018-05-16 17:18:24 -06003896 skip |= ValidateMemoryIsBoundToBuffer(device_data, buffer_state, "vkCmdFillBuffer()", "VUID-vkCmdFillBuffer-dstBuffer-00031");
Mike Schuchardt9c582402017-02-23 15:57:37 -07003897 skip |= ValidateCmdQueueFlags(device_data, cb_node, "vkCmdFillBuffer()",
Dave Houltond8ed0212018-05-16 17:18:24 -06003898 VK_QUEUE_TRANSFER_BIT | VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT,
3899 "VUID-vkCmdFillBuffer-commandBuffer-cmdpool");
Mark Lobodzinskidf0acbf2017-02-10 14:01:27 -07003900 skip |= ValidateCmd(device_data, cb_node, CMD_FILLBUFFER, "vkCmdFillBuffer()");
3901 // Validate that DST buffer has correct usage flags set
Dave Houltond8ed0212018-05-16 17:18:24 -06003902 skip |=
3903 ValidateBufferUsageFlags(device_data, buffer_state, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true,
3904 "VUID-vkCmdFillBuffer-dstBuffer-00029", "vkCmdFillBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
3905 skip |= insideRenderPass(device_data, cb_node, "vkCmdFillBuffer()", "VUID-vkCmdFillBuffer-renderpass");
Mark Lobodzinskidf0acbf2017-02-10 14:01:27 -07003906 return skip;
3907}
3908
3909void PreCallRecordCmdFillBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *buffer_state) {
Mark Lobodzinskidf0acbf2017-02-10 14:01:27 -07003910 // Update bindings between buffer and cmd buffer
3911 AddCommandBufferBindingBuffer(device_data, cb_node, buffer_state);
Mark Lobodzinskidf0acbf2017-02-10 14:01:27 -07003912}
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07003913
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07003914bool ValidateBufferImageCopyData(const debug_report_data *report_data, uint32_t regionCount, const VkBufferImageCopy *pRegions,
3915 IMAGE_STATE *image_state, const char *function) {
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07003916 bool skip = false;
3917
3918 for (uint32_t i = 0; i < regionCount; i++) {
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003919 if (image_state->createInfo.imageType == VK_IMAGE_TYPE_1D) {
3920 if ((pRegions[i].imageOffset.y != 0) || (pRegions[i].imageExtent.height != 1)) {
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07003921 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 -06003922 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-srcImage-00199",
Dave Houltona9df0ce2018-02-07 10:51:23 -07003923 "%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 -06003924 "and 1, respectively.",
3925 function, i, pRegions[i].imageOffset.y, pRegions[i].imageExtent.height);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07003926 }
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003927 }
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07003928
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003929 if ((image_state->createInfo.imageType == VK_IMAGE_TYPE_1D) || (image_state->createInfo.imageType == VK_IMAGE_TYPE_2D)) {
3930 if ((pRegions[i].imageOffset.z != 0) || (pRegions[i].imageExtent.depth != 1)) {
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07003931 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 -06003932 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-srcImage-00201",
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003933 "%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 -06003934 "must be 0 and 1, respectively.",
3935 function, i, pRegions[i].imageOffset.z, pRegions[i].imageExtent.depth);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07003936 }
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003937 }
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07003938
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003939 if (image_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
3940 if ((0 != pRegions[i].imageSubresource.baseArrayLayer) || (1 != pRegions[i].imageSubresource.layerCount)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003941 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 -06003942 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-baseArrayLayer-00213",
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003943 "%s(): pRegion[%d] imageSubresource.baseArrayLayer is %d and imageSubresource.layerCount is %d. "
3944 "For 3D images these must be 0 and 1, respectively.",
3945 function, i, pRegions[i].imageSubresource.baseArrayLayer, pRegions[i].imageSubresource.layerCount);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003946 }
3947 }
3948
3949 // If the the calling command's VkImage parameter's format is not a depth/stencil format,
3950 // then bufferOffset must be a multiple of the calling command's VkImage parameter's texel size
Dave Houlton1d2022c2017-03-29 11:43:58 -06003951 auto texel_size = FormatSize(image_state->createInfo.format);
Dave Houlton1150cf52017-04-27 14:38:11 -06003952 if (!FormatIsDepthAndStencil(image_state->createInfo.format) && SafeModulo(pRegions[i].bufferOffset, texel_size) != 0) {
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003953 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 -06003954 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-bufferOffset-00193",
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003955 "%s(): pRegion[%d] bufferOffset 0x%" PRIxLEAST64
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003956 " must be a multiple of this format's texel size (" PRINTF_SIZE_T_SPECIFIER ").",
3957 function, i, pRegions[i].bufferOffset, texel_size);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003958 }
3959
3960 // BufferOffset must be a multiple of 4
Dave Houlton1d2022c2017-03-29 11:43:58 -06003961 if (SafeModulo(pRegions[i].bufferOffset, 4) != 0) {
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003962 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 -06003963 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-bufferOffset-00194",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003964 "%s(): pRegion[%d] bufferOffset 0x%" PRIxLEAST64 " must be a multiple of 4.", function, i,
3965 pRegions[i].bufferOffset);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003966 }
3967
3968 // BufferRowLength must be 0, or greater than or equal to the width member of imageExtent
3969 if ((pRegions[i].bufferRowLength != 0) && (pRegions[i].bufferRowLength < pRegions[i].imageExtent.width)) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003970 skip |=
3971 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003972 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-bufferRowLength-00195",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003973 "%s(): pRegion[%d] bufferRowLength (%d) must be zero or greater-than-or-equal-to imageExtent.width (%d).",
3974 function, i, pRegions[i].bufferRowLength, pRegions[i].imageExtent.width);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003975 }
3976
3977 // BufferImageHeight must be 0, or greater than or equal to the height member of imageExtent
3978 if ((pRegions[i].bufferImageHeight != 0) && (pRegions[i].bufferImageHeight < pRegions[i].imageExtent.height)) {
3979 skip |= log_msg(
3980 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003981 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-bufferImageHeight-00196",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003982 "%s(): pRegion[%d] bufferImageHeight (%d) must be zero or greater-than-or-equal-to imageExtent.height (%d).",
3983 function, i, pRegions[i].bufferImageHeight, pRegions[i].imageExtent.height);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003984 }
3985
3986 // subresource aspectMask must have exactly 1 bit set
3987 const int num_bits = sizeof(VkFlags) * CHAR_BIT;
3988 std::bitset<num_bits> aspect_mask_bits(pRegions[i].imageSubresource.aspectMask);
3989 if (aspect_mask_bits.count() != 1) {
3990 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 -06003991 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-aspectMask-00212",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003992 "%s: aspectMasks for imageSubresource in each region must have only a single bit set.", function);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003993 }
3994
3995 // image subresource aspect bit must match format
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06003996 if (!VerifyAspectsPresent(pRegions[i].imageSubresource.aspectMask, image_state->createInfo.format)) {
Dave Houlton9dae7ec2017-03-01 16:23:25 -07003997 skip |= log_msg(
3998 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06003999 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-aspectMask-00211",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004000 "%s(): pRegion[%d] subresource aspectMask 0x%x specifies aspects that are not present in image format 0x%x.",
4001 function, i, pRegions[i].imageSubresource.aspectMask, image_state->createInfo.format);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004002 }
4003
4004 // Checks that apply only to compressed images
Cort Stratton420ebd42018-05-04 01:12:23 -04004005 if (FormatIsCompressed(image_state->createInfo.format) || FormatIsSinglePlane_422(image_state->createInfo.format)) {
Dave Houlton1d2022c2017-03-29 11:43:58 -06004006 auto block_size = FormatCompressedTexelBlockExtent(image_state->createInfo.format);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004007
4008 // BufferRowLength must be a multiple of block width
Dave Houlton1d2022c2017-03-29 11:43:58 -06004009 if (SafeModulo(pRegions[i].bufferRowLength, block_size.width) != 0) {
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004010 skip |= log_msg(
4011 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004012 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-bufferRowLength-00203",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004013 "%s(): pRegion[%d] bufferRowLength (%d) must be a multiple of the compressed image's texel width (%d)..",
4014 function, i, pRegions[i].bufferRowLength, block_size.width);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004015 }
4016
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004017 // BufferRowHeight must be a multiple of block height
Dave Houlton1d2022c2017-03-29 11:43:58 -06004018 if (SafeModulo(pRegions[i].bufferImageHeight, block_size.height) != 0) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07004019 skip |= log_msg(
4020 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004021 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-bufferImageHeight-00204",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004022 "%s(): pRegion[%d] bufferImageHeight (%d) must be a multiple of the compressed image's texel height (%d)..",
4023 function, i, pRegions[i].bufferImageHeight, block_size.height);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004024 }
4025
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004026 // image offsets must be multiples of block dimensions
Dave Houlton1d2022c2017-03-29 11:43:58 -06004027 if ((SafeModulo(pRegions[i].imageOffset.x, block_size.width) != 0) ||
4028 (SafeModulo(pRegions[i].imageOffset.y, block_size.height) != 0) ||
4029 (SafeModulo(pRegions[i].imageOffset.z, block_size.depth) != 0)) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004030 skip |=
4031 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004032 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-imageOffset-00205",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004033 "%s(): pRegion[%d] imageOffset(x,y) (%d, %d) must be multiples of the compressed image's texel "
4034 "width & height (%d, %d)..",
4035 function, i, pRegions[i].imageOffset.x, pRegions[i].imageOffset.y, block_size.width, block_size.height);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004036 }
4037
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004038 // bufferOffset must be a multiple of block size (linear bytes)
Dave Houlton1d2022c2017-03-29 11:43:58 -06004039 size_t block_size_in_bytes = FormatSize(image_state->createInfo.format);
4040 if (SafeModulo(pRegions[i].bufferOffset, block_size_in_bytes) != 0) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004041 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 -06004042 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-bufferOffset-00206",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004043 "%s(): pRegion[%d] bufferOffset (0x%" PRIxLEAST64
4044 ") must be a multiple of the compressed image's texel block size (" PRINTF_SIZE_T_SPECIFIER ")..",
4045 function, i, pRegions[i].bufferOffset, block_size_in_bytes);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004046 }
Dave Houlton67e9b532017-03-02 17:00:10 -07004047
4048 // imageExtent width must be a multiple of block width, or extent+offset width must equal subresource width
Dave Houlton75967fc2017-03-06 17:21:16 -07004049 VkExtent3D mip_extent = GetImageSubresourceExtent(image_state, &(pRegions[i].imageSubresource));
Dave Houlton1d2022c2017-03-29 11:43:58 -06004050 if ((SafeModulo(pRegions[i].imageExtent.width, block_size.width) != 0) &&
Dave Houlton75967fc2017-03-06 17:21:16 -07004051 (pRegions[i].imageExtent.width + pRegions[i].imageOffset.x != mip_extent.width)) {
4052 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 -06004053 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-imageExtent-00207",
Dave Houlton75967fc2017-03-06 17:21:16 -07004054 "%s(): pRegion[%d] extent width (%d) must be a multiple of the compressed texture block width "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004055 "(%d), or when added to offset.x (%d) must equal the image subresource width (%d)..",
Dave Houlton75967fc2017-03-06 17:21:16 -07004056 function, i, pRegions[i].imageExtent.width, block_size.width, pRegions[i].imageOffset.x,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004057 mip_extent.width);
Dave Houlton67e9b532017-03-02 17:00:10 -07004058 }
4059
4060 // imageExtent height must be a multiple of block height, or extent+offset height must equal subresource height
Dave Houlton1d2022c2017-03-29 11:43:58 -06004061 if ((SafeModulo(pRegions[i].imageExtent.height, block_size.height) != 0) &&
Dave Houlton75967fc2017-03-06 17:21:16 -07004062 (pRegions[i].imageExtent.height + pRegions[i].imageOffset.y != mip_extent.height)) {
4063 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 -06004064 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-imageExtent-00208",
Dave Houlton75967fc2017-03-06 17:21:16 -07004065 "%s(): pRegion[%d] extent height (%d) must be a multiple of the compressed texture block height "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004066 "(%d), or when added to offset.y (%d) must equal the image subresource height (%d)..",
Dave Houlton75967fc2017-03-06 17:21:16 -07004067 function, i, pRegions[i].imageExtent.height, block_size.height, pRegions[i].imageOffset.y,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004068 mip_extent.height);
Dave Houlton67e9b532017-03-02 17:00:10 -07004069 }
4070
4071 // imageExtent depth must be a multiple of block depth, or extent+offset depth must equal subresource depth
Dave Houlton1d2022c2017-03-29 11:43:58 -06004072 if ((SafeModulo(pRegions[i].imageExtent.depth, block_size.depth) != 0) &&
Dave Houlton75967fc2017-03-06 17:21:16 -07004073 (pRegions[i].imageExtent.depth + pRegions[i].imageOffset.z != mip_extent.depth)) {
4074 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 -06004075 HandleToUint64(image_state->image), "VUID-VkBufferImageCopy-imageExtent-00209",
Dave Houlton75967fc2017-03-06 17:21:16 -07004076 "%s(): pRegion[%d] extent width (%d) must be a multiple of the compressed texture block depth "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004077 "(%d), or when added to offset.z (%d) must equal the image subresource depth (%d)..",
Dave Houlton75967fc2017-03-06 17:21:16 -07004078 function, i, pRegions[i].imageExtent.depth, block_size.depth, pRegions[i].imageOffset.z,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004079 mip_extent.depth);
Dave Houlton67e9b532017-03-02 17:00:10 -07004080 }
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004081 }
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004082 }
4083
4084 return skip;
4085}
4086
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004087static bool ValidateImageBounds(const debug_report_data *report_data, const IMAGE_STATE *image_state, const uint32_t regionCount,
Dave Houltond8ed0212018-05-16 17:18:24 -06004088 const VkBufferImageCopy *pRegions, const char *func_name, std::string msg_code) {
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004089 bool skip = false;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004090 const VkImageCreateInfo *image_info = &(image_state->createInfo);
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004091
4092 for (uint32_t i = 0; i < regionCount; i++) {
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004093 VkExtent3D extent = pRegions[i].imageExtent;
4094 VkOffset3D offset = pRegions[i].imageOffset;
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004095
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004096 if (IsExtentSizeZero(&extent)) // Warn on zero area subresource
4097 {
Mark Lobodzinski88529492018-04-01 10:38:15 -06004098 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
4099 (uint64_t)0, IMAGE_ZERO_AREA_SUBREGION, "%s: pRegion[%d] imageExtent of {%1d, %1d, %1d} has zero area",
4100 func_name, i, extent.width, extent.height, extent.depth);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004101 }
4102
4103 VkExtent3D image_extent = GetImageSubresourceExtent(image_state, &(pRegions[i].imageSubresource));
4104
4105 // 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 -06004106 if (FormatIsCompressed(image_info->format)) {
4107 auto block_extent = FormatCompressedTexelBlockExtent(image_info->format);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004108 if (image_extent.width % block_extent.width) {
4109 image_extent.width += (block_extent.width - (image_extent.width % block_extent.width));
4110 }
4111 if (image_extent.height % block_extent.height) {
4112 image_extent.height += (block_extent.height - (image_extent.height % block_extent.height));
4113 }
4114 if (image_extent.depth % block_extent.depth) {
4115 image_extent.depth += (block_extent.depth - (image_extent.depth % block_extent.depth));
4116 }
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004117 }
4118
Dave Houltonfc1a4052017-04-27 14:32:45 -06004119 if (0 != ExceedsBounds(&offset, &extent, &image_extent)) {
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004120 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 -06004121 msg_code, "%s: pRegion[%d] exceeds image bounds..", func_name, i);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004122 }
4123 }
4124
4125 return skip;
4126}
4127
Chris Forbese8ba09a2017-06-01 17:39:02 -07004128static inline bool ValidateBufferBounds(const debug_report_data *report_data, IMAGE_STATE *image_state, BUFFER_STATE *buff_state,
Dave Houlton33c2d252017-06-09 17:08:32 -06004129 uint32_t regionCount, const VkBufferImageCopy *pRegions, const char *func_name,
Dave Houltond8ed0212018-05-16 17:18:24 -06004130 std::string msg_code) {
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004131 bool skip = false;
4132
4133 VkDeviceSize buffer_size = buff_state->createInfo.size;
4134
4135 for (uint32_t i = 0; i < regionCount; i++) {
4136 VkExtent3D copy_extent = pRegions[i].imageExtent;
4137
4138 VkDeviceSize buffer_width = (0 == pRegions[i].bufferRowLength ? copy_extent.width : pRegions[i].bufferRowLength);
4139 VkDeviceSize buffer_height = (0 == pRegions[i].bufferImageHeight ? copy_extent.height : pRegions[i].bufferImageHeight);
Dave Houlton1d2022c2017-03-29 11:43:58 -06004140 VkDeviceSize unit_size = FormatSize(image_state->createInfo.format); // size (bytes) of texel or block
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004141
Dave Houltonf3229d52017-02-21 15:59:08 -07004142 // Handle special buffer packing rules for specific depth/stencil formats
4143 if (pRegions[i].imageSubresource.aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) {
Dave Houlton1d2022c2017-03-29 11:43:58 -06004144 unit_size = FormatSize(VK_FORMAT_S8_UINT);
Dave Houltonf3229d52017-02-21 15:59:08 -07004145 } else if (pRegions[i].imageSubresource.aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) {
4146 switch (image_state->createInfo.format) {
4147 case VK_FORMAT_D16_UNORM_S8_UINT:
Dave Houlton1d2022c2017-03-29 11:43:58 -06004148 unit_size = FormatSize(VK_FORMAT_D16_UNORM);
Dave Houltonf3229d52017-02-21 15:59:08 -07004149 break;
4150 case VK_FORMAT_D32_SFLOAT_S8_UINT:
Dave Houlton1d2022c2017-03-29 11:43:58 -06004151 unit_size = FormatSize(VK_FORMAT_D32_SFLOAT);
Dave Houltonf3229d52017-02-21 15:59:08 -07004152 break;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004153 case VK_FORMAT_X8_D24_UNORM_PACK32: // Fall through
Dave Houltonf3229d52017-02-21 15:59:08 -07004154 case VK_FORMAT_D24_UNORM_S8_UINT:
4155 unit_size = 4;
4156 break;
4157 default:
4158 break;
4159 }
4160 }
4161
Dave Houlton1d2022c2017-03-29 11:43:58 -06004162 if (FormatIsCompressed(image_state->createInfo.format)) {
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004163 // Switch to texel block units, rounding up for any partially-used blocks
Dave Houlton1d2022c2017-03-29 11:43:58 -06004164 auto block_dim = FormatCompressedTexelBlockExtent(image_state->createInfo.format);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004165 buffer_width = (buffer_width + block_dim.width - 1) / block_dim.width;
4166 buffer_height = (buffer_height + block_dim.height - 1) / block_dim.height;
4167
4168 copy_extent.width = (copy_extent.width + block_dim.width - 1) / block_dim.width;
4169 copy_extent.height = (copy_extent.height + block_dim.height - 1) / block_dim.height;
4170 copy_extent.depth = (copy_extent.depth + block_dim.depth - 1) / block_dim.depth;
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004171 }
4172
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004173 // Either depth or layerCount may be greater than 1 (not both). This is the number of 'slices' to copy
4174 uint32_t z_copies = std::max(copy_extent.depth, pRegions[i].imageSubresource.layerCount);
4175 if (IsExtentSizeZero(&copy_extent) || (0 == z_copies)) {
Chris Forbese8ba09a2017-06-01 17:39:02 -07004176 // TODO: Issue warning here? Already warned in ValidateImageBounds()...
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004177 } else {
4178 // Calculate buffer offset of final copied byte, + 1.
4179 VkDeviceSize max_buffer_offset = (z_copies - 1) * buffer_height * buffer_width; // offset to slice
4180 max_buffer_offset += ((copy_extent.height - 1) * buffer_width) + copy_extent.width; // add row,col
4181 max_buffer_offset *= unit_size; // convert to bytes
4182 max_buffer_offset += pRegions[i].bufferOffset; // add initial offset (bytes)
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004183
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004184 if (buffer_size < max_buffer_offset) {
Mark Lobodzinski88529492018-04-01 10:38:15 -06004185 skip |=
4186 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)0,
4187 msg_code, "%s: pRegion[%d] exceeds buffer size of %" PRIu64 " bytes..", func_name, i, buffer_size);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004188 }
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004189 }
4190 }
4191
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004192 return skip;
4193}
4194
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004195bool PreCallValidateCmdCopyImageToBuffer(layer_data *device_data, VkImageLayout srcImageLayout, GLOBAL_CB_NODE *cb_node,
Mark Lobodzinski1fe9b002017-02-15 14:11:12 -07004196 IMAGE_STATE *src_image_state, BUFFER_STATE *dst_buffer_state, uint32_t regionCount,
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004197 const VkBufferImageCopy *pRegions, const char *func_name) {
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004198 const debug_report_data *report_data = core_validation::GetReportData(device_data);
4199 bool skip = ValidateBufferImageCopyData(report_data, regionCount, pRegions, src_image_state, "vkCmdCopyImageToBuffer");
4200
4201 // Validate command buffer state
John Zulauf5c2750c2018-01-30 15:04:56 -07004202 skip |= ValidateCmd(device_data, cb_node, CMD_COPYIMAGETOBUFFER, "vkCmdCopyImageToBuffer()");
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004203
4204 // Command pool must support graphics, compute, or transfer operations
4205 auto pPool = GetCommandPoolNode(device_data, cb_node->createInfo.commandPool);
4206
4207 VkQueueFlags queue_flags = GetPhysDevProperties(device_data)->queue_family_properties[pPool->queueFamilyIndex].queueFlags;
4208 if (0 == (queue_flags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT))) {
4209 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 -06004210 HandleToUint64(cb_node->createInfo.commandPool), "VUID-vkCmdCopyImageToBuffer-commandBuffer-cmdpool",
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004211 "Cannot call vkCmdCopyImageToBuffer() on a command buffer allocated from a pool without graphics, compute, "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004212 "or transfer capabilities..");
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004213 }
Dave Houlton0ef27492018-04-04 11:41:48 -06004214 skip |= ValidateImageBounds(report_data, src_image_state, regionCount, pRegions, "vkCmdCopyImageToBuffer()",
Dave Houltond8ed0212018-05-16 17:18:24 -06004215 "VUID-vkCmdCopyImageToBuffer-pRegions-00182");
Chris Forbese8ba09a2017-06-01 17:39:02 -07004216 skip |= ValidateBufferBounds(report_data, src_image_state, dst_buffer_state, regionCount, pRegions, "vkCmdCopyImageToBuffer()",
Dave Houltond8ed0212018-05-16 17:18:24 -06004217 "VUID-vkCmdCopyImageToBuffer-pRegions-00183");
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004218
4219 skip |= ValidateImageSampleCount(device_data, src_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdCopyImageToBuffer(): srcImage",
Dave Houltond8ed0212018-05-16 17:18:24 -06004220 "VUID-vkCmdCopyImageToBuffer-srcImage-00188");
4221 skip |= ValidateMemoryIsBoundToImage(device_data, src_image_state, "vkCmdCopyImageToBuffer()",
4222 "VUID-vkCmdCopyImageToBuffer-srcImage-00187");
4223 skip |= ValidateMemoryIsBoundToBuffer(device_data, dst_buffer_state, "vkCmdCopyImageToBuffer()",
4224 "VUID-vkCmdCopyImageToBuffer-dstBuffer-00192");
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07004225
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004226 // Validate that SRC image & DST buffer have correct usage flags set
Dave Houltond8ed0212018-05-16 17:18:24 -06004227 skip |= ValidateImageUsageFlags(device_data, src_image_state, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true,
4228 "VUID-vkCmdCopyImageToBuffer-srcImage-00186", "vkCmdCopyImageToBuffer()",
4229 "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
Tobin Ehlis3c37fb32017-05-24 09:31:13 -06004230 skip |= ValidateBufferUsageFlags(device_data, dst_buffer_state, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true,
Dave Houltond8ed0212018-05-16 17:18:24 -06004231 "VUID-vkCmdCopyImageToBuffer-dstBuffer-00191", "vkCmdCopyImageToBuffer()",
4232 "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
Cort Stratton186b1a22018-05-01 20:18:06 -04004233 if (GetApiVersion(device_data) >= VK_API_VERSION_1_1 || GetDeviceExtensions(device_data)->vk_khr_maintenance1) {
4234 skip |= ValidateImageFormatFeatureFlags(device_data, src_image_state, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004235 "vkCmdCopyImageToBuffer()", "VUID-vkCmdCopyImageToBuffer-srcImage-00185",
4236 "VUID-vkCmdCopyImageToBuffer-srcImage-00185");
Cort Stratton186b1a22018-05-01 20:18:06 -04004237 }
Dave Houltond8ed0212018-05-16 17:18:24 -06004238 skip |= insideRenderPass(device_data, cb_node, "vkCmdCopyImageToBuffer()", "VUID-vkCmdCopyImageToBuffer-renderpass");
Tobin Ehlisc8266452017-04-07 12:20:30 -06004239 bool hit_error = false;
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07004240 for (uint32_t i = 0; i < regionCount; ++i) {
Tobin Ehlis3c37fb32017-05-24 09:31:13 -06004241 skip |= VerifyImageLayout(device_data, cb_node, src_image_state, pRegions[i].imageSubresource, srcImageLayout,
Dave Houltond8ed0212018-05-16 17:18:24 -06004242 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, "vkCmdCopyImageToBuffer()",
4243 "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00190", &hit_error);
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07004244 skip |= ValidateCopyBufferImageTransferGranularityRequirements(device_data, cb_node, src_image_state, &pRegions[i], i,
Dave Houltond8ed0212018-05-16 17:18:24 -06004245 "vkCmdCopyImageToBuffer()",
4246 "VUID-vkCmdCopyImageToBuffer-imageOffset-01794");
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07004247 }
4248 return skip;
4249}
4250
4251void PreCallRecordCmdCopyImageToBuffer(layer_data *device_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *src_image_state,
Tobin Ehlise35b66a2017-03-15 12:18:31 -06004252 BUFFER_STATE *dst_buffer_state, uint32_t region_count, const VkBufferImageCopy *regions,
4253 VkImageLayout src_image_layout) {
4254 // Make sure that all image slices are updated to correct layout
4255 for (uint32_t i = 0; i < region_count; ++i) {
4256 SetImageLayout(device_data, cb_node, src_image_state, regions[i].imageSubresource, src_image_layout);
4257 }
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07004258 // Update bindings between buffer/image and cmd buffer
4259 AddCommandBufferBindingImage(device_data, cb_node, src_image_state);
Mark Lobodzinski1fe9b002017-02-15 14:11:12 -07004260 AddCommandBufferBindingBuffer(device_data, cb_node, dst_buffer_state);
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004261}
4262
4263bool PreCallValidateCmdCopyBufferToImage(layer_data *device_data, VkImageLayout dstImageLayout, GLOBAL_CB_NODE *cb_node,
Mark Lobodzinski1fe9b002017-02-15 14:11:12 -07004264 BUFFER_STATE *src_buffer_state, IMAGE_STATE *dst_image_state, uint32_t regionCount,
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004265 const VkBufferImageCopy *pRegions, const char *func_name) {
4266 const debug_report_data *report_data = core_validation::GetReportData(device_data);
4267 bool skip = ValidateBufferImageCopyData(report_data, regionCount, pRegions, dst_image_state, "vkCmdCopyBufferToImage");
4268
4269 // Validate command buffer state
John Zulauf5c2750c2018-01-30 15:04:56 -07004270 skip |= ValidateCmd(device_data, cb_node, CMD_COPYBUFFERTOIMAGE, "vkCmdCopyBufferToImage()");
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004271
4272 // Command pool must support graphics, compute, or transfer operations
4273 auto pPool = GetCommandPoolNode(device_data, cb_node->createInfo.commandPool);
4274 VkQueueFlags queue_flags = GetPhysDevProperties(device_data)->queue_family_properties[pPool->queueFamilyIndex].queueFlags;
4275 if (0 == (queue_flags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT))) {
4276 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 -06004277 HandleToUint64(cb_node->createInfo.commandPool), "VUID-vkCmdCopyBufferToImage-commandBuffer-cmdpool",
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004278 "Cannot call vkCmdCopyBufferToImage() on a command buffer allocated from a pool without graphics, compute, "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004279 "or transfer capabilities..");
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004280 }
Dave Houlton9dae7ec2017-03-01 16:23:25 -07004281 skip |= ValidateImageBounds(report_data, dst_image_state, regionCount, pRegions, "vkCmdCopyBufferToImage()",
Dave Houltond8ed0212018-05-16 17:18:24 -06004282 "VUID-vkCmdCopyBufferToImage-pRegions-00172");
Chris Forbese8ba09a2017-06-01 17:39:02 -07004283 skip |= ValidateBufferBounds(report_data, dst_image_state, src_buffer_state, regionCount, pRegions, "vkCmdCopyBufferToImage()",
Dave Houltond8ed0212018-05-16 17:18:24 -06004284 "VUID-vkCmdCopyBufferToImage-pRegions-00171");
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07004285 skip |= ValidateImageSampleCount(device_data, dst_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdCopyBufferToImage(): dstImage",
Dave Houltond8ed0212018-05-16 17:18:24 -06004286 "VUID-vkCmdCopyBufferToImage-dstImage-00179");
4287 skip |= ValidateMemoryIsBoundToBuffer(device_data, src_buffer_state, "vkCmdCopyBufferToImage()",
4288 "VUID-vkCmdCopyBufferToImage-srcBuffer-00176");
4289 skip |= ValidateMemoryIsBoundToImage(device_data, dst_image_state, "vkCmdCopyBufferToImage()",
4290 "VUID-vkCmdCopyBufferToImage-dstImage-00178");
Tobin Ehlis3c37fb32017-05-24 09:31:13 -06004291 skip |= ValidateBufferUsageFlags(device_data, src_buffer_state, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true,
Dave Houltond8ed0212018-05-16 17:18:24 -06004292 "VUID-vkCmdCopyBufferToImage-srcBuffer-00174", "vkCmdCopyBufferToImage()",
4293 "VK_BUFFER_USAGE_TRANSFER_SRC_BIT");
4294 skip |= ValidateImageUsageFlags(device_data, dst_image_state, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true,
4295 "VUID-vkCmdCopyBufferToImage-dstImage-00177", "vkCmdCopyBufferToImage()",
4296 "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
Cort Stratton186b1a22018-05-01 20:18:06 -04004297 if (GetApiVersion(device_data) >= VK_API_VERSION_1_1 || GetDeviceExtensions(device_data)->vk_khr_maintenance1) {
4298 skip |= ValidateImageFormatFeatureFlags(device_data, dst_image_state, VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
Dave Houltond8ed0212018-05-16 17:18:24 -06004299 "vkCmdCopyBufferToImage()", "VUID-vkCmdCopyBufferToImage-dstImage-00175",
4300 "VUID-vkCmdCopyBufferToImage-dstImage-00175");
Cort Stratton186b1a22018-05-01 20:18:06 -04004301 }
Dave Houltond8ed0212018-05-16 17:18:24 -06004302 skip |= insideRenderPass(device_data, cb_node, "vkCmdCopyBufferToImage()", "VUID-vkCmdCopyBufferToImage-renderpass");
Tobin Ehlisc8266452017-04-07 12:20:30 -06004303 bool hit_error = false;
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07004304 for (uint32_t i = 0; i < regionCount; ++i) {
Tobin Ehlis3c37fb32017-05-24 09:31:13 -06004305 skip |= VerifyImageLayout(device_data, cb_node, dst_image_state, pRegions[i].imageSubresource, dstImageLayout,
Dave Houltond8ed0212018-05-16 17:18:24 -06004306 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, "vkCmdCopyBufferToImage()",
4307 "VUID-vkCmdCopyBufferToImage-dstImageLayout-00181", &hit_error);
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07004308 skip |= ValidateCopyBufferImageTransferGranularityRequirements(device_data, cb_node, dst_image_state, &pRegions[i], i,
Dave Houltond8ed0212018-05-16 17:18:24 -06004309 "vkCmdCopyBufferToImage()",
4310 "VUID-vkCmdCopyBufferToImage-imageOffset-01793");
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07004311 }
4312 return skip;
4313}
4314
Mark Lobodzinski1fe9b002017-02-15 14:11:12 -07004315void PreCallRecordCmdCopyBufferToImage(layer_data *device_data, GLOBAL_CB_NODE *cb_node, BUFFER_STATE *src_buffer_state,
Tobin Ehlise35b66a2017-03-15 12:18:31 -06004316 IMAGE_STATE *dst_image_state, uint32_t region_count, const VkBufferImageCopy *regions,
4317 VkImageLayout dst_image_layout) {
4318 // Make sure that all image slices are updated to correct layout
4319 for (uint32_t i = 0; i < region_count; ++i) {
4320 SetImageLayout(device_data, cb_node, dst_image_state, regions[i].imageSubresource, dst_image_layout);
4321 }
Mark Lobodzinski1fe9b002017-02-15 14:11:12 -07004322 AddCommandBufferBindingBuffer(device_data, cb_node, src_buffer_state);
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07004323 AddCommandBufferBindingImage(device_data, cb_node, dst_image_state);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07004324}
Mike Weiblen672b58b2017-02-21 14:32:53 -07004325
4326bool PreCallValidateGetImageSubresourceLayout(layer_data *device_data, VkImage image, const VkImageSubresource *pSubresource) {
4327 const auto report_data = core_validation::GetReportData(device_data);
4328 bool skip = false;
4329 const VkImageAspectFlags sub_aspect = pSubresource->aspectMask;
4330
Dave Houlton1d960ff2018-01-19 12:17:05 -07004331 // The aspectMask member of pSubresource must only have a single bit set
Mike Weiblen672b58b2017-02-21 14:32:53 -07004332 const int num_bits = sizeof(sub_aspect) * CHAR_BIT;
4333 std::bitset<num_bits> aspect_mask_bits(sub_aspect);
4334 if (aspect_mask_bits.count() != 1) {
Petr Krausbc7f5442017-05-14 23:43:38 +02004335 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 -06004336 "VUID-vkGetImageSubresourceLayout-aspectMask-00997",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004337 "vkGetImageSubresourceLayout(): VkImageSubresource.aspectMask must have exactly 1 bit set.");
Mike Weiblen672b58b2017-02-21 14:32:53 -07004338 }
4339
4340 IMAGE_STATE *image_entry = GetImageState(device_data, image);
4341 if (!image_entry) {
4342 return skip;
4343 }
4344
Dave Houlton1d960ff2018-01-19 12:17:05 -07004345 // image must have been created with tiling equal to VK_IMAGE_TILING_LINEAR
Mike Weiblen672b58b2017-02-21 14:32:53 -07004346 if (image_entry->createInfo.tiling != VK_IMAGE_TILING_LINEAR) {
Dave Houltond8ed0212018-05-16 17:18:24 -06004347 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image),
4348 "VUID-vkGetImageSubresourceLayout-image-00996",
4349 "vkGetImageSubresourceLayout(): Image must have tiling of VK_IMAGE_TILING_LINEAR.");
Mike Weiblen672b58b2017-02-21 14:32:53 -07004350 }
4351
Dave Houlton1d960ff2018-01-19 12:17:05 -07004352 // mipLevel must be less than the mipLevels specified in VkImageCreateInfo when the image was created
Mike Weiblen672b58b2017-02-21 14:32:53 -07004353 if (pSubresource->mipLevel >= image_entry->createInfo.mipLevels) {
Dave Houltond8ed0212018-05-16 17:18:24 -06004354 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image),
4355 "VUID-vkGetImageSubresourceLayout-mipLevel-01716",
4356 "vkGetImageSubresourceLayout(): pSubresource.mipLevel (%d) must be less than %d.", pSubresource->mipLevel,
4357 image_entry->createInfo.mipLevels);
Mike Weiblen672b58b2017-02-21 14:32:53 -07004358 }
4359
Dave Houlton1d960ff2018-01-19 12:17:05 -07004360 // arrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when the image was created
Mike Weiblen672b58b2017-02-21 14:32:53 -07004361 if (pSubresource->arrayLayer >= image_entry->createInfo.arrayLayers) {
Dave Houltond8ed0212018-05-16 17:18:24 -06004362 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image),
4363 "VUID-vkGetImageSubresourceLayout-arrayLayer-01717",
4364 "vkGetImageSubresourceLayout(): pSubresource.arrayLayer (%d) must be less than %d.",
4365 pSubresource->arrayLayer, image_entry->createInfo.arrayLayers);
Mike Weiblen672b58b2017-02-21 14:32:53 -07004366 }
4367
Dave Houlton1d960ff2018-01-19 12:17:05 -07004368 // subresource's aspect must be compatible with image's format.
Mike Weiblen672b58b2017-02-21 14:32:53 -07004369 const VkFormat img_format = image_entry->createInfo.format;
Dave Houlton1d960ff2018-01-19 12:17:05 -07004370 if (FormatIsMultiplane(img_format)) {
4371 VkImageAspectFlags allowed_flags = (VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR);
Dave Houltond8ed0212018-05-16 17:18:24 -06004372 std::string vuid = "VUID-vkGetImageSubresourceLayout-format-01581"; // 2-plane version
Dave Houlton1d960ff2018-01-19 12:17:05 -07004373 if (FormatPlaneCount(img_format) > 2u) {
4374 allowed_flags |= VK_IMAGE_ASPECT_PLANE_2_BIT_KHR;
Dave Houltond8ed0212018-05-16 17:18:24 -06004375 vuid = "VUID-vkGetImageSubresourceLayout-format-01582"; // 3-plane version
Dave Houlton1d960ff2018-01-19 12:17:05 -07004376 }
4377 if (sub_aspect != (sub_aspect & allowed_flags)) {
4378 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 -06004379 HandleToUint64(image), vuid,
Dave Houlton1d960ff2018-01-19 12:17:05 -07004380 "vkGetImageSubresourceLayout(): For multi-planar images, VkImageSubresource.aspectMask (0x%" PRIx32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004381 ") must be a single-plane specifier flag.",
4382 sub_aspect);
Dave Houlton1d960ff2018-01-19 12:17:05 -07004383 }
4384 } else if (FormatIsColor(img_format)) {
Mike Weiblen672b58b2017-02-21 14:32:53 -07004385 if (sub_aspect != VK_IMAGE_ASPECT_COLOR_BIT) {
Dave Houlton852287e2018-01-19 15:11:51 -07004386 skip |= log_msg(
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06004387 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image),
Dave Houltond8ed0212018-05-16 17:18:24 -06004388 "VUID-VkImageSubresource-aspectMask-parameter",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004389 "vkGetImageSubresourceLayout(): For color formats, VkImageSubresource.aspectMask must be VK_IMAGE_ASPECT_COLOR.");
Mike Weiblen672b58b2017-02-21 14:32:53 -07004390 }
Dave Houlton1d2022c2017-03-29 11:43:58 -06004391 } else if (FormatIsDepthOrStencil(img_format)) {
Mike Weiblen672b58b2017-02-21 14:32:53 -07004392 if ((sub_aspect != VK_IMAGE_ASPECT_DEPTH_BIT) && (sub_aspect != VK_IMAGE_ASPECT_STENCIL_BIT)) {
Mark Lobodzinski0827aec2017-03-21 16:41:45 -06004393 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 -06004394 HandleToUint64(image), "VUID-VkImageSubresource-aspectMask-parameter",
Mike Weiblen672b58b2017-02-21 14:32:53 -07004395 "vkGetImageSubresourceLayout(): For depth/stencil formats, VkImageSubresource.aspectMask must be "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06004396 "either VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT.");
Mike Weiblen672b58b2017-02-21 14:32:53 -07004397 }
4398 }
4399 return skip;
4400}