blob: 74d533ff9e8fef01615403cb5a12870ab3b85487 [file] [log] [blame]
Jeremy Gebben65975ed2021-10-29 11:16:10 -06001/* Copyright (c) 2015-2022 The Khronos Group Inc.
2 * Copyright (c) 2015-2022 Valve Corporation
3 * Copyright (c) 2015-2022 LunarG, Inc.
4 * Copyright (C) 2015-2022 Google Inc.
Aaron Hagan1656b2b2021-12-21 11:52:41 -05005 * Modifications Copyright (C) 2020-2022 Advanced Micro Devices, Inc. All rights reserved.
Mark Lobodzinskid42e4d22017-01-17 14:14:22 -07006 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 * Author: Mark Lobodzinski <mark@lunarg.com>
Dave Houlton4eaaf3a2017-03-14 11:31:20 -060020 * Author: Dave Houlton <daveh@lunarg.com>
Shannon McPherson3ea65132018-12-05 10:37:39 -070021 * Shannon McPherson <shannon@lunarg.com>
Tobias Hector6663c9b2020-11-05 10:18:02 +000022 * Author: Tobias Hector <tobias.hector@amd.com>
Mark Lobodzinskid42e4d22017-01-17 14:14:22 -070023 */
24
Dave Houlton0d4ad6f2018-09-05 14:53:34 -060025#include <cmath>
26#include <set>
Mark Lobodzinski90224de2017-01-26 15:23:11 -070027#include <sstream>
Petr Kraus4d718682017-05-18 03:38:41 +020028#include <string>
Jeremy Gebben579aaca2021-02-15 13:36:18 -070029#include <iostream>
Mark Lobodzinski90224de2017-01-26 15:23:11 -070030
31#include "vk_enum_string_helper.h"
Petr Kraus5a01b472019-08-10 01:40:28 +020032#include "vk_format_utils.h"
Mark Lobodzinski90224de2017-01-26 15:23:11 -070033#include "vk_layer_data.h"
34#include "vk_layer_utils.h"
35#include "vk_layer_logging.h"
Dave Houltonbd2e2622018-04-10 16:41:14 -060036#include "vk_typemap_helper.h"
Mark Lobodzinski90224de2017-01-26 15:23:11 -070037
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -070038#include "chassis.h"
Mark Lobodzinski76d76662019-02-14 14:38:21 -070039#include "core_validation.h"
Jeremy Gebbene60d4172021-02-02 15:42:15 -070040#include "core_error_location.h"
Mark Lobodzinski76d76662019-02-14 14:38:21 -070041#include "shader_validation.h"
42#include "descriptor_sets.h"
Mark Lobodzinskid42e4d22017-01-17 14:14:22 -070043#include "buffer_validation.h"
Jeremy Gebben7ba56152021-06-18 10:40:10 -060044#include "sync_utils.h"
Jeremy Gebbene60d4172021-02-02 15:42:15 -070045#include "sync_vuid_maps.h"
Mark Lobodzinski42fe5f72017-01-11 11:36:16 -070046
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -060047using LayoutEntry = image_layout_map::ImageSubresourceLayoutMap::LayoutEntry;
48
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070049// All VUID from copy_bufferimage_to_imagebuffer_common.txt
sfricke-samsung2e5b16c2020-10-31 22:14:15 -070050static const char *GetBufferImageCopyCommandVUID(std::string id, bool image_to_buffer, bool copy2) {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070051 // clang-format off
sfricke-samsung2e5b16c2020-10-31 22:14:15 -070052 static const std::map<std::string, std::array<const char *, 4>> copy_imagebuffer_vuid = {
53 {"00193", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070054 "VUID-vkCmdCopyBufferToImage-bufferOffset-00193", // !copy2 & !image_to_buffer
55 "VUID-vkCmdCopyImageToBuffer-bufferOffset-00193", // !copy2 & image_to_buffer
Tony Barbour845d29b2021-11-09 11:43:14 -070056 "VUID-VkCopyBufferToImageInfo2-bufferOffset-00193", // copy2 & !image_to_buffer
Tony-LunarGaf3632a2021-11-10 15:51:57 -070057 "VUID-VkCopyImageToBufferInfo2-bufferOffset-00193", // copy2 & image_to_buffer
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070058 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -070059 {"01558", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070060 "VUID-vkCmdCopyBufferToImage-bufferOffset-01558",
61 "VUID-vkCmdCopyImageToBuffer-bufferOffset-01558",
Tony Barbour845d29b2021-11-09 11:43:14 -070062 "VUID-VkCopyBufferToImageInfo2-bufferOffset-01558",
Tony-LunarGaf3632a2021-11-10 15:51:57 -070063 "VUID-VkCopyImageToBufferInfo2-bufferOffset-01558",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070064 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -070065 {"01559", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070066 "VUID-vkCmdCopyBufferToImage-bufferOffset-01559",
67 "VUID-vkCmdCopyImageToBuffer-bufferOffset-01559",
Tony Barbour845d29b2021-11-09 11:43:14 -070068 "VUID-VkCopyBufferToImageInfo2-bufferOffset-01559",
Tony-LunarGaf3632a2021-11-10 15:51:57 -070069 "VUID-VkCopyImageToBufferInfo2-bufferOffset-01559",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070070 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -070071 {"00197", {
Mike Schuchardt7b152fa2021-08-03 16:30:27 -070072 "VUID-vkCmdCopyBufferToImage-pRegions-06218",
73 "VUID-vkCmdCopyImageToBuffer-pRegions-06221",
Tony Barbour845d29b2021-11-09 11:43:14 -070074 "VUID-VkCopyBufferToImageInfo2-pRegions-06223",
Tony-LunarGaf3632a2021-11-10 15:51:57 -070075 "VUID-VkCopyImageToBufferInfo2-imageOffset-00197",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070076 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -070077 {"00198", {
Mike Schuchardt7b152fa2021-08-03 16:30:27 -070078 "VUID-vkCmdCopyBufferToImage-pRegions-06219",
79 "VUID-vkCmdCopyImageToBuffer-pRegions-06222",
Tony Barbour845d29b2021-11-09 11:43:14 -070080 "VUID-VkCopyBufferToImageInfo2-pRegions-06224",
Tony-LunarGaf3632a2021-11-10 15:51:57 -070081 "VUID-VkCopyImageToBufferInfo2-imageOffset-00198",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070082 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -070083 {"00199", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070084 "VUID-vkCmdCopyBufferToImage-srcImage-00199",
85 "VUID-vkCmdCopyImageToBuffer-srcImage-00199",
Tony Barbour845d29b2021-11-09 11:43:14 -070086 "VUID-VkCopyBufferToImageInfo2-srcImage-00199",
Tony-LunarGaf3632a2021-11-10 15:51:57 -070087 "VUID-VkCopyImageToBufferInfo2-srcImage-00199",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070088 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -070089 {"00200", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070090 "VUID-vkCmdCopyBufferToImage-imageOffset-00200",
91 "VUID-vkCmdCopyImageToBuffer-imageOffset-00200",
Tony Barbour845d29b2021-11-09 11:43:14 -070092 "VUID-VkCopyBufferToImageInfo2-imageOffset-00200",
Tony-LunarGaf3632a2021-11-10 15:51:57 -070093 "VUID-VkCopyImageToBufferInfo2-imageOffset-00200",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070094 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -070095 {"00201", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -070096 "VUID-vkCmdCopyBufferToImage-srcImage-00201",
97 "VUID-vkCmdCopyImageToBuffer-srcImage-00201",
Tony Barbour845d29b2021-11-09 11:43:14 -070098 "VUID-VkCopyBufferToImageInfo2-srcImage-00201",
Tony-LunarGaf3632a2021-11-10 15:51:57 -070099 "VUID-VkCopyImageToBufferInfo2-srcImage-00201",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700100 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -0700101 {"00203", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700102 "VUID-vkCmdCopyBufferToImage-bufferRowLength-00203",
103 "VUID-vkCmdCopyImageToBuffer-bufferRowLength-00203",
Tony Barbour845d29b2021-11-09 11:43:14 -0700104 "VUID-VkCopyBufferToImageInfo2-bufferRowLength-00203",
Tony-LunarGaf3632a2021-11-10 15:51:57 -0700105 "VUID-VkCopyImageToBufferInfo2-bufferRowLength-00203",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700106 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -0700107 {"00204", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700108 "VUID-vkCmdCopyBufferToImage-bufferImageHeight-00204",
109 "VUID-vkCmdCopyImageToBuffer-bufferImageHeight-00204",
Tony Barbour845d29b2021-11-09 11:43:14 -0700110 "VUID-VkCopyBufferToImageInfo2-bufferImageHeight-00204",
Tony-LunarGaf3632a2021-11-10 15:51:57 -0700111 "VUID-VkCopyImageToBufferInfo2-bufferImageHeight-00204",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700112 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -0700113 {"00205", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700114 "VUID-vkCmdCopyBufferToImage-imageOffset-00205",
115 "VUID-vkCmdCopyImageToBuffer-imageOffset-00205",
Tony Barbour845d29b2021-11-09 11:43:14 -0700116 "VUID-VkCopyBufferToImageInfo2-imageOffset-00205",
Tony-LunarGaf3632a2021-11-10 15:51:57 -0700117 "VUID-VkCopyImageToBufferInfo2-imageOffset-00205",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700118 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -0700119 {"00206", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700120 "VUID-vkCmdCopyBufferToImage-bufferOffset-00206",
121 "VUID-vkCmdCopyImageToBuffer-bufferOffset-00206",
Tony Barbour845d29b2021-11-09 11:43:14 -0700122 "VUID-VkCopyBufferToImageInfo2-bufferOffset-00206",
Tony-LunarGaf3632a2021-11-10 15:51:57 -0700123 "VUID-VkCopyImageToBufferInfo2-bufferOffset-00206",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700124 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -0700125 {"00207", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700126 "VUID-vkCmdCopyBufferToImage-imageExtent-00207",
127 "VUID-vkCmdCopyImageToBuffer-imageExtent-00207",
Tony Barbour845d29b2021-11-09 11:43:14 -0700128 "VUID-VkCopyBufferToImageInfo2-imageExtent-00207",
Tony-LunarGaf3632a2021-11-10 15:51:57 -0700129 "VUID-VkCopyImageToBufferInfo2-imageExtent-00207",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700130 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -0700131 {"00208", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700132 "VUID-vkCmdCopyBufferToImage-imageExtent-00208",
133 "VUID-vkCmdCopyImageToBuffer-imageExtent-00208",
Tony Barbour845d29b2021-11-09 11:43:14 -0700134 "VUID-VkCopyBufferToImageInfo2-imageExtent-00208",
Tony-LunarGaf3632a2021-11-10 15:51:57 -0700135 "VUID-VkCopyImageToBufferInfo2-imageExtent-00208",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700136 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -0700137 {"00209", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700138 "VUID-vkCmdCopyBufferToImage-imageExtent-00209",
139 "VUID-vkCmdCopyImageToBuffer-imageExtent-00209",
Tony Barbour845d29b2021-11-09 11:43:14 -0700140 "VUID-VkCopyBufferToImageInfo2-imageExtent-00209",
Tony-LunarGaf3632a2021-11-10 15:51:57 -0700141 "VUID-VkCopyImageToBufferInfo2-imageExtent-00209",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700142 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -0700143 {"00211", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700144 "VUID-vkCmdCopyBufferToImage-aspectMask-00211",
145 "VUID-vkCmdCopyImageToBuffer-aspectMask-00211",
Tony Barbour845d29b2021-11-09 11:43:14 -0700146 "VUID-VkCopyBufferToImageInfo2-aspectMask-00211",
Tony-LunarGaf3632a2021-11-10 15:51:57 -0700147 "VUID-VkCopyImageToBufferInfo2-aspectMask-00211",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700148 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -0700149 {"01560", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700150 "VUID-vkCmdCopyBufferToImage-aspectMask-01560",
151 "VUID-vkCmdCopyImageToBuffer-aspectMask-01560",
Tony Barbour845d29b2021-11-09 11:43:14 -0700152 "VUID-VkCopyBufferToImageInfo2-aspectMask-01560",
Tony-LunarGaf3632a2021-11-10 15:51:57 -0700153 "VUID-VkCopyImageToBufferInfo2-aspectMask-01560",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700154 }},
sfricke-samsung2e5b16c2020-10-31 22:14:15 -0700155 {"00213", {
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700156 "VUID-vkCmdCopyBufferToImage-baseArrayLayer-00213",
157 "VUID-vkCmdCopyImageToBuffer-baseArrayLayer-00213",
Tony Barbour845d29b2021-11-09 11:43:14 -0700158 "VUID-VkCopyBufferToImageInfo2-baseArrayLayer-00213",
Tony-LunarGaf3632a2021-11-10 15:51:57 -0700159 "VUID-VkCopyImageToBufferInfo2-baseArrayLayer-00213",
sfricke-samsung8feecc12021-01-23 03:28:38 -0800160 }},
161 {"04052", {
162 "VUID-vkCmdCopyBufferToImage-commandBuffer-04052",
163 "VUID-vkCmdCopyImageToBuffer-commandBuffer-04052",
Tony Barbour845d29b2021-11-09 11:43:14 -0700164 "VUID-VkCopyBufferToImageInfo2-commandBuffer-04052",
Tony-LunarGaf3632a2021-11-10 15:51:57 -0700165 "VUID-VkCopyImageToBufferInfo2-commandBuffer-04052",
sfricke-samsung8feecc12021-01-23 03:28:38 -0800166 }},
167 {"04053", {
168 "VUID-vkCmdCopyBufferToImage-srcImage-04053",
169 "VUID-vkCmdCopyImageToBuffer-srcImage-04053",
Tony Barbour845d29b2021-11-09 11:43:14 -0700170 "VUID-VkCopyBufferToImageInfo2-srcImage-04053",
Tony-LunarGaf3632a2021-11-10 15:51:57 -0700171 "VUID-VkCopyImageToBufferInfo2-srcImage-04053",
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700172 }}
173 };
174 // clang-format on
175
176 uint8_t index = 0;
Artem Bolgar82d08362021-06-03 13:11:13 -0700177 index |= uint8_t((image_to_buffer) ? 0x1 : 0);
178 index |= uint8_t((copy2) ? 0x2 : 0);
sfricke-samsung88ac6fe2020-10-24 10:00:13 -0700179 return copy_imagebuffer_vuid.at(id).at(index);
180}
181
Jeremy Gebben50e0b412021-02-18 10:39:41 -0700182static VkImageLayout NormalizeDepthImageLayout(VkImageLayout layout) {
Hans-Kristian Arntzen94d97222021-07-05 12:46:37 +0200183 switch (layout) {
184 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
185 case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
186 return VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL;
187
188 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
189 case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:
190 return VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
191
192 default:
193 return layout;
194 }
Jeremy Gebben50e0b412021-02-18 10:39:41 -0700195}
196
197static VkImageLayout NormalizeStencilImageLayout(VkImageLayout layout) {
Hans-Kristian Arntzen94d97222021-07-05 12:46:37 +0200198 switch (layout) {
199 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
200 case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:
201 return VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL;
202
203 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
204 case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
205 return VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL;
206
207 default:
208 return layout;
209 }
Jeremy Gebben50e0b412021-02-18 10:39:41 -0700210}
211
Jeremy Gebben579aaca2021-02-15 13:36:18 -0700212static VkImageLayout NormalizeSynchronization2Layout(const VkImageAspectFlags aspect_mask, VkImageLayout layout) {
213 if (layout == VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR) {
214 if (aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT) {
215 layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
216 } else if (aspect_mask == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
217 layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
218 } else if (aspect_mask == VK_IMAGE_ASPECT_DEPTH_BIT) {
219 layout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
220 } else if (aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT) {
221 layout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL;
222 }
223 } else if (layout == VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR) {
224 if (aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT) {
225 layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
226 } else if (aspect_mask == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
227 layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
228 } else if (aspect_mask == VK_IMAGE_ASPECT_DEPTH_BIT) {
229 layout = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL;
230 } else if (aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT) {
231 layout = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL;
232 }
233 }
234 return layout;
235}
236
Jeremy Gebben50e0b412021-02-18 10:39:41 -0700237static bool ImageLayoutMatches(const VkImageAspectFlags aspect_mask, VkImageLayout a, VkImageLayout b) {
238 bool matches = (a == b);
239 if (!matches) {
John Zulaufbea70432021-02-23 07:03:12 -0700240 a = NormalizeSynchronization2Layout(aspect_mask, a);
241 b = NormalizeSynchronization2Layout(aspect_mask, b);
242 matches = (a == b);
243 if (!matches) {
Hans-Kristian Arntzen94d97222021-07-05 12:46:37 +0200244 // Relaxed rules when referencing *only* the depth or stencil aspects.
245 // When accessing both, normalize layouts for aspects separately.
246 if (aspect_mask == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
247 matches = NormalizeDepthImageLayout(a) == NormalizeDepthImageLayout(b) &&
248 NormalizeStencilImageLayout(a) == NormalizeStencilImageLayout(b);
249 } else if (aspect_mask == VK_IMAGE_ASPECT_DEPTH_BIT) {
John Zulaufbea70432021-02-23 07:03:12 -0700250 matches = NormalizeDepthImageLayout(a) == NormalizeDepthImageLayout(b);
251 } else if (aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT) {
252 matches = NormalizeStencilImageLayout(a) == NormalizeStencilImageLayout(b);
253 }
Jeremy Gebben50e0b412021-02-18 10:39:41 -0700254 }
255 }
256 return matches;
257}
258
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -0600259// Utility type for checking Image layouts
Jeremy Gebben50e0b412021-02-18 10:39:41 -0700260struct LayoutUseCheckAndMessage {
261 const static VkImageAspectFlags kDepthOrStencil = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -0600262 const VkImageLayout expected_layout;
Jeremy Gebben50e0b412021-02-18 10:39:41 -0700263 const VkImageAspectFlags aspect_mask;
264 const char *message;
265 VkImageLayout layout;
266
267 LayoutUseCheckAndMessage() = delete;
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -0600268 LayoutUseCheckAndMessage(VkImageLayout expected, const VkImageAspectFlags aspect_mask_ = 0)
269 : expected_layout{expected}, aspect_mask{aspect_mask_}, message(nullptr), layout(kInvalidLayout) {}
270 bool Check(const LayoutEntry &layout_entry) {
Jeremy Gebben50e0b412021-02-18 10:39:41 -0700271 message = nullptr;
272 layout = kInvalidLayout; // Success status
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -0600273 if (layout_entry.current_layout != kInvalidLayout) {
274 if (!ImageLayoutMatches(aspect_mask, expected_layout, layout_entry.current_layout)) {
275 message = "previous known";
276 layout = layout_entry.current_layout;
277 }
278 } else if (layout_entry.initial_layout != kInvalidLayout) {
279 if (!ImageLayoutMatches(aspect_mask, expected_layout, layout_entry.initial_layout)) {
280 assert(layout_entry.state); // If we have an initial layout, we better have a state for it
281 if (!((layout_entry.state->aspect_mask & kDepthOrStencil) &&
282 ImageLayoutMatches(layout_entry.state->aspect_mask, expected_layout, layout_entry.initial_layout))) {
283 message = "previously used";
284 layout = layout_entry.initial_layout;
285 }
Jeremy Gebben50e0b412021-02-18 10:39:41 -0700286 }
287 }
288 return layout == kInvalidLayout;
289 }
290};
291
locke-lunarg540b2252020-08-03 13:23:36 -0600292bool IMAGE_VIEW_STATE::OverlapSubresource(const IMAGE_VIEW_STATE &compare_view) const {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -0600293 if (image_view() == compare_view.image_view()) {
locke-lunarg540b2252020-08-03 13:23:36 -0600294 return true;
295 }
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -0600296 if (image_state->image() != compare_view.image_state->image()) {
locke-lunargdc287022020-08-21 12:03:57 -0600297 return false;
298 }
locke-lunarg540b2252020-08-03 13:23:36 -0600299 if (normalized_subresource_range.aspectMask != compare_view.normalized_subresource_range.aspectMask) {
300 return false;
301 }
302
303 // compare if overlap mip level
locke-lunarg540b2252020-08-03 13:23:36 -0600304 if ((normalized_subresource_range.baseMipLevel < compare_view.normalized_subresource_range.baseMipLevel) &&
locke-lunargdc287022020-08-21 12:03:57 -0600305 ((normalized_subresource_range.baseMipLevel + normalized_subresource_range.levelCount) <=
locke-lunarg540b2252020-08-03 13:23:36 -0600306 compare_view.normalized_subresource_range.baseMipLevel)) {
locke-lunargdc287022020-08-21 12:03:57 -0600307 return false;
locke-lunarg540b2252020-08-03 13:23:36 -0600308 }
309
310 if ((normalized_subresource_range.baseMipLevel > compare_view.normalized_subresource_range.baseMipLevel) &&
locke-lunargdc287022020-08-21 12:03:57 -0600311 (normalized_subresource_range.baseMipLevel >=
locke-lunarg540b2252020-08-03 13:23:36 -0600312 (compare_view.normalized_subresource_range.baseMipLevel + compare_view.normalized_subresource_range.levelCount))) {
locke-lunargdc287022020-08-21 12:03:57 -0600313 return false;
locke-lunarg540b2252020-08-03 13:23:36 -0600314 }
315
316 // compare if overlap array layer
locke-lunarg540b2252020-08-03 13:23:36 -0600317 if ((normalized_subresource_range.baseArrayLayer < compare_view.normalized_subresource_range.baseArrayLayer) &&
locke-lunargdc287022020-08-21 12:03:57 -0600318 ((normalized_subresource_range.baseArrayLayer + normalized_subresource_range.layerCount) <=
locke-lunarg540b2252020-08-03 13:23:36 -0600319 compare_view.normalized_subresource_range.baseArrayLayer)) {
locke-lunargdc287022020-08-21 12:03:57 -0600320 return false;
locke-lunarg540b2252020-08-03 13:23:36 -0600321 }
322
323 if ((normalized_subresource_range.baseArrayLayer > compare_view.normalized_subresource_range.baseArrayLayer) &&
locke-lunargdc287022020-08-21 12:03:57 -0600324 (normalized_subresource_range.baseArrayLayer >=
locke-lunarg540b2252020-08-03 13:23:36 -0600325 (compare_view.normalized_subresource_range.baseArrayLayer + compare_view.normalized_subresource_range.layerCount))) {
locke-lunargdc287022020-08-21 12:03:57 -0600326 return false;
locke-lunarg540b2252020-08-03 13:23:36 -0600327 }
locke-lunargdc287022020-08-21 12:03:57 -0600328 return true;
locke-lunarg540b2252020-08-03 13:23:36 -0600329}
330
Dave Houltond9611312018-11-19 17:03:36 -0700331uint32_t FullMipChainLevels(uint32_t height, uint32_t width, uint32_t depth) {
332 // uint cast applies floor()
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -0700333 return 1u + static_cast<uint32_t>(log2(std::max({height, width, depth})));
Dave Houltond9611312018-11-19 17:03:36 -0700334}
335
336uint32_t FullMipChainLevels(VkExtent3D extent) { return FullMipChainLevels(extent.height, extent.width, extent.depth); }
337
338uint32_t FullMipChainLevels(VkExtent2D extent) { return FullMipChainLevels(extent.height, extent.width); }
339
John Zulauf2d60a452021-03-04 15:12:03 -0700340bool CoreChecks::FindLayouts(const IMAGE_STATE &image_state, std::vector<VkImageLayout> &layouts) const {
Jeremy Gebben4a8881f2022-01-10 17:04:30 -0700341 const auto *layout_range_map = image_state.layout_range_map.get();
John Zulauf2076e812020-01-08 14:55:54 -0700342 if (!layout_range_map) return false;
Jeremy Gebben4a8881f2022-01-10 17:04:30 -0700343
344 auto guard = layout_range_map->ReadLock();
locke-lunargf155ccf2020-02-18 11:34:15 -0700345 // TODO: FindLayouts function should mutate into a ValidatePresentableLayout with the loop wrapping the LogError
346 // from the caller. You can then use decode to add the subresource of the range::begin to the error message.
347
John Zulauf2076e812020-01-08 14:55:54 -0700348 // TODO: what is this test and what is it supposed to do?! -- the logic doesn't match the comment below?!
349
350 // TODO: Make this robust for >1 aspect mask. Now it will just say ignore potential errors in this case.
John Zulauf2d60a452021-03-04 15:12:03 -0700351 if (layout_range_map->size() >= (image_state.createInfo.arrayLayers * image_state.createInfo.mipLevels + 1)) {
Tony Barbourdf013b92017-01-25 12:53:48 -0700352 return false;
353 }
locke-lunargcba7d5f2019-12-30 16:59:11 -0700354
John Zulauf79f06582021-02-27 18:38:39 -0700355 for (const auto &entry : *layout_range_map) {
John Zulauf2076e812020-01-08 14:55:54 -0700356 layouts.push_back(entry.second);
Tony Barbourdf013b92017-01-25 12:53:48 -0700357 }
358 return true;
359}
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700360
Mark Lobodzinskief4ab2e2019-03-07 13:23:36 -0700361bool CoreChecks::ValidateRenderPassLayoutAgainstFramebufferImageUsage(RenderPassCreateVersion rp_version, VkImageLayout layout,
Jeremy Gebben057f9d52021-11-05 14:12:31 -0600362 const IMAGE_VIEW_STATE &image_view_state,
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700363 VkFramebuffer framebuffer, VkRenderPass renderpass,
John Zulauf17a01bb2019-08-09 16:41:19 -0600364 uint32_t attachment_index, const char *variable_name) const {
Tobias Hectorbbb12282018-10-22 15:17:59 +0100365 bool skip = false;
Jeremy Gebben057f9d52021-11-05 14:12:31 -0600366 const auto &image_view = image_view_state.Handle();
367 const auto *image_state = image_view_state.image_state.get();
368 const auto &image = image_state->Handle();
Tobias Hectorbbb12282018-10-22 15:17:59 +0100369 const char *vuid;
370 const bool use_rp2 = (rp_version == RENDER_PASS_VERSION_2);
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -0700371 const char *function_name = use_rp2 ? "vkCmdBeginRenderPass2()" : "vkCmdBeginRenderPass()";
Tobias Hectorbbb12282018-10-22 15:17:59 +0100372
373 if (!image_state) {
Mark Lobodzinskiea561582020-03-16 18:13:56 -0600374 LogObjectList objlist(image);
375 objlist.add(renderpass);
376 objlist.add(framebuffer);
377 objlist.add(image_view);
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -0700378 skip |=
sfricke-samsung4389faa2022-03-23 01:19:42 -0500379 LogError(objlist, "VUID-VkRenderPassBeginInfo-framebuffer-parameter",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -0700380 "%s: RenderPass %s uses %s where pAttachments[%" PRIu32 "] = %s, which refers to an invalid image",
381 function_name, report_data->FormatHandle(renderpass).c_str(), report_data->FormatHandle(framebuffer).c_str(),
382 attachment_index, report_data->FormatHandle(image_view).c_str());
Tobias Hectorbbb12282018-10-22 15:17:59 +0100383 return skip;
384 }
385
386 auto image_usage = image_state->createInfo.usage;
Mark Lobodzinski1f887d32020-12-30 15:31:33 -0700387 const auto stencil_usage_info = LvlFindInChain<VkImageStencilUsageCreateInfo>(image_state->createInfo.pNext);
Ricardo Garcia3f5984c2020-04-09 10:56:34 +0200388 if (stencil_usage_info) {
389 image_usage |= stencil_usage_info->stencilUsage;
390 }
Tobias Hectorbbb12282018-10-22 15:17:59 +0100391
392 // Check for layouts that mismatch image usages in the framebuffer
393 if (layout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL && !(image_usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)) {
Mike Schuchardt65847d92019-12-20 13:50:47 -0800394 vuid = use_rp2 ? "VUID-vkCmdBeginRenderPass2-initialLayout-03094" : "VUID-vkCmdBeginRenderPass-initialLayout-00895";
Mark Lobodzinskiea561582020-03-16 18:13:56 -0600395 LogObjectList objlist(image);
396 objlist.add(renderpass);
397 objlist.add(framebuffer);
398 objlist.add(image_view);
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -0700399 skip |= LogError(objlist, vuid,
400 "%s: Layout/usage mismatch for attachment %u in %s"
401 " - the %s is %s but the image attached to %s via %s"
402 " was not created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT",
403 function_name, attachment_index, report_data->FormatHandle(renderpass).c_str(), variable_name,
404 string_VkImageLayout(layout), report_data->FormatHandle(framebuffer).c_str(),
405 report_data->FormatHandle(image_view).c_str());
Tobias Hectorbbb12282018-10-22 15:17:59 +0100406 }
407
408 if (layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL &&
409 !(image_usage & (VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT))) {
Mike Schuchardt65847d92019-12-20 13:50:47 -0800410 vuid = use_rp2 ? "VUID-vkCmdBeginRenderPass2-initialLayout-03097" : "VUID-vkCmdBeginRenderPass-initialLayout-00897";
Mark Lobodzinskiea561582020-03-16 18:13:56 -0600411 LogObjectList objlist(image);
412 objlist.add(renderpass);
413 objlist.add(framebuffer);
414 objlist.add(image_view);
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -0700415 skip |= LogError(objlist, vuid,
416 "%s: Layout/usage mismatch for attachment %u in %s"
417 " - the %s is %s but the image attached to %s via %s"
418 " was not created with VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT or VK_IMAGE_USAGE_SAMPLED_BIT",
419 function_name, attachment_index, report_data->FormatHandle(renderpass).c_str(), variable_name,
420 string_VkImageLayout(layout), report_data->FormatHandle(framebuffer).c_str(),
421 report_data->FormatHandle(image_view).c_str());
Tobias Hectorbbb12282018-10-22 15:17:59 +0100422 }
423
424 if (layout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL && !(image_usage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT)) {
Mike Schuchardt65847d92019-12-20 13:50:47 -0800425 vuid = use_rp2 ? "VUID-vkCmdBeginRenderPass2-initialLayout-03098" : "VUID-vkCmdBeginRenderPass-initialLayout-00898";
Mark Lobodzinskiea561582020-03-16 18:13:56 -0600426 LogObjectList objlist(image);
427 objlist.add(renderpass);
428 objlist.add(framebuffer);
429 objlist.add(image_view);
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -0700430 skip |= LogError(objlist, vuid,
431 "%s: Layout/usage mismatch for attachment %u in %s"
432 " - the %s is %s but the image attached to %s via %s"
433 " was not created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT",
434 function_name, attachment_index, report_data->FormatHandle(renderpass).c_str(), variable_name,
435 string_VkImageLayout(layout), report_data->FormatHandle(framebuffer).c_str(),
436 report_data->FormatHandle(image_view).c_str());
Tobias Hectorbbb12282018-10-22 15:17:59 +0100437 }
438
439 if (layout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && !(image_usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) {
Mike Schuchardt65847d92019-12-20 13:50:47 -0800440 vuid = use_rp2 ? "VUID-vkCmdBeginRenderPass2-initialLayout-03099" : "VUID-vkCmdBeginRenderPass-initialLayout-00899";
Mark Lobodzinskiea561582020-03-16 18:13:56 -0600441 LogObjectList objlist(image);
442 objlist.add(renderpass);
443 objlist.add(framebuffer);
444 objlist.add(image_view);
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -0700445 skip |= LogError(objlist, vuid,
446 "%s: Layout/usage mismatch for attachment %u in %s"
447 " - the %s is %s but the image attached to %s via %s"
448 " was not created with VK_IMAGE_USAGE_TRANSFER_DST_BIT",
449 function_name, attachment_index, report_data->FormatHandle(renderpass).c_str(), variable_name,
450 string_VkImageLayout(layout), report_data->FormatHandle(framebuffer).c_str(),
451 report_data->FormatHandle(image_view).c_str());
Tobias Hectorbbb12282018-10-22 15:17:59 +0100452 }
453
sfricke-samsung45996a42021-09-16 13:45:27 -0700454 if (IsExtEnabled(device_extensions.vk_khr_maintenance2)) {
Tobias Hectorbbb12282018-10-22 15:17:59 +0100455 if ((layout == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL ||
456 layout == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL ||
457 layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL ||
458 layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL) &&
459 !(image_usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
Mike Schuchardt65847d92019-12-20 13:50:47 -0800460 vuid = use_rp2 ? "VUID-vkCmdBeginRenderPass2-initialLayout-03096" : "VUID-vkCmdBeginRenderPass-initialLayout-01758";
Mark Lobodzinskiea561582020-03-16 18:13:56 -0600461 LogObjectList objlist(image);
462 objlist.add(renderpass);
463 objlist.add(framebuffer);
464 objlist.add(image_view);
465 skip |= LogError(objlist, vuid,
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -0700466 "%s: Layout/usage mismatch for attachment %u in %s"
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -0700467 " - the %s is %s but the image attached to %s via %s"
468 " was not created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -0700469 function_name, attachment_index, report_data->FormatHandle(renderpass).c_str(), variable_name,
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -0700470 string_VkImageLayout(layout), report_data->FormatHandle(framebuffer).c_str(),
471 report_data->FormatHandle(image_view).c_str());
Tobias Hectorbbb12282018-10-22 15:17:59 +0100472 }
473 } else {
474 // The create render pass 2 extension requires maintenance 2 (the previous branch), so no vuid switch needed here.
475 if ((layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL ||
476 layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL) &&
477 !(image_usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
Mark Lobodzinskiea561582020-03-16 18:13:56 -0600478 LogObjectList objlist(image);
479 objlist.add(renderpass);
480 objlist.add(framebuffer);
481 objlist.add(image_view);
482 skip |= LogError(objlist, "VUID-vkCmdBeginRenderPass-initialLayout-00896",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -0700483 "%s: Layout/usage mismatch for attachment %u in %s"
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -0700484 " - the %s is %s but the image attached to %s via %s"
485 " was not created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -0700486 function_name, attachment_index, report_data->FormatHandle(renderpass).c_str(), variable_name,
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -0700487 string_VkImageLayout(layout), report_data->FormatHandle(framebuffer).c_str(),
488 report_data->FormatHandle(image_view).c_str());
Tobias Hectorbbb12282018-10-22 15:17:59 +0100489 }
490 }
491 return skip;
492}
493
John Zulauf17a01bb2019-08-09 16:41:19 -0600494bool CoreChecks::VerifyFramebufferAndRenderPassLayouts(RenderPassCreateVersion rp_version, const CMD_BUFFER_STATE *pCB,
Mark Lobodzinskief4ab2e2019-03-07 13:23:36 -0700495 const VkRenderPassBeginInfo *pRenderPassBegin,
John Zulauf17a01bb2019-08-09 16:41:19 -0600496 const FRAMEBUFFER_STATE *framebuffer_state) const {
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600497 bool skip = false;
Jeremy Gebbenf4449392022-01-28 10:09:10 -0700498 auto render_pass_state = Get<RENDER_PASS_STATE>(pRenderPassBegin->renderPass);
Jeremy Gebbenb20a8242021-11-05 15:14:43 -0600499 const auto *render_pass_info = render_pass_state->createInfo.ptr();
500 auto render_pass = render_pass_state->renderPass();
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -0700501 auto const &framebuffer_info = framebuffer_state->createInfo;
502 const VkImageView *attachments = framebuffer_info.pAttachments;
Tobias Hectorbbb12282018-10-22 15:17:59 +0100503
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -0600504 auto framebuffer = framebuffer_state->framebuffer();
Tobias Hectorbbb12282018-10-22 15:17:59 +0100505
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -0700506 if (render_pass_info->attachmentCount != framebuffer_info.attachmentCount) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -0600507 skip |= LogError(pCB->commandBuffer(), kVUID_Core_DrawState_InvalidRenderpass,
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -0700508 "You cannot start a render pass using a framebuffer with a different number of attachments.");
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700509 }
John Zulauf8e308292018-09-21 11:34:37 -0600510
Mark Lobodzinski1f887d32020-12-30 15:31:33 -0700511 const auto *attachment_info = LvlFindInChain<VkRenderPassAttachmentBeginInfo>(pRenderPassBegin->pNext);
Mike Schuchardt2df08912020-12-15 16:28:09 -0800512 if (((framebuffer_info.flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT) != 0) && attachment_info != nullptr) {
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -0700513 attachments = attachment_info->pAttachments;
Tobias Hectorbbb12282018-10-22 15:17:59 +0100514 }
515
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600516 if (attachments == nullptr) {
517 return skip;
518 }
519 const auto *const_p_cb = static_cast<const CMD_BUFFER_STATE *>(pCB);
520 for (uint32_t i = 0; i < render_pass_info->attachmentCount && i < framebuffer_info.attachmentCount; ++i) {
521 auto image_view = attachments[i];
522 auto view_state = Get<IMAGE_VIEW_STATE>(image_view);
Tobias Hectorbbb12282018-10-22 15:17:59 +0100523
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600524 if (!view_state) {
525 LogObjectList objlist(pRenderPassBegin->renderPass);
526 objlist.add(framebuffer_state->framebuffer());
527 objlist.add(image_view);
528 skip |= LogError(objlist, "VUID-VkRenderPassBeginInfo-framebuffer-parameter",
529 "vkCmdBeginRenderPass(): %s pAttachments[%" PRIu32 "] = %s is not a valid VkImageView handle",
530 report_data->FormatHandle(framebuffer_state->framebuffer()).c_str(), i,
531 report_data->FormatHandle(image_view).c_str());
532 continue;
Tobias Hectorbbb12282018-10-22 15:17:59 +0100533 }
534
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600535 const VkImage image = view_state->create_info.image;
536 const auto *image_state = view_state->image_state.get();
Tobias Hectorbbb12282018-10-22 15:17:59 +0100537
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600538 if (!image_state) {
539 LogObjectList objlist(pRenderPassBegin->renderPass);
540 objlist.add(framebuffer_state->framebuffer());
541 objlist.add(image_view);
542 objlist.add(image);
543 skip |= LogError(objlist, "VUID-VkRenderPassBeginInfo-framebuffer-parameter",
544 "vkCmdBeginRenderPass(): %s pAttachments[%" PRIu32 "] = %s references non-extant %s.",
545 report_data->FormatHandle(framebuffer_state->framebuffer()).c_str(), i,
546 report_data->FormatHandle(image_view).c_str(), report_data->FormatHandle(image).c_str());
547 continue;
548 }
549 auto attachment_initial_layout = render_pass_info->pAttachments[i].initialLayout;
550 auto final_layout = render_pass_info->pAttachments[i].finalLayout;
551
552 // Default to expecting stencil in the same layout.
553 auto attachment_stencil_initial_layout = attachment_initial_layout;
554
555 // If a separate layout is specified, look for that.
556 const auto *attachment_description_stencil_layout =
557 LvlFindInChain<VkAttachmentDescriptionStencilLayout>(render_pass_info->pAttachments[i].pNext);
558 if (attachment_description_stencil_layout) {
559 attachment_stencil_initial_layout = attachment_description_stencil_layout->stencilInitialLayout;
560 }
561
562 const ImageSubresourceLayoutMap *subresource_map = nullptr;
563 bool has_queried_map = false;
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600564
565 for (uint32_t aspect_index = 0; aspect_index < 32; aspect_index++) {
566 VkImageAspectFlags test_aspect = 1u << aspect_index;
567 if ((view_state->normalized_subresource_range.aspectMask & test_aspect) == 0) {
568 continue;
569 }
570
571 // Allow for differing depth and stencil layouts
572 VkImageLayout check_layout = attachment_initial_layout;
573 if (test_aspect == VK_IMAGE_ASPECT_STENCIL_BIT) {
574 check_layout = attachment_stencil_initial_layout;
575 }
576
577 // If no layout information for image yet, will be checked at QueueSubmit time
578 if (check_layout == VK_IMAGE_LAYOUT_UNDEFINED) {
579 continue;
580 }
581 if (!has_queried_map) {
582 // Cast pCB to const because we don't want to create entries that don't exist here (in case the key changes to
583 // something in common with the non-const version.) The lookup is expensive, so cache it.
584 subresource_map = const_p_cb->GetImageSubresourceLayoutMap(*image_state);
585 has_queried_map = true;
586 }
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600587 if (!subresource_map) {
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -0600588 // If no layout information for image yet, will be checked at QueueSubmit time
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600589 continue;
590 }
591 auto normalized_range = view_state->normalized_subresource_range;
592 normalized_range.aspectMask = test_aspect;
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -0600593 LayoutUseCheckAndMessage layout_check(check_layout, test_aspect);
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600594
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -0600595 skip |= subresource_map->AnyInRange(
596 normalized_range, [this, &layout_check, i](const VkImageSubresource &subres, const LayoutEntry &state) {
597 bool subres_skip = false;
598 if (!layout_check.Check(state)) {
599 subres_skip = LogError(device, kVUID_Core_DrawState_InvalidRenderpass,
600 "You cannot start a render pass using attachment %u where the render pass initial "
601 "layout is %s "
602 "and the %s layout of the attachment is %s. The layouts must match, or the render "
603 "pass initial layout for the attachment must be VK_IMAGE_LAYOUT_UNDEFINED",
604 i, string_VkImageLayout(layout_check.expected_layout), layout_check.message,
605 string_VkImageLayout(layout_check.layout));
606 }
607 return subres_skip;
608 });
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600609 }
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600610 ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, attachment_initial_layout, *view_state, framebuffer,
611 render_pass, i, "initial layout");
612
613 ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, final_layout, *view_state, framebuffer, render_pass, i,
614 "final layout");
615 }
616
617 for (uint32_t j = 0; j < render_pass_info->subpassCount; ++j) {
618 auto &subpass = render_pass_info->pSubpasses[j];
619 for (uint32_t k = 0; k < render_pass_info->pSubpasses[j].inputAttachmentCount; ++k) {
620 auto &attachment_ref = subpass.pInputAttachments[k];
621 if (attachment_ref.attachment != VK_ATTACHMENT_UNUSED) {
622 auto image_view = attachments[attachment_ref.attachment];
623 auto view_state = Get<IMAGE_VIEW_STATE>(image_view);
624
625 if (view_state) {
626 ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, attachment_ref.layout, *view_state,
627 framebuffer, render_pass, attachment_ref.attachment,
628 "input attachment layout");
629 }
630 }
631 }
632
633 for (uint32_t k = 0; k < render_pass_info->pSubpasses[j].colorAttachmentCount; ++k) {
634 auto &attachment_ref = subpass.pColorAttachments[k];
635 if (attachment_ref.attachment != VK_ATTACHMENT_UNUSED) {
636 auto image_view = attachments[attachment_ref.attachment];
637 auto view_state = Get<IMAGE_VIEW_STATE>(image_view);
638
639 if (view_state) {
640 ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, attachment_ref.layout, *view_state,
641 framebuffer, render_pass, attachment_ref.attachment,
642 "color attachment layout");
643 if (subpass.pResolveAttachments) {
Jeremy Gebben057f9d52021-11-05 14:12:31 -0600644 ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, attachment_ref.layout, *view_state,
Mark Lobodzinskief4ab2e2019-03-07 13:23:36 -0700645 framebuffer, render_pass, attachment_ref.attachment,
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600646 "resolve attachment layout");
Tobias Hectorbbb12282018-10-22 15:17:59 +0100647 }
648 }
649 }
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600650 }
Tobias Hectorbbb12282018-10-22 15:17:59 +0100651
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600652 if (render_pass_info->pSubpasses[j].pDepthStencilAttachment) {
653 auto &attachment_ref = *subpass.pDepthStencilAttachment;
654 if (attachment_ref.attachment != VK_ATTACHMENT_UNUSED) {
655 auto image_view = attachments[attachment_ref.attachment];
656 auto view_state = Get<IMAGE_VIEW_STATE>(image_view);
Tobias Hectorbbb12282018-10-22 15:17:59 +0100657
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600658 if (view_state) {
659 ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, attachment_ref.layout, *view_state,
660 framebuffer, render_pass, attachment_ref.attachment,
661 "input attachment layout");
Tobias Hectorbbb12282018-10-22 15:17:59 +0100662 }
663 }
664 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700665 }
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -0600666 return skip;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700667}
668
Mark Lobodzinski33a34b82019-04-25 11:38:36 -0600669void CoreChecks::TransitionAttachmentRefLayout(CMD_BUFFER_STATE *pCB, FRAMEBUFFER_STATE *pFramebuffer,
Mike Schuchardtf6f00492019-10-21 23:35:17 -0700670 const safe_VkAttachmentReference2 &ref) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700671 if (ref.attachment != VK_ATTACHMENT_UNUSED) {
Jeremy Gebben9efe1cf2021-05-15 20:05:09 -0600672 IMAGE_VIEW_STATE *image_view = pCB->GetActiveAttachmentImageViewState(ref.attachment);
John Zulauf8e308292018-09-21 11:34:37 -0600673 if (image_view) {
Piers Daniell4fde9b72019-11-27 16:19:46 -0700674 VkImageLayout stencil_layout = kInvalidLayout;
Mark Lobodzinski1f887d32020-12-30 15:31:33 -0700675 const auto *attachment_reference_stencil_layout = LvlFindInChain<VkAttachmentReferenceStencilLayout>(ref.pNext);
Piers Daniell4fde9b72019-11-27 16:19:46 -0700676 if (attachment_reference_stencil_layout) {
677 stencil_layout = attachment_reference_stencil_layout->stencilLayout;
678 }
679
Jeremy Gebben1ec89332021-08-05 13:51:49 -0600680 pCB->SetImageViewLayout(*image_view, ref.layout, stencil_layout);
John Zulauf8e308292018-09-21 11:34:37 -0600681 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700682 }
683}
684
Mark Lobodzinski33a34b82019-04-25 11:38:36 -0600685void CoreChecks::TransitionSubpassLayouts(CMD_BUFFER_STATE *pCB, const RENDER_PASS_STATE *render_pass_state,
686 const int subpass_index, FRAMEBUFFER_STATE *framebuffer_state) {
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700687 assert(render_pass_state);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700688
689 if (framebuffer_state) {
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700690 auto const &subpass = render_pass_state->createInfo.pSubpasses[subpass_index];
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700691 for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) {
Mark Lobodzinski8564e442019-03-07 12:49:41 -0700692 TransitionAttachmentRefLayout(pCB, framebuffer_state, subpass.pInputAttachments[j]);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700693 }
694 for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) {
Mark Lobodzinski8564e442019-03-07 12:49:41 -0700695 TransitionAttachmentRefLayout(pCB, framebuffer_state, subpass.pColorAttachments[j]);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700696 }
697 if (subpass.pDepthStencilAttachment) {
Mark Lobodzinski8564e442019-03-07 12:49:41 -0700698 TransitionAttachmentRefLayout(pCB, framebuffer_state, *subpass.pDepthStencilAttachment);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700699 }
700 }
701}
702
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700703// Transition the layout state for renderpass attachments based on the BeginRenderPass() call. This includes:
704// 1. Transition into initialLayout state
705// 2. Transition from initialLayout to layout used in subpass 0
Mark Lobodzinski33a34b82019-04-25 11:38:36 -0600706void CoreChecks::TransitionBeginRenderPassLayouts(CMD_BUFFER_STATE *cb_state, const RENDER_PASS_STATE *render_pass_state,
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -0700707 FRAMEBUFFER_STATE *framebuffer_state) {
John Zulauf81dd1f12021-01-26 16:49:16 -0700708 // First record expected initialLayout as a potential initial layout usage.
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700709 auto const rpci = render_pass_state->createInfo.ptr();
710 for (uint32_t i = 0; i < rpci->attachmentCount; ++i) {
Jeremy Gebben9efe1cf2021-05-15 20:05:09 -0600711 auto *view_state = cb_state->GetActiveAttachmentImageViewState(i);
John Zulauf8e308292018-09-21 11:34:37 -0600712 if (view_state) {
John Zulauf81dd1f12021-01-26 16:49:16 -0700713 IMAGE_STATE *image_state = view_state->image_state.get();
714 const auto initial_layout = rpci->pAttachments[i].initialLayout;
Piers Daniell4fde9b72019-11-27 16:19:46 -0700715 const auto *attachment_description_stencil_layout =
Mark Lobodzinski1f887d32020-12-30 15:31:33 -0700716 LvlFindInChain<VkAttachmentDescriptionStencilLayout>(rpci->pAttachments[i].pNext);
Piers Daniell4fde9b72019-11-27 16:19:46 -0700717 if (attachment_description_stencil_layout) {
John Zulauf81dd1f12021-01-26 16:49:16 -0700718 const auto stencil_initial_layout = attachment_description_stencil_layout->stencilInitialLayout;
719 VkImageSubresourceRange sub_range = view_state->normalized_subresource_range;
720 sub_range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
Jeremy Gebben1ec89332021-08-05 13:51:49 -0600721 cb_state->SetImageInitialLayout(*image_state, sub_range, initial_layout);
John Zulauf81dd1f12021-01-26 16:49:16 -0700722 sub_range.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
Jeremy Gebben1ec89332021-08-05 13:51:49 -0600723 cb_state->SetImageInitialLayout(*image_state, sub_range, stencil_initial_layout);
John Zulauf81dd1f12021-01-26 16:49:16 -0700724 } else {
Jeremy Gebben1ec89332021-08-05 13:51:49 -0600725 cb_state->SetImageInitialLayout(*image_state, view_state->normalized_subresource_range, initial_layout);
Piers Daniell4fde9b72019-11-27 16:19:46 -0700726 }
John Zulauf8e308292018-09-21 11:34:37 -0600727 }
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700728 }
729 // Now transition for first subpass (index 0)
Mark Lobodzinski8564e442019-03-07 12:49:41 -0700730 TransitionSubpassLayouts(cb_state, render_pass_state, 0, framebuffer_state);
Tobin Ehlis0d4274b2017-02-17 15:17:04 -0700731}
732
Dave Houlton10b39482017-03-16 13:18:15 -0600733bool VerifyAspectsPresent(VkImageAspectFlags aspect_mask, VkFormat format) {
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600734 if ((aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != 0) {
Dave Houltone2fca552018-04-05 16:20:33 -0600735 if (!(FormatIsColor(format) || FormatIsMultiplane(format))) return false;
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600736 }
737 if ((aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) != 0) {
Dave Houlton1d2022c2017-03-29 11:43:58 -0600738 if (!FormatHasDepth(format)) return false;
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600739 }
740 if ((aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) != 0) {
Dave Houlton1d2022c2017-03-29 11:43:58 -0600741 if (!FormatHasStencil(format)) return false;
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600742 }
Mike Schuchardt2df08912020-12-15 16:28:09 -0800743 if (0 != (aspect_mask & (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT | VK_IMAGE_ASPECT_PLANE_2_BIT))) {
Dave Houltonb3f4b282018-02-22 16:25:16 -0700744 if (FormatPlaneCount(format) == 1) return false;
745 }
Dave Houlton4eaaf3a2017-03-14 11:31:20 -0600746 return true;
747}
748
sfricke-samsung10b35ce2021-09-29 08:50:20 -0700749// There is a table in the Vulkan spec to list all formats that implicitly require YCbCr conversion,
750// but some features/extensions can explicitly turn that restriction off
751// The implicit check is done in format utils, while feature checks are done here in CoreChecks
752bool CoreChecks::FormatRequiresYcbcrConversionExplicitly(const VkFormat format) const {
753 if (format == VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 &&
754 enabled_features.rgba10x6_formats_features.formatRgba10x6WithoutYCbCrSampler) {
755 return false;
756 }
757 return FormatRequiresYcbcrConversion(format);
758}
759
Mike Weiblen62d08a32017-03-07 22:18:27 -0700760// Verify an ImageMemoryBarrier's old/new ImageLayouts are compatible with the Image's ImageUsageFlags.
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -0700761bool CoreChecks::ValidateBarrierLayoutToImageUsage(const Location &loc, VkImage image, VkImageLayout layout,
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700762 VkImageUsageFlags usage_flags) const {
Mike Weiblen62d08a32017-03-07 22:18:27 -0700763 bool skip = false;
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700764 bool is_error = false;
Mike Weiblen62d08a32017-03-07 22:18:27 -0700765 switch (layout) {
766 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700767 is_error = ((usage_flags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) == 0);
Mike Weiblen62d08a32017-03-07 22:18:27 -0700768 break;
769 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700770 is_error = ((usage_flags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0);
Mike Weiblen62d08a32017-03-07 22:18:27 -0700771 break;
772 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700773 is_error = ((usage_flags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0);
Mike Weiblen62d08a32017-03-07 22:18:27 -0700774 break;
775 case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700776 is_error = ((usage_flags & (VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)) == 0);
Mike Weiblen62d08a32017-03-07 22:18:27 -0700777 break;
778 case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700779 is_error = ((usage_flags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) == 0);
Mike Weiblen62d08a32017-03-07 22:18:27 -0700780 break;
781 case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700782 is_error = ((usage_flags & VK_IMAGE_USAGE_TRANSFER_DST_BIT) == 0);
Mike Weiblen62d08a32017-03-07 22:18:27 -0700783 break;
Dave Houlton142c4cb2018-10-17 15:04:41 -0600784 case VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV:
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700785 is_error = ((usage_flags & VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV) == 0);
Jeff Bolz9af91c52018-09-01 21:53:57 -0500786 break;
sfricke-samsung9f9ca962020-04-25 02:04:55 -0700787 case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700788 is_error = ((usage_flags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0);
sfricke-samsung9f9ca962020-04-25 02:04:55 -0700789 break;
790 case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700791 is_error = ((usage_flags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0);
sfricke-samsung9f9ca962020-04-25 02:04:55 -0700792 break;
Mike Weiblen62d08a32017-03-07 22:18:27 -0700793 default:
794 // Other VkImageLayout values do not have VUs defined in this context.
795 break;
796 }
797
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700798 if (is_error) {
799 const auto &vuid = sync_vuid_maps::GetBadImageLayoutVUID(loc, layout);
800
801 skip |=
802 LogError(image, vuid, "%s Image barrier Layout=%s is not compatible with %s usage flags 0x%" PRIx32 ".",
803 loc.Message().c_str(), string_VkImageLayout(layout), report_data->FormatHandle(image).c_str(), usage_flags);
Mike Weiblen62d08a32017-03-07 22:18:27 -0700804 }
805 return skip;
806}
807
808// Verify image barriers are compatible with the images they reference.
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700809template <typename ImageBarrier>
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -0700810bool CoreChecks::ValidateBarriersToImages(const Location &outer_loc, const CMD_BUFFER_STATE *cb_state,
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700811 uint32_t imageMemoryBarrierCount, const ImageBarrier *pImageMemoryBarriers) const {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700812 bool skip = false;
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700813 using sync_vuid_maps::GetImageBarrierVUID;
814 using sync_vuid_maps::ImageError;
Petr Krausad0096a2019-08-09 18:35:04 +0200815
John Zulauf463c51e2018-05-31 13:29:20 -0600816 // Scoreboard for duplicate layout transition barriers within the list
817 // Pointers retained in the scoreboard only have the lifetime of *this* call (i.e. within the scope of the API call)
ziga-lunarg189ae5d2021-10-19 13:09:58 +0200818 const CommandBufferImageLayoutMap &current_map = cb_state->GetImageSubresourceLayoutMap();
819 CommandBufferImageLayoutMap layout_updates;
John Zulauf463c51e2018-05-31 13:29:20 -0600820
Mike Weiblen62d08a32017-03-07 22:18:27 -0700821 for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700822 auto loc = outer_loc.dot(Field::pImageMemoryBarriers, i);
Petr Krausad0096a2019-08-09 18:35:04 +0200823 const auto &img_barrier = pImageMemoryBarriers[i];
Mike Weiblen62d08a32017-03-07 22:18:27 -0700824
Jeremy Gebbenb20a8242021-11-05 15:14:43 -0600825 auto image_state = Get<IMAGE_STATE>(img_barrier.image);
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600826 if (!image_state) {
827 continue;
828 }
829 VkImageUsageFlags usage_flags = image_state->createInfo.usage;
830 skip |= ValidateBarrierLayoutToImageUsage(loc.dot(Field::oldLayout), img_barrier.image, img_barrier.oldLayout, usage_flags);
831 skip |= ValidateBarrierLayoutToImageUsage(loc.dot(Field::newLayout), img_barrier.image, img_barrier.newLayout, usage_flags);
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -0600832
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600833 // Make sure layout is able to be transitioned, currently only presented shared presentable images are locked
834 if (image_state->layout_locked) {
835 // TODO: Add unique id for error when available
836 skip |= LogError(
837 img_barrier.image, "VUID-Undefined",
838 "%s Attempting to transition shared presentable %s"
839 " from layout %s to layout %s, but image has already been presented and cannot have its layout transitioned.",
840 loc.Message().c_str(), report_data->FormatHandle(img_barrier.image).c_str(),
841 string_VkImageLayout(img_barrier.oldLayout), string_VkImageLayout(img_barrier.newLayout));
842 }
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -0600843
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600844 const VkImageCreateInfo &image_create_info = image_state->createInfo;
845 const VkFormat image_format = image_create_info.format;
846 const VkImageAspectFlags aspect_mask = img_barrier.subresourceRange.aspectMask;
847 // For a Depth/Stencil image both aspects MUST be set
848 auto image_loc = loc.dot(Field::image);
849 if (FormatIsDepthAndStencil(image_format)) {
850 if (enabled_features.core12.separateDepthStencilLayouts) {
851 if (!(aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) {
852 auto vuid = GetImageBarrierVUID(loc, ImageError::kNotDepthOrStencilAspect);
sfricke-samsung79b00482020-04-01 21:15:50 -0700853 skip |= LogError(img_barrier.image, vuid,
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600854 "%s references %s of format %s that must have either the depth or stencil "
855 "aspects set, but its aspectMask is 0x%" PRIx32 ".",
856 image_loc.Message().c_str(), report_data->FormatHandle(img_barrier.image).c_str(),
857 string_VkFormat(image_format), aspect_mask);
858 }
859 } else {
860 auto const ds_mask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
861 if ((aspect_mask & ds_mask) != (ds_mask)) {
862 auto error = IsExtEnabled(device_extensions.vk_khr_separate_depth_stencil_layouts)
863 ? ImageError::kNotSeparateDepthAndStencilAspect
864 : ImageError::kNotDepthAndStencilAspect;
865 auto vuid = GetImageBarrierVUID(image_loc, error);
866 skip |= LogError(img_barrier.image, vuid,
867 "%s references %s of format %s that must have the depth and stencil "
868 "aspects set, but its aspectMask is 0x%" PRIx32 ".",
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700869 image_loc.Message().c_str(), report_data->FormatHandle(img_barrier.image).c_str(),
sfricke-samsung79b00482020-04-01 21:15:50 -0700870 string_VkFormat(image_format), aspect_mask);
871 }
872 }
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600873 }
sfricke-samsung79b00482020-04-01 21:15:50 -0700874
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600875 if (img_barrier.oldLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
876 // TODO: Set memory invalid which is in mem_tracker currently
877 } else if (!QueueFamilyIsExternal(img_barrier.srcQueueFamilyIndex)) {
878 auto &write_subresource_map = layout_updates[image_state.get()];
879 bool new_write = false;
880 if (!write_subresource_map) {
881 write_subresource_map = std::make_shared<ImageSubresourceLayoutMap>(*image_state);
882 new_write = true;
883 }
884 const auto &current_subresource_map = current_map.find(image_state.get());
885 const auto &read_subresource_map = (new_write && current_subresource_map != current_map.end())
886 ? (*current_subresource_map).second
887 : write_subresource_map;
888
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600889 // Validate aspects in isolation.
890 // This is required when handling separate depth-stencil layouts.
891 for (uint32_t aspect_index = 0; aspect_index < 32; aspect_index++) {
892 VkImageAspectFlags test_aspect = 1u << aspect_index;
893 if ((img_barrier.subresourceRange.aspectMask & test_aspect) == 0) {
894 continue;
895 }
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -0600896 auto old_layout = NormalizeSynchronization2Layout(img_barrier.subresourceRange.aspectMask, img_barrier.oldLayout);
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600897
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -0600898 LayoutUseCheckAndMessage layout_check(old_layout, test_aspect);
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600899 auto normalized_isr = image_state->NormalizeSubresourceRange(img_barrier.subresourceRange);
900 normalized_isr.aspectMask = test_aspect;
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -0600901 skip |= read_subresource_map->AnyInRange(
902 normalized_isr, [this, cb_state, &layout_check, &loc, &img_barrier](const VkImageSubresource &subres,
903 const LayoutEntry &state) {
904 bool subres_skip = false;
905 if (!layout_check.Check(state)) {
906 const auto &vuid = GetImageBarrierVUID(loc, ImageError::kConflictingLayout);
907 subres_skip = LogError(
908 cb_state->commandBuffer(), vuid,
909 "%s %s cannot transition the layout of aspect=%d level=%d layer=%d from %s when the "
910 "%s layout is %s.",
911 loc.Message().c_str(), report_data->FormatHandle(img_barrier.image).c_str(), subres.aspectMask,
912 subres.mipLevel, subres.arrayLayer, string_VkImageLayout(img_barrier.oldLayout),
913 layout_check.message, string_VkImageLayout(layout_check.layout));
914 }
915 return subres_skip;
916 });
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600917 write_subresource_map->SetSubresourceRangeLayout(*cb_state, normalized_isr, img_barrier.newLayout);
918 }
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600919 }
920
921 // checks color format and (single-plane or non-disjoint)
922 // if ycbcr extension is not supported then single-plane and non-disjoint are always both true
923 if ((FormatIsColor(image_format) == true) &&
924 ((FormatIsMultiplane(image_format) == false) || (image_state->disjoint == false))) {
925 if (aspect_mask != VK_IMAGE_ASPECT_COLOR_BIT) {
926 auto error = IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion) ? ImageError::kNotColorAspect
927 : ImageError::kNotColorAspectYcbcr;
928 const auto &vuid = GetImageBarrierVUID(loc, error);
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700929 skip |= LogError(img_barrier.image, vuid,
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600930 "%s references %s of format %s that must be only VK_IMAGE_ASPECT_COLOR_BIT, "
931 "but its aspectMask is 0x%" PRIx32 ".",
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700932 image_loc.Message().c_str(), report_data->FormatHandle(img_barrier.image).c_str(),
sfricke-samsung79b00482020-04-01 21:15:50 -0700933 string_VkFormat(image_format), aspect_mask);
934 }
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600935 }
sfricke-samsung79b00482020-04-01 21:15:50 -0700936
Jeremy Gebben3d6fc342022-04-19 10:03:12 -0600937 VkImageAspectFlags valid_disjoint_mask =
938 VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT | VK_IMAGE_ASPECT_PLANE_2_BIT | VK_IMAGE_ASPECT_COLOR_BIT;
939 if ((FormatIsMultiplane(image_format) == true) && (image_state->disjoint == true) &&
940 ((aspect_mask & valid_disjoint_mask) == 0)) {
941 const auto &vuid = GetImageBarrierVUID(image_loc, ImageError::kBadMultiplanarAspect);
942 skip |= LogError(img_barrier.image, vuid,
943 "%s references %s of format %s has aspectMask (0x%" PRIx32
944 ") but needs to include either an VK_IMAGE_ASPECT_PLANE_*_BIT or VK_IMAGE_ASPECT_COLOR_BIT.",
945 image_loc.Message().c_str(), report_data->FormatHandle(img_barrier.image).c_str(),
946 string_VkFormat(image_format), aspect_mask);
947 }
948
949 if ((FormatPlaneCount(image_format) == 2) && ((aspect_mask & VK_IMAGE_ASPECT_PLANE_2_BIT) != 0)) {
950 const auto &vuid = GetImageBarrierVUID(image_loc, ImageError::kBadPlaneCount);
951 skip |= LogError(img_barrier.image, vuid,
952 "%s references %s of format %s has only two planes but included "
953 "VK_IMAGE_ASPECT_PLANE_2_BIT in its aspectMask (0x%" PRIx32 ").",
954 image_loc.Message().c_str(), report_data->FormatHandle(img_barrier.image).c_str(),
955 string_VkFormat(image_format), aspect_mask);
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -0700956 }
957 }
958 return skip;
959}
960
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700961template <typename Barrier, typename TransferBarrier>
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -0700962bool CoreChecks::ValidateQFOTransferBarrierUniqueness(const Location &loc, const CMD_BUFFER_STATE *cb_state, const Barrier &barrier,
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700963 const QFOTransferBarrierSets<TransferBarrier> &barrier_sets) const {
John Zulauf6b4aae82018-05-09 13:03:36 -0600964 bool skip = false;
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700965 const char *handle_name = TransferBarrier::HandleName();
John Zulauf6b4aae82018-05-09 13:03:36 -0600966 const char *transfer_type = nullptr;
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700967 if (!IsTransferOp(barrier)) {
968 return skip;
969 }
970 const TransferBarrier *barrier_record = nullptr;
Jeremy Gebben7ba56152021-06-18 10:40:10 -0600971 if (cb_state->IsReleaseOp(barrier) && !QueueFamilyIsExternal(barrier.dstQueueFamilyIndex)) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700972 const auto found = barrier_sets.release.find(barrier);
973 if (found != barrier_sets.release.cend()) {
974 barrier_record = &(*found);
975 transfer_type = "releasing";
John Zulauf6b4aae82018-05-09 13:03:36 -0600976 }
Jeremy Gebben7ba56152021-06-18 10:40:10 -0600977 } else if (cb_state->IsAcquireOp(barrier) && !QueueFamilyIsExternal(barrier.srcQueueFamilyIndex)) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700978 const auto found = barrier_sets.acquire.find(barrier);
979 if (found != barrier_sets.acquire.cend()) {
980 barrier_record = &(*found);
981 transfer_type = "acquiring";
John Zulauf6b4aae82018-05-09 13:03:36 -0600982 }
983 }
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700984 if (barrier_record != nullptr) {
985 skip |=
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -0600986 LogWarning(cb_state->commandBuffer(), TransferBarrier::ErrMsgDuplicateQFOInCB(),
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700987 "%s %s queue ownership of %s (%s), from srcQueueFamilyIndex %" PRIu32 " to dstQueueFamilyIndex %" PRIu32
988 " duplicates existing barrier recorded in this command buffer.",
989 loc.Message().c_str(), transfer_type, handle_name, report_data->FormatHandle(barrier_record->handle).c_str(),
990 barrier_record->srcQueueFamilyIndex, barrier_record->dstQueueFamilyIndex);
991 }
John Zulauf6b4aae82018-05-09 13:03:36 -0600992 return skip;
993}
994
John Zulaufa4472282019-08-22 14:44:34 -0600995VulkanTypedHandle BarrierTypedHandle(const VkImageMemoryBarrier &barrier) {
996 return VulkanTypedHandle(barrier.image, kVulkanObjectTypeImage);
997}
998
Jeremy Gebbene60d4172021-02-02 15:42:15 -0700999VulkanTypedHandle BarrierTypedHandle(const VkImageMemoryBarrier2KHR &barrier) {
1000 return VulkanTypedHandle(barrier.image, kVulkanObjectTypeImage);
1001}
1002
Jeremy Gebben9f537102021-10-05 16:37:12 -06001003std::shared_ptr<const IMAGE_STATE> BarrierHandleState(const ValidationStateTracker &device_state,
1004 const VkImageMemoryBarrier &barrier) {
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06001005 return device_state.Get<IMAGE_STATE>(barrier.image);
John Zulaufa4472282019-08-22 14:44:34 -06001006}
1007
Jeremy Gebben9f537102021-10-05 16:37:12 -06001008std::shared_ptr<const IMAGE_STATE> BarrierHandleState(const ValidationStateTracker &device_state,
1009 const VkImageMemoryBarrier2KHR &barrier) {
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06001010 return device_state.Get<IMAGE_STATE>(barrier.image);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001011}
1012
John Zulaufa4472282019-08-22 14:44:34 -06001013VulkanTypedHandle BarrierTypedHandle(const VkBufferMemoryBarrier &barrier) {
1014 return VulkanTypedHandle(barrier.buffer, kVulkanObjectTypeBuffer);
1015}
1016
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001017VulkanTypedHandle BarrierTypedHandle(const VkBufferMemoryBarrier2KHR &barrier) {
1018 return VulkanTypedHandle(barrier.buffer, kVulkanObjectTypeBuffer);
1019}
1020
Jeremy Gebben9f537102021-10-05 16:37:12 -06001021const std::shared_ptr<const BUFFER_STATE> BarrierHandleState(const ValidationStateTracker &device_state,
1022 const VkBufferMemoryBarrier &barrier) {
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06001023 return device_state.Get<BUFFER_STATE>(barrier.buffer);
John Zulaufa4472282019-08-22 14:44:34 -06001024}
1025
Jeremy Gebben9f537102021-10-05 16:37:12 -06001026std::shared_ptr<const BUFFER_STATE> BarrierHandleState(const ValidationStateTracker &device_state,
1027 const VkBufferMemoryBarrier2KHR &barrier) {
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06001028 return device_state.Get<BUFFER_STATE>(barrier.buffer);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001029}
John Zulaufa4472282019-08-22 14:44:34 -06001030
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001031template <typename Barrier, typename TransferBarrier>
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07001032void CoreChecks::RecordBarrierValidationInfo(const Location &loc, CMD_BUFFER_STATE *cb_state, const Barrier &barrier,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001033 QFOTransferBarrierSets<TransferBarrier> &barrier_sets) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001034 if (IsTransferOp(barrier)) {
Jeremy Gebben7ba56152021-06-18 10:40:10 -06001035 if (cb_state->IsReleaseOp(barrier) && !QueueFamilyIsExternal(barrier.dstQueueFamilyIndex)) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001036 barrier_sets.release.emplace(barrier);
Jeremy Gebben7ba56152021-06-18 10:40:10 -06001037 } else if (cb_state->IsAcquireOp(barrier) && !QueueFamilyIsExternal(barrier.srcQueueFamilyIndex)) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001038 barrier_sets.acquire.emplace(barrier);
John Zulaufa4472282019-08-22 14:44:34 -06001039 }
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001040 }
John Zulaufa4472282019-08-22 14:44:34 -06001041
David Zhao Akeleyd76df472021-05-15 17:25:59 -07001042 // 7.7.4: If the values of srcQueueFamilyIndex and dstQueueFamilyIndex are equal, no ownership transfer is performed, and the
1043 // barrier operates as if they were both set to VK_QUEUE_FAMILY_IGNORED.
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001044 const uint32_t src_queue_family = barrier.srcQueueFamilyIndex;
1045 const uint32_t dst_queue_family = barrier.dstQueueFamilyIndex;
David Zhao Akeleyd76df472021-05-15 17:25:59 -07001046 const bool is_ownership_transfer = src_queue_family != dst_queue_family;
1047
1048 if (is_ownership_transfer) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001049 // Only enqueue submit time check if it is needed. If more submit time checks are added, change the criteria
1050 // TODO create a better named list, or rename the submit time lists to something that matches the broader usage...
1051 auto handle_state = BarrierHandleState(*this, barrier);
1052 bool mode_concurrent = handle_state ? handle_state->createInfo.sharingMode == VK_SHARING_MODE_CONCURRENT : false;
1053 if (!mode_concurrent) {
1054 const auto typed_handle = BarrierTypedHandle(barrier);
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07001055 core_error::LocationCapture loc_capture(loc);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001056 cb_state->queue_submit_functions.emplace_back(
Jeremy Gebbene5361dd2021-11-18 14:23:56 -07001057 [loc_capture, typed_handle, src_queue_family, dst_queue_family](
1058 const ValidationStateTracker &device_data, const QUEUE_STATE &queue_state, const CMD_BUFFER_STATE &cb_state) {
John Zulaufb4438f02021-02-20 20:22:16 -07001059 return ValidateConcurrentBarrierAtSubmit(loc_capture.Get(), device_data, queue_state, cb_state, typed_handle,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001060 src_queue_family, dst_queue_family);
1061 });
John Zulauf6b4aae82018-05-09 13:03:36 -06001062 }
1063 }
1064}
1065
Jeremy Gebben50e0b412021-02-18 10:39:41 -07001066// Verify image barrier image state and that the image is consistent with FB image
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001067template <typename ImgBarrier>
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07001068bool CoreChecks::ValidateImageBarrierAttachment(const Location &loc, CMD_BUFFER_STATE const *cb_state,
Jeremy Gebben50e0b412021-02-18 10:39:41 -07001069 const FRAMEBUFFER_STATE *framebuffer, uint32_t active_subpass,
1070 const safe_VkSubpassDescription2 &sub_desc, const VkRenderPass rp_handle,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001071 const ImgBarrier &img_barrier, const CMD_BUFFER_STATE *primary_cb_state) const {
1072 using sync_vuid_maps::GetImageBarrierVUID;
1073 using sync_vuid_maps::ImageError;
1074
Jeremy Gebben50e0b412021-02-18 10:39:41 -07001075 bool skip = false;
1076 const auto *fb_state = framebuffer;
1077 assert(fb_state);
1078 const auto img_bar_image = img_barrier.image;
1079 bool image_match = false;
1080 bool sub_image_found = false; // Do we find a corresponding subpass description
1081 VkImageLayout sub_image_layout = VK_IMAGE_LAYOUT_UNDEFINED;
1082 uint32_t attach_index = 0;
1083 // Verify that a framebuffer image matches barrier image
1084 const auto attachment_count = fb_state->createInfo.attachmentCount;
1085 for (uint32_t attachment = 0; attachment < attachment_count; ++attachment) {
Jeremy Gebben9efe1cf2021-05-15 20:05:09 -06001086 auto view_state = primary_cb_state ? primary_cb_state->GetActiveAttachmentImageViewState(attachment) : cb_state->GetActiveAttachmentImageViewState(attachment);
Jeremy Gebben50e0b412021-02-18 10:39:41 -07001087 if (view_state && (img_bar_image == view_state->create_info.image)) {
1088 image_match = true;
1089 attach_index = attachment;
1090 break;
1091 }
1092 }
1093 if (image_match) { // Make sure subpass is referring to matching attachment
1094 if (sub_desc.pDepthStencilAttachment && sub_desc.pDepthStencilAttachment->attachment == attach_index) {
1095 sub_image_layout = sub_desc.pDepthStencilAttachment->layout;
1096 sub_image_found = true;
1097 }
sfricke-samsung45996a42021-09-16 13:45:27 -07001098 if (!sub_image_found && IsExtEnabled(device_extensions.vk_khr_depth_stencil_resolve)) {
Jeremy Gebben50e0b412021-02-18 10:39:41 -07001099 const auto *resolve = LvlFindInChain<VkSubpassDescriptionDepthStencilResolve>(sub_desc.pNext);
1100 if (resolve && resolve->pDepthStencilResolveAttachment &&
1101 resolve->pDepthStencilResolveAttachment->attachment == attach_index) {
1102 sub_image_layout = resolve->pDepthStencilResolveAttachment->layout;
1103 sub_image_found = true;
1104 }
1105 }
1106 if (!sub_image_found) {
1107 for (uint32_t j = 0; j < sub_desc.colorAttachmentCount; ++j) {
1108 if (sub_desc.pColorAttachments && sub_desc.pColorAttachments[j].attachment == attach_index) {
1109 sub_image_layout = sub_desc.pColorAttachments[j].layout;
1110 sub_image_found = true;
1111 break;
1112 }
1113 if (!sub_image_found && sub_desc.pResolveAttachments &&
1114 sub_desc.pResolveAttachments[j].attachment == attach_index) {
1115 sub_image_layout = sub_desc.pResolveAttachments[j].layout;
1116 sub_image_found = true;
1117 break;
1118 }
1119 }
1120 }
1121 if (!sub_image_found) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001122 auto img_loc = loc.dot(Field::image);
1123 const auto &vuid = GetImageBarrierVUID(img_loc, ImageError::kRenderPassMismatch);
1124 skip |=
1125 LogError(rp_handle, vuid,
1126 "%s Barrier for %s is not referenced by the VkSubpassDescription for active subpass (%d) of current %s.",
1127 img_loc.Message().c_str(), report_data->FormatHandle(img_bar_image).c_str(), active_subpass,
1128 report_data->FormatHandle(rp_handle).c_str());
Jeremy Gebben50e0b412021-02-18 10:39:41 -07001129 }
1130 } else { // !image_match
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001131 auto img_loc = loc.dot(Field::image);
1132 const auto &vuid = GetImageBarrierVUID(img_loc, ImageError::kRenderPassMismatch);
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06001133 skip |= LogError(fb_state->framebuffer(), vuid, "%s Barrier for %s does not match an image from the current %s.",
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001134 img_loc.Message().c_str(), report_data->FormatHandle(img_bar_image).c_str(),
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06001135 report_data->FormatHandle(fb_state->framebuffer()).c_str());
Jeremy Gebben50e0b412021-02-18 10:39:41 -07001136 }
1137 if (img_barrier.oldLayout != img_barrier.newLayout) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001138 auto layout_loc = loc.dot(Field::oldLayout);
1139 const auto &vuid = GetImageBarrierVUID(layout_loc, ImageError::kRenderPassLayoutChange);
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06001140 skip |= LogError(cb_state->commandBuffer(), vuid,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001141 "%s As the Image Barrier for %s is being executed within a render pass instance, oldLayout must "
Jeremy Gebben50e0b412021-02-18 10:39:41 -07001142 "equal newLayout yet they are %s and %s.",
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001143 layout_loc.Message().c_str(), report_data->FormatHandle(img_barrier.image).c_str(),
Jeremy Gebben50e0b412021-02-18 10:39:41 -07001144 string_VkImageLayout(img_barrier.oldLayout), string_VkImageLayout(img_barrier.newLayout));
1145 } else {
1146 if (sub_image_found && sub_image_layout != img_barrier.oldLayout) {
1147 LogObjectList objlist(rp_handle);
1148 objlist.add(img_bar_image);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001149 auto layout_loc = loc.dot(Field::oldLayout);
1150 const auto &vuid = GetImageBarrierVUID(layout_loc, ImageError::kRenderPassLayoutChange);
1151 skip |= LogError(objlist, vuid,
1152 "%s Barrier for %s is referenced by the VkSubpassDescription for active "
Jeremy Gebben50e0b412021-02-18 10:39:41 -07001153 "subpass (%d) of current %s as having layout %s, but image barrier has layout %s.",
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001154 layout_loc.Message().c_str(), report_data->FormatHandle(img_bar_image).c_str(), active_subpass,
Jeremy Gebben50e0b412021-02-18 10:39:41 -07001155 report_data->FormatHandle(rp_handle).c_str(), string_VkImageLayout(sub_image_layout),
1156 string_VkImageLayout(img_barrier.oldLayout));
1157 }
1158 }
1159 return skip;
1160}
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001161// explictly instantiate so these can be used in core_validation.cpp
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07001162template bool CoreChecks::ValidateImageBarrierAttachment(const Location &loc, CMD_BUFFER_STATE const *cb_state,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001163 const FRAMEBUFFER_STATE *framebuffer, uint32_t active_subpass,
1164 const safe_VkSubpassDescription2 &sub_desc, const VkRenderPass rp_handle,
1165 const VkImageMemoryBarrier &img_barrier,
1166 const CMD_BUFFER_STATE *primary_cb_state) const;
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07001167template bool CoreChecks::ValidateImageBarrierAttachment(const Location &loc, CMD_BUFFER_STATE const *cb_state,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001168 const FRAMEBUFFER_STATE *framebuffer, uint32_t active_subpass,
1169 const safe_VkSubpassDescription2 &sub_desc, const VkRenderPass rp_handle,
1170 const VkImageMemoryBarrier2KHR &img_barrier,
1171 const CMD_BUFFER_STATE *primary_cb_state) const;
Jeremy Gebben50e0b412021-02-18 10:39:41 -07001172
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001173template <typename ImgBarrier>
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07001174void CoreChecks::EnqueueSubmitTimeValidateImageBarrierAttachment(const Location &loc, CMD_BUFFER_STATE *cb_state,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001175 const ImgBarrier &barrier) {
Jeremy Gebben50e0b412021-02-18 10:39:41 -07001176 // Secondary CBs can have null framebuffer so queue up validation in that case 'til FB is known
1177 if ((cb_state->activeRenderPass) && (VK_NULL_HANDLE == cb_state->activeFramebuffer) &&
1178 (VK_COMMAND_BUFFER_LEVEL_SECONDARY == cb_state->createInfo.level)) {
1179 const auto active_subpass = cb_state->activeSubpass;
1180 const auto rp_state = cb_state->activeRenderPass;
1181 const auto &sub_desc = rp_state->createInfo.pSubpasses[active_subpass];
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001182 // Secondary CB case w/o FB specified delay validation
1183 auto *this_ptr = this; // Required for older compilers with c++20 compatibility
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07001184 core_error::LocationCapture loc_capture(loc);
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06001185 const auto render_pass = rp_state->renderPass();
John Zulaufb4438f02021-02-20 20:22:16 -07001186 cb_state->cmd_execute_commands_functions.emplace_back(
Jeremy Gebben057f9d52021-11-05 14:12:31 -06001187 [this_ptr, loc_capture, active_subpass, sub_desc, render_pass, barrier](
1188 const CMD_BUFFER_STATE &secondary_cb, const CMD_BUFFER_STATE *primary_cb, const FRAMEBUFFER_STATE *fb) {
1189 return this_ptr->ValidateImageBarrierAttachment(loc_capture.Get(), &secondary_cb, fb, active_subpass, sub_desc,
John Zulaufb4438f02021-02-20 20:22:16 -07001190 render_pass, barrier, primary_cb);
1191 });
Jeremy Gebben50e0b412021-02-18 10:39:41 -07001192 }
1193}
1194
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07001195void CoreChecks::RecordBarriers(Func func_name, CMD_BUFFER_STATE *cb_state, uint32_t bufferBarrierCount,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001196 const VkBufferMemoryBarrier *pBufferMemBarriers, uint32_t imageMemBarrierCount,
1197 const VkImageMemoryBarrier *pImageMemBarriers) {
1198 for (uint32_t i = 0; i < bufferBarrierCount; i++) {
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07001199 Location loc(func_name, Struct::VkBufferMemoryBarrier, Field::pBufferMemoryBarriers, i);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001200 RecordBarrierValidationInfo(loc, cb_state, pBufferMemBarriers[i], cb_state->qfo_transfer_buffer_barriers);
1201 }
1202 for (uint32_t i = 0; i < imageMemBarrierCount; i++) {
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07001203 Location loc(func_name, Struct::VkImageMemoryBarrier, Field::pImageMemoryBarriers, i);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001204 const auto &img_barrier = pImageMemBarriers[i];
1205 RecordBarrierValidationInfo(loc, cb_state, img_barrier, cb_state->qfo_transfer_image_barriers);
1206 EnqueueSubmitTimeValidateImageBarrierAttachment(loc, cb_state, img_barrier);
1207 }
1208}
1209
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07001210void CoreChecks::RecordBarriers(Func func_name, CMD_BUFFER_STATE *cb_state, const VkDependencyInfoKHR &dep_info) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001211 for (uint32_t i = 0; i < dep_info.bufferMemoryBarrierCount; i++) {
Tony-LunarG279601c2021-11-16 10:50:51 -07001212 Location loc(func_name, Struct::VkBufferMemoryBarrier2, Field::pBufferMemoryBarriers, i);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001213 RecordBarrierValidationInfo(loc, cb_state, dep_info.pBufferMemoryBarriers[i], cb_state->qfo_transfer_buffer_barriers);
1214 }
1215 for (uint32_t i = 0; i < dep_info.imageMemoryBarrierCount; i++) {
Tony-LunarG279601c2021-11-16 10:50:51 -07001216 Location loc(func_name, Struct::VkImageMemoryBarrier2, Field::pImageMemoryBarriers, i);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001217 const auto &img_barrier = dep_info.pImageMemoryBarriers[i];
1218 RecordBarrierValidationInfo(loc, cb_state, img_barrier, cb_state->qfo_transfer_image_barriers);
1219 EnqueueSubmitTimeValidateImageBarrierAttachment(loc, cb_state, img_barrier);
1220 }
1221}
1222
1223template <typename TransferBarrier, typename Scoreboard>
Mark Lobodzinski33a34b82019-04-25 11:38:36 -06001224bool CoreChecks::ValidateAndUpdateQFOScoreboard(const debug_report_data *report_data, const CMD_BUFFER_STATE *cb_state,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001225 const char *operation, const TransferBarrier &barrier,
1226 Scoreboard *scoreboard) const {
John Zulauf6b4aae82018-05-09 13:03:36 -06001227 // Record to the scoreboard or report that we have a duplication
1228 bool skip = false;
Jeremy Gebbencbf22862021-03-03 12:01:22 -07001229 auto inserted = scoreboard->emplace(barrier, cb_state);
John Zulauf6b4aae82018-05-09 13:03:36 -06001230 if (!inserted.second && inserted.first->second != cb_state) {
1231 // This is a duplication (but don't report duplicates from the same CB, as we do that at record time
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06001232 LogObjectList objlist(cb_state->commandBuffer());
Mark Lobodzinskiea561582020-03-16 18:13:56 -06001233 objlist.add(barrier.handle);
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06001234 objlist.add(inserted.first->second->commandBuffer());
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001235 skip = LogWarning(objlist, TransferBarrier::ErrMsgDuplicateQFOInSubmit(),
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001236 "%s: %s %s queue ownership of %s (%s), from srcQueueFamilyIndex %" PRIu32
1237 " to dstQueueFamilyIndex %" PRIu32 " duplicates existing barrier submitted in this batch from %s.",
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001238 "vkQueueSubmit()", TransferBarrier::BarrierName(), operation, TransferBarrier::HandleName(),
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001239 report_data->FormatHandle(barrier.handle).c_str(), barrier.srcQueueFamilyIndex,
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06001240 barrier.dstQueueFamilyIndex, report_data->FormatHandle(inserted.first->second->commandBuffer()).c_str());
John Zulauf6b4aae82018-05-09 13:03:36 -06001241 }
1242 return skip;
1243}
1244
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001245template <typename TransferBarrier>
1246bool CoreChecks::ValidateQueuedQFOTransferBarriers(
1247 const CMD_BUFFER_STATE *cb_state, QFOTransferCBScoreboards<TransferBarrier> *scoreboards,
1248 const GlobalQFOTransferBarrierMap<TransferBarrier> &global_release_barriers) const {
John Zulauf6b4aae82018-05-09 13:03:36 -06001249 bool skip = false;
Jeremy Gebben159b3cc2021-06-03 09:09:03 -06001250 const auto &cb_barriers = cb_state->GetQFOBarrierSets(TransferBarrier());
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001251 const char *barrier_name = TransferBarrier::BarrierName();
1252 const char *handle_name = TransferBarrier::HandleName();
John Zulauf6b4aae82018-05-09 13:03:36 -06001253 // No release should have an extant duplicate (WARNING)
1254 for (const auto &release : cb_barriers.release) {
1255 // Check the global pending release barriers
1256 const auto set_it = global_release_barriers.find(release.handle);
1257 if (set_it != global_release_barriers.cend()) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001258 const QFOTransferBarrierSet<TransferBarrier> &set_for_handle = set_it->second;
John Zulauf6b4aae82018-05-09 13:03:36 -06001259 const auto found = set_for_handle.find(release);
1260 if (found != set_for_handle.cend()) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06001261 skip |= LogWarning(cb_state->commandBuffer(), TransferBarrier::ErrMsgDuplicateQFOSubmitted(),
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001262 "%s: %s releasing queue ownership of %s (%s), from srcQueueFamilyIndex %" PRIu32
1263 " to dstQueueFamilyIndex %" PRIu32
1264 " duplicates existing barrier queued for execution, without intervening acquire operation.",
1265 "vkQueueSubmit()", barrier_name, handle_name, report_data->FormatHandle(found->handle).c_str(),
1266 found->srcQueueFamilyIndex, found->dstQueueFamilyIndex);
John Zulauf6b4aae82018-05-09 13:03:36 -06001267 }
1268 }
1269 skip |= ValidateAndUpdateQFOScoreboard(report_data, cb_state, "releasing", release, &scoreboards->release);
1270 }
1271 // Each acquire must have a matching release (ERROR)
1272 for (const auto &acquire : cb_barriers.acquire) {
1273 const auto set_it = global_release_barriers.find(acquire.handle);
1274 bool matching_release_found = false;
1275 if (set_it != global_release_barriers.cend()) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001276 const QFOTransferBarrierSet<TransferBarrier> &set_for_handle = set_it->second;
John Zulauf6b4aae82018-05-09 13:03:36 -06001277 matching_release_found = set_for_handle.find(acquire) != set_for_handle.cend();
1278 }
1279 if (!matching_release_found) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06001280 skip |= LogError(cb_state->commandBuffer(), TransferBarrier::ErrMsgMissingQFOReleaseInSubmit(),
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001281 "%s: in submitted command buffer %s acquiring ownership of %s (%s), from srcQueueFamilyIndex %" PRIu32
1282 " to dstQueueFamilyIndex %" PRIu32 " has no matching release barrier queued for execution.",
1283 "vkQueueSubmit()", barrier_name, handle_name, report_data->FormatHandle(acquire.handle).c_str(),
1284 acquire.srcQueueFamilyIndex, acquire.dstQueueFamilyIndex);
John Zulauf6b4aae82018-05-09 13:03:36 -06001285 }
1286 skip |= ValidateAndUpdateQFOScoreboard(report_data, cb_state, "acquiring", acquire, &scoreboards->acquire);
1287 }
1288 return skip;
1289}
1290
John Zulauf3b04ebd2019-07-18 14:08:11 -06001291bool CoreChecks::ValidateQueuedQFOTransfers(const CMD_BUFFER_STATE *cb_state,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001292 QFOTransferCBScoreboards<QFOImageTransferBarrier> *qfo_image_scoreboards,
1293 QFOTransferCBScoreboards<QFOBufferTransferBarrier> *qfo_buffer_scoreboards) const {
John Zulauf6b4aae82018-05-09 13:03:36 -06001294 bool skip = false;
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001295 skip |=
1296 ValidateQueuedQFOTransferBarriers<QFOImageTransferBarrier>(cb_state, qfo_image_scoreboards, qfo_release_image_barrier_map);
1297 skip |= ValidateQueuedQFOTransferBarriers<QFOBufferTransferBarrier>(cb_state, qfo_buffer_scoreboards,
1298 qfo_release_buffer_barrier_map);
John Zulauf6b4aae82018-05-09 13:03:36 -06001299 return skip;
1300}
1301
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001302template <typename TransferBarrier>
1303void RecordQueuedQFOTransferBarriers(QFOTransferBarrierSets<TransferBarrier> &cb_barriers,
1304 GlobalQFOTransferBarrierMap<TransferBarrier> &global_release_barriers) {
John Zulauf6b4aae82018-05-09 13:03:36 -06001305 // Add release barriers from this submit to the global map
1306 for (const auto &release : cb_barriers.release) {
1307 // the global barrier list is mapped by resource handle to allow cleanup on resource destruction
Jeremy Gebben51499ca2022-01-11 08:36:13 -07001308 // NOTE: vl_concurrent_ordered_map::find() makes a thread safe copy of the result, so we must
1309 // copy back after updating.
1310 auto iter = global_release_barriers.find(release.handle);
1311 iter->second.insert(release);
1312 global_release_barriers.insert_or_assign(release.handle, iter->second);
John Zulauf6b4aae82018-05-09 13:03:36 -06001313 }
1314
1315 // Erase acquired barriers from this submit from the global map -- essentially marking releases as consumed
1316 for (const auto &acquire : cb_barriers.acquire) {
1317 // NOTE: We're not using [] because we don't want to create entries for missing releases
1318 auto set_it = global_release_barriers.find(acquire.handle);
1319 if (set_it != global_release_barriers.end()) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001320 QFOTransferBarrierSet<TransferBarrier> &set_for_handle = set_it->second;
John Zulauf6b4aae82018-05-09 13:03:36 -06001321 set_for_handle.erase(acquire);
1322 if (set_for_handle.size() == 0) { // Clean up empty sets
Jeremy Gebben51499ca2022-01-11 08:36:13 -07001323 global_release_barriers.erase(acquire.handle);
1324 } else {
1325 // NOTE: vl_concurrent_ordered_map::find() makes a thread safe copy of the result, so we must
1326 // copy back after updating.
1327 global_release_barriers.insert_or_assign(acquire.handle, set_for_handle);
John Zulauf6b4aae82018-05-09 13:03:36 -06001328 }
1329 }
1330 }
1331}
1332
Mark Lobodzinski33a34b82019-04-25 11:38:36 -06001333void CoreChecks::RecordQueuedQFOTransfers(CMD_BUFFER_STATE *cb_state) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001334 RecordQueuedQFOTransferBarriers<QFOImageTransferBarrier>(cb_state->qfo_transfer_image_barriers, qfo_release_image_barrier_map);
1335 RecordQueuedQFOTransferBarriers<QFOBufferTransferBarrier>(cb_state->qfo_transfer_buffer_barriers,
1336 qfo_release_buffer_barrier_map);
John Zulauf6b4aae82018-05-09 13:03:36 -06001337}
1338
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001339template <typename ImgBarrier>
1340void CoreChecks::TransitionImageLayouts(CMD_BUFFER_STATE *cb_state, uint32_t barrier_count, const ImgBarrier *barriers) {
1341 // For ownership transfers, the barrier is specified twice; as a release
1342 // operation on the yielding queue family, and as an acquire operation
1343 // on the acquiring queue family. This barrier may also include a layout
1344 // transition, which occurs 'between' the two operations. For validation
1345 // purposes it doesn't seem important which side performs the layout
1346 // transition, but it must not be performed twice. We'll arbitrarily
1347 // choose to perform it as part of the acquire operation.
1348 //
1349 // However, we still need to record initial layout for the "initial layout" validation
1350 for (uint32_t i = 0; i < barrier_count; i++) {
1351 const auto &mem_barrier = barriers[i];
Jeremy Gebbenefead332021-06-18 08:22:44 -06001352 const bool is_release_op = cb_state->IsReleaseOp(mem_barrier);
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06001353 auto image_state = Get<IMAGE_STATE>(mem_barrier.image);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001354 if (image_state) {
Jeremy Gebben9f537102021-10-05 16:37:12 -06001355 RecordTransitionImageLayout(cb_state, image_state.get(), mem_barrier, is_release_op);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001356 }
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -07001357 }
1358}
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001359// explictly instantiate this template so it can be used in core_validation.cpp
1360template void CoreChecks::TransitionImageLayouts(CMD_BUFFER_STATE *cb_state, uint32_t barrier_count,
1361 const VkImageMemoryBarrier *barrier);
1362template void CoreChecks::TransitionImageLayouts(CMD_BUFFER_STATE *cb_state, uint32_t barrier_count,
1363 const VkImageMemoryBarrier2KHR *barrier);
Mark Lobodzinski6b6c50a2017-02-27 12:56:14 -07001364
Jeremy Gebben579aaca2021-02-15 13:36:18 -07001365VkImageLayout NormalizeSynchronization2Layout(const VkImageAspectFlags aspect_mask, VkImageLayout layout);
1366
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001367template <typename ImgBarrier>
unknown86bcb3a2019-07-11 13:05:36 -06001368void CoreChecks::RecordTransitionImageLayout(CMD_BUFFER_STATE *cb_state, const IMAGE_STATE *image_state,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07001369 const ImgBarrier &mem_barrier, bool is_release_op) {
Tony-LunarG273f32f2021-09-28 08:56:30 -06001370 if (enabled_features.core13.synchronization2) {
Jeremy Gebben579aaca2021-02-15 13:36:18 -07001371 if (mem_barrier.oldLayout == mem_barrier.newLayout) {
1372 return;
1373 }
1374 }
Jeremy Gebben1dfbd172021-05-19 14:00:58 -06001375 auto normalized_isr = image_state->NormalizeSubresourceRange(mem_barrier.subresourceRange);
unknown86bcb3a2019-07-11 13:05:36 -06001376
Jeremy Gebben579aaca2021-02-15 13:36:18 -07001377 VkImageLayout initial_layout = NormalizeSynchronization2Layout(mem_barrier.subresourceRange.aspectMask, mem_barrier.oldLayout);
1378 VkImageLayout new_layout = NormalizeSynchronization2Layout(mem_barrier.subresourceRange.aspectMask, mem_barrier.newLayout);
Michael Spang8af7c102020-05-03 20:50:09 -04001379
1380 // Layout transitions in external instance are not tracked, so don't validate initial layout.
John Zulaufcea64cb2020-06-10 17:17:27 -06001381 if (QueueFamilyIsExternal(mem_barrier.srcQueueFamilyIndex)) {
Michael Spang8af7c102020-05-03 20:50:09 -04001382 initial_layout = VK_IMAGE_LAYOUT_UNDEFINED;
1383 }
1384
John Zulauf2be3fe02019-12-30 09:48:02 -07001385 if (is_release_op) {
Jeremy Gebben1ec89332021-08-05 13:51:49 -06001386 cb_state->SetImageInitialLayout(*image_state, normalized_isr, initial_layout);
John Zulauf2be3fe02019-12-30 09:48:02 -07001387 } else {
Jeremy Gebben1ec89332021-08-05 13:51:49 -06001388 cb_state->SetImageLayout(*image_state, normalized_isr, new_layout, initial_layout);
John Zulauf2be3fe02019-12-30 09:48:02 -07001389 }
unknown86bcb3a2019-07-11 13:05:36 -06001390}
1391
John Zulauf15578df2022-06-02 13:50:03 -06001392template <typename RangeFactory>
1393bool CoreChecks::VerifyImageLayoutRange(const CMD_BUFFER_STATE &cb_node, const IMAGE_STATE &image_state,
1394 VkImageAspectFlags aspect_mask, VkImageLayout explicit_layout,
1395 const RangeFactory &range_factory, const char *caller, const char *layout_mismatch_msg_code,
1396 bool *error) const {
1397 bool skip = false;
1398 const auto *subresource_map = cb_node.GetImageSubresourceLayoutMap(image_state);
1399 if (!subresource_map) return skip;
1400
1401 LayoutUseCheckAndMessage layout_check(explicit_layout, aspect_mask);
1402 skip |= subresource_map->AnyInRange(
1403 range_factory(*subresource_map), [this, &cb_node, &image_state, &layout_check, layout_mismatch_msg_code, caller, error](
1404 const VkImageSubresource &subres, const LayoutEntry &state) {
1405 bool subres_skip = false;
1406 if (!layout_check.Check(state)) {
1407 *error = true;
1408 subres_skip |= LogError(cb_node.commandBuffer(), layout_mismatch_msg_code,
1409 "%s: Cannot use %s (layer=%u mip=%u) with specific layout %s that doesn't match the "
1410 "%s layout %s.",
1411 caller, report_data->FormatHandle(image_state.Handle()).c_str(), subres.arrayLayer,
1412 subres.mipLevel, string_VkImageLayout(layout_check.expected_layout), layout_check.message,
1413 string_VkImageLayout(layout_check.layout));
1414 }
1415 return subres_skip;
1416 });
1417
1418 return skip;
1419}
1420
John Zulaufe2b7bcb2019-07-05 16:08:39 -06001421bool CoreChecks::VerifyImageLayout(const CMD_BUFFER_STATE *cb_node, const IMAGE_STATE *image_state,
1422 const VkImageSubresourceRange &range, VkImageAspectFlags aspect_mask,
1423 VkImageLayout explicit_layout, VkImageLayout optimal_layout, const char *caller,
1424 const char *layout_invalid_msg_code, const char *layout_mismatch_msg_code, bool *error) const {
Mark Lobodzinski90eea5b2020-05-15 12:54:00 -06001425 if (disabled[image_layout_validation]) return false;
John Zulauff660ad62019-03-23 07:16:05 -06001426 assert(cb_node);
1427 assert(image_state);
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -06001428 bool skip = false;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001429
John Zulauf15578df2022-06-02 13:50:03 -06001430 VkImageSubresourceRange normalized_isr = image_state->NormalizeSubresourceRange(range);
1431 auto range_factory = [&normalized_isr](const ImageSubresourceLayoutMap &map) {
1432 return map.RangeGen(normalized_isr);
1433 };
1434 skip |= VerifyImageLayoutRange(*cb_node, *image_state, aspect_mask, explicit_layout, range_factory, caller,
1435 layout_mismatch_msg_code, error);
John Zulauff660ad62019-03-23 07:16:05 -06001436
Tobin Ehlis2d85ec62017-03-14 15:38:48 -06001437 // If optimal_layout is not UNDEFINED, check that layout matches optimal for this case
1438 if ((VK_IMAGE_LAYOUT_UNDEFINED != optimal_layout) && (explicit_layout != optimal_layout)) {
1439 if (VK_IMAGE_LAYOUT_GENERAL == explicit_layout) {
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001440 if (image_state->createInfo.tiling != VK_IMAGE_TILING_LINEAR) {
1441 // LAYOUT_GENERAL is allowed, but may not be performance optimal, flag as perf warning.
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06001442 skip |= LogPerformanceWarning(cb_node->commandBuffer(), kVUID_Core_DrawState_InvalidImageLayout,
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001443 "%s: For optimal performance %s layout should be %s instead of GENERAL.", caller,
Jeremy Gebben6335df62021-11-01 10:50:13 -06001444 report_data->FormatHandle(image_state->Handle()).c_str(),
1445 string_VkImageLayout(optimal_layout));
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001446 }
sfricke-samsung45996a42021-09-16 13:45:27 -07001447 } else if (IsExtEnabled(device_extensions.vk_khr_shared_presentable_image)) {
Mark Lobodzinski087380c2017-05-16 14:42:25 -06001448 if (image_state->shared_presentable) {
1449 if (VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR != explicit_layout) {
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07001450 skip |=
1451 LogError(device, layout_invalid_msg_code,
1452 "%s: Layout for shared presentable image is %s but must be VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR.",
1453 caller, string_VkImageLayout(optimal_layout));
Mark Lobodzinski087380c2017-05-16 14:42:25 -06001454 }
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -06001455 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001456 } else {
Tobin Ehlisc8266452017-04-07 12:20:30 -06001457 *error = true;
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06001458 skip |= LogError(cb_node->commandBuffer(), layout_invalid_msg_code,
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001459 "%s: Layout for %s is %s but can only be %s or VK_IMAGE_LAYOUT_GENERAL.", caller,
Jeremy Gebben6335df62021-11-01 10:50:13 -06001460 report_data->FormatHandle(image_state->Handle()).c_str(), string_VkImageLayout(explicit_layout),
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001461 string_VkImageLayout(optimal_layout));
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001462 }
1463 }
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -06001464 return skip;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001465}
John Zulaufe2b7bcb2019-07-05 16:08:39 -06001466bool CoreChecks::VerifyImageLayout(const CMD_BUFFER_STATE *cb_node, const IMAGE_STATE *image_state,
John Zulauff660ad62019-03-23 07:16:05 -06001467 const VkImageSubresourceLayers &subLayers, VkImageLayout explicit_layout,
1468 VkImageLayout optimal_layout, const char *caller, const char *layout_invalid_msg_code,
John Zulaufe2b7bcb2019-07-05 16:08:39 -06001469 const char *layout_mismatch_msg_code, bool *error) const {
John Zulauff660ad62019-03-23 07:16:05 -06001470 return VerifyImageLayout(cb_node, image_state, RangeFromLayers(subLayers), explicit_layout, optimal_layout, caller,
1471 layout_invalid_msg_code, layout_mismatch_msg_code, error);
1472}
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001473
Jeremy Gebbene7b99fc2022-06-02 08:44:33 -06001474bool CoreChecks::VerifyImageLayout(const CMD_BUFFER_STATE *cb_node, const IMAGE_VIEW_STATE *image_view_state,
1475 VkImageLayout explicit_layout, const char *caller, const char *layout_mismatch_msg_code,
1476 bool *error) const {
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -06001477 if (disabled[image_layout_validation]) return false;
1478 assert(cb_node);
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -06001479 assert(image_view_state);
John Zulauf15578df2022-06-02 13:50:03 -06001480 assert(image_view_state->image_state);
1481 auto range_factory = [image_view_state](const ImageSubresourceLayoutMap &map) {
1482 return image_layout_map::RangeGenerator(image_view_state->range_generator);
1483 };
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -06001484
John Zulauf15578df2022-06-02 13:50:03 -06001485 return VerifyImageLayoutRange(*cb_node, *image_view_state->image_state.get(),
1486 image_view_state->create_info.subresourceRange.aspectMask, explicit_layout, range_factory, caller,
1487 layout_mismatch_msg_code, error);
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -06001488}
1489
Mark Lobodzinski33a34b82019-04-25 11:38:36 -06001490void CoreChecks::TransitionFinalSubpassLayouts(CMD_BUFFER_STATE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin,
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001491 FRAMEBUFFER_STATE *framebuffer_state) {
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06001492 auto render_pass = Get<RENDER_PASS_STATE>(pRenderPassBegin->renderPass);
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07001493 if (!render_pass) return;
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001494
Mike Schuchardt2df08912020-12-15 16:28:09 -08001495 const VkRenderPassCreateInfo2 *render_pass_info = render_pass->createInfo.ptr();
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001496 if (framebuffer_state) {
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07001497 for (uint32_t i = 0; i < render_pass_info->attachmentCount; ++i) {
Jeremy Gebben9efe1cf2021-05-15 20:05:09 -06001498 auto *view_state = pCB->GetActiveAttachmentImageViewState(i);
John Zulauf8e308292018-09-21 11:34:37 -06001499 if (view_state) {
Piers Daniell4fde9b72019-11-27 16:19:46 -07001500 VkImageLayout stencil_layout = kInvalidLayout;
1501 const auto *attachment_description_stencil_layout =
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07001502 LvlFindInChain<VkAttachmentDescriptionStencilLayout>(render_pass_info->pAttachments[i].pNext);
Piers Daniell4fde9b72019-11-27 16:19:46 -07001503 if (attachment_description_stencil_layout) {
1504 stencil_layout = attachment_description_stencil_layout->stencilFinalLayout;
1505 }
Jeremy Gebben1ec89332021-08-05 13:51:49 -06001506 pCB->SetImageViewLayout(*view_state, render_pass_info->pAttachments[i].finalLayout, stencil_layout);
John Zulauf8e308292018-09-21 11:34:37 -06001507 }
Mark Lobodzinski3c0f6362017-02-01 13:35:48 -07001508 }
1509 }
1510}
Dave Houltone19e20d2018-02-02 16:32:41 -07001511
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001512#ifdef VK_USE_PLATFORM_ANDROID_KHR
1513// Android-specific validation that uses types defined only with VK_USE_PLATFORM_ANDROID_KHR
1514// This could also move into a seperate core_validation_android.cpp file... ?
1515
1516//
1517// AHB-specific validation within non-AHB APIs
1518//
Jeff Bolz46c0ea02019-10-09 13:06:29 -05001519bool CoreChecks::ValidateCreateImageANDROID(const debug_report_data *report_data, const VkImageCreateInfo *create_info) const {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001520 bool skip = false;
1521
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07001522 const VkExternalFormatANDROID *ext_fmt_android = LvlFindInChain<VkExternalFormatANDROID>(create_info->pNext);
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001523 if (ext_fmt_android) {
Dave Houltond9611312018-11-19 17:03:36 -07001524 if (0 != ext_fmt_android->externalFormat) {
1525 if (VK_FORMAT_UNDEFINED != create_info->format) {
1526 skip |=
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001527 LogError(device, "VUID-VkImageCreateInfo-pNext-01974",
1528 "vkCreateImage(): VkImageCreateInfo struct has a chained VkExternalFormatANDROID struct with non-zero "
1529 "externalFormat, but the VkImageCreateInfo's format is not VK_FORMAT_UNDEFINED.");
Dave Houltond9611312018-11-19 17:03:36 -07001530 }
1531
1532 if (0 != (VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT & create_info->flags)) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001533 skip |= LogError(device, "VUID-VkImageCreateInfo-pNext-02396",
1534 "vkCreateImage(): VkImageCreateInfo struct has a chained VkExternalFormatANDROID struct with "
1535 "non-zero externalFormat, but flags include VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT.");
Dave Houltond9611312018-11-19 17:03:36 -07001536 }
1537
1538 if (0 != (~VK_IMAGE_USAGE_SAMPLED_BIT & create_info->usage)) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001539 skip |= LogError(device, "VUID-VkImageCreateInfo-pNext-02397",
1540 "vkCreateImage(): VkImageCreateInfo struct has a chained VkExternalFormatANDROID struct with "
Jeremy Gebbenda6b48f2021-05-13 10:46:18 -06001541 "non-zero externalFormat, but usage includes bits (0x%" PRIx32 ") other than VK_IMAGE_USAGE_SAMPLED_BIT.",
Spencer Frickef48ad4a2020-04-09 00:07:39 -07001542 create_info->usage);
Dave Houltond9611312018-11-19 17:03:36 -07001543 }
1544
1545 if (VK_IMAGE_TILING_OPTIMAL != create_info->tiling) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001546 skip |= LogError(device, "VUID-VkImageCreateInfo-pNext-02398",
1547 "vkCreateImage(): VkImageCreateInfo struct has a chained VkExternalFormatANDROID struct with "
1548 "non-zero externalFormat, but layout is not VK_IMAGE_TILING_OPTIMAL.");
Dave Houltond9611312018-11-19 17:03:36 -07001549 }
1550 }
1551
Spencer Fricke6bba8c72020-04-06 07:41:21 -07001552 if ((0 != ext_fmt_android->externalFormat) &&
1553 (ahb_ext_formats_map.find(ext_fmt_android->externalFormat) == ahb_ext_formats_map.end())) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001554 skip |= LogError(device, "VUID-VkExternalFormatANDROID-externalFormat-01894",
Spencer Frickef48ad4a2020-04-09 00:07:39 -07001555 "vkCreateImage(): Chained VkExternalFormatANDROID struct contains a non-zero externalFormat (%" PRIu64
1556 ") which has "
1557 "not been previously retrieved by vkGetAndroidHardwareBufferPropertiesANDROID().",
1558 ext_fmt_android->externalFormat);
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001559 }
1560 }
1561
Dave Houltond9611312018-11-19 17:03:36 -07001562 if ((nullptr == ext_fmt_android) || (0 == ext_fmt_android->externalFormat)) {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001563 if (VK_FORMAT_UNDEFINED == create_info->format) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001564 skip |=
1565 LogError(device, "VUID-VkImageCreateInfo-pNext-01975",
1566 "vkCreateImage(): VkImageCreateInfo struct's format is VK_FORMAT_UNDEFINED, but either does not have a "
1567 "chained VkExternalFormatANDROID struct or the struct exists but has an externalFormat of 0.");
Dave Houltond9611312018-11-19 17:03:36 -07001568 }
1569 }
1570
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07001571 const VkExternalMemoryImageCreateInfo *emici = LvlFindInChain<VkExternalMemoryImageCreateInfo>(create_info->pNext);
Dave Houltond9611312018-11-19 17:03:36 -07001572 if (emici && (emici->handleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)) {
1573 if (create_info->imageType != VK_IMAGE_TYPE_2D) {
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001574 skip |=
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001575 LogError(device, "VUID-VkImageCreateInfo-pNext-02393",
1576 "vkCreateImage(): VkImageCreateInfo struct with imageType %s has chained VkExternalMemoryImageCreateInfo "
1577 "struct with handleType VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID.",
1578 string_VkImageType(create_info->imageType));
Dave Houltond9611312018-11-19 17:03:36 -07001579 }
1580
1581 if ((create_info->mipLevels != 1) && (create_info->mipLevels != FullMipChainLevels(create_info->extent))) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001582 skip |= LogError(device, "VUID-VkImageCreateInfo-pNext-02394",
1583 "vkCreateImage(): VkImageCreateInfo struct with chained VkExternalMemoryImageCreateInfo struct of "
1584 "handleType VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID "
1585 "specifies mipLevels = %" PRId32 " (full chain mipLevels are %" PRId32 ").",
1586 create_info->mipLevels, FullMipChainLevels(create_info->extent));
Dave Houltond9611312018-11-19 17:03:36 -07001587 }
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001588 }
1589
1590 return skip;
1591}
1592
Jeff Bolz46c0ea02019-10-09 13:06:29 -05001593bool CoreChecks::ValidateCreateImageViewANDROID(const VkImageViewCreateInfo *create_info) const {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001594 bool skip = false;
Jeremy Gebbenf4449392022-01-28 10:09:10 -07001595 auto image_state = Get<IMAGE_STATE>(create_info->image);
Dave Houltond3e046d2018-11-28 13:08:09 -07001596
Jeremy Gebbenb4d17012021-07-08 13:18:15 -06001597 if (image_state->HasAHBFormat()) {
Dave Houltond9611312018-11-19 17:03:36 -07001598 if (VK_FORMAT_UNDEFINED != create_info->format) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001599 skip |= LogError(create_info->image, "VUID-VkImageViewCreateInfo-image-02399",
1600 "vkCreateImageView(): VkImageViewCreateInfo struct has a chained VkExternalFormatANDROID struct, but "
Spencer Frickef48ad4a2020-04-09 00:07:39 -07001601 "format member is %s and must be VK_FORMAT_UNDEFINED.",
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001602 string_VkFormat(create_info->format));
Dave Houltond9611312018-11-19 17:03:36 -07001603 }
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001604
Dave Houltond9611312018-11-19 17:03:36 -07001605 // Chain must include a compatible ycbcr conversion
1606 bool conv_found = false;
1607 uint64_t external_format = 0;
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07001608 const VkSamplerYcbcrConversionInfo *ycbcr_conv_info = LvlFindInChain<VkSamplerYcbcrConversionInfo>(create_info->pNext);
Dave Houltond9611312018-11-19 17:03:36 -07001609 if (ycbcr_conv_info != nullptr) {
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06001610 auto ycbcr_state = Get<SAMPLER_YCBCR_CONVERSION_STATE>(ycbcr_conv_info->conversion);
Jeremy Gebbenf4fb2a02021-07-08 09:57:46 -06001611 if (ycbcr_state) {
Dave Houltond9611312018-11-19 17:03:36 -07001612 conv_found = true;
Jeremy Gebbenf4fb2a02021-07-08 09:57:46 -06001613 external_format = ycbcr_state->external_format;
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001614 }
Dave Houltond9611312018-11-19 17:03:36 -07001615 }
Dave Houltond3e046d2018-11-28 13:08:09 -07001616 if ((!conv_found) || (external_format != image_state->ahb_format)) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001617 skip |= LogError(create_info->image, "VUID-VkImageViewCreateInfo-image-02400",
Spencer Frickef48ad4a2020-04-09 00:07:39 -07001618 "vkCreateImageView(): VkImageViewCreateInfo struct has a chained VkExternalFormatANDROID struct with "
1619 "an externalFormat (%" PRIu64
1620 ") but needs a chained VkSamplerYcbcrConversionInfo struct with a VkSamplerYcbcrConversion created "
1621 "with the same external format.",
1622 image_state->ahb_format);
Dave Houltond9611312018-11-19 17:03:36 -07001623 }
1624
1625 // Errors in create_info swizzles
sfricke-samsungbd0e8052020-06-06 01:36:39 -07001626 if (IsIdentitySwizzle(create_info->components) == false) {
1627 skip |= LogError(
1628 create_info->image, "VUID-VkImageViewCreateInfo-image-02401",
1629 "vkCreateImageView(): VkImageViewCreateInfo struct has a chained VkExternalFormatANDROID struct, but "
1630 "includes one or more non-identity component swizzles, r swizzle = %s, g swizzle = %s, b swizzle = %s, a swizzle "
1631 "= %s.",
1632 string_VkComponentSwizzle(create_info->components.r), string_VkComponentSwizzle(create_info->components.g),
1633 string_VkComponentSwizzle(create_info->components.b), string_VkComponentSwizzle(create_info->components.a));
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001634 }
1635 }
Dave Houltond9611312018-11-19 17:03:36 -07001636
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001637 return skip;
1638}
1639
John Zulaufa26d3c82019-08-14 16:09:08 -06001640bool CoreChecks::ValidateGetImageSubresourceLayoutANDROID(const VkImage image) const {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001641 bool skip = false;
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001642
Jeremy Gebbenf4449392022-01-28 10:09:10 -07001643 auto image_state = Get<IMAGE_STATE>(image);
sfricke-samsung013f1ef2020-05-14 22:56:20 -07001644 if (image_state != nullptr) {
Aitor Camacho3294edd2022-05-16 22:34:19 +02001645 if (image_state->IsExternalAHB() && (0 == image_state->GetBoundMemoryStates().size())) {
sfricke-samsung013f1ef2020-05-14 22:56:20 -07001646 skip |= LogError(image, "VUID-vkGetImageSubresourceLayout-image-01895",
1647 "vkGetImageSubresourceLayout(): Attempt to query layout from an image created with "
1648 "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID handleType which has not yet been "
1649 "bound to memory.");
1650 }
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001651 }
1652 return skip;
1653}
1654
1655#else
1656
Jeff Bolz46c0ea02019-10-09 13:06:29 -05001657bool CoreChecks::ValidateCreateImageANDROID(const debug_report_data *report_data, const VkImageCreateInfo *create_info) const {
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001658 return false;
1659}
1660
Jeff Bolz46c0ea02019-10-09 13:06:29 -05001661bool CoreChecks::ValidateCreateImageViewANDROID(const VkImageViewCreateInfo *create_info) const { return false; }
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001662
John Zulaufa26d3c82019-08-14 16:09:08 -06001663bool CoreChecks::ValidateGetImageSubresourceLayoutANDROID(const VkImage image) const { return false; }
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001664
1665#endif // VK_USE_PLATFORM_ANDROID_KHR
1666
Spencer Fricke6bba8c72020-04-06 07:41:21 -07001667bool CoreChecks::ValidateImageFormatFeatures(const VkImageCreateInfo *pCreateInfo) const {
1668 bool skip = false;
1669
1670 // validates based on imageCreateFormatFeatures from vkspec.html#resources-image-creation-limits
Lionel Landwerlin21719f62021-12-09 11:40:09 +02001671 VkFormatFeatureFlags2KHR tiling_features = 0;
Spencer Fricke6bba8c72020-04-06 07:41:21 -07001672 const VkImageTiling image_tiling = pCreateInfo->tiling;
1673 const VkFormat image_format = pCreateInfo->format;
1674
1675 if (image_format == VK_FORMAT_UNDEFINED) {
1676 // VU 01975 states format can't be undefined unless an android externalFormat
1677#ifdef VK_USE_PLATFORM_ANDROID_KHR
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07001678 const VkExternalFormatANDROID *ext_fmt_android = LvlFindInChain<VkExternalFormatANDROID>(pCreateInfo->pNext);
Spencer Fricke6bba8c72020-04-06 07:41:21 -07001679 if ((image_tiling == VK_IMAGE_TILING_OPTIMAL) && (ext_fmt_android != nullptr) && (0 != ext_fmt_android->externalFormat)) {
1680 auto it = ahb_ext_formats_map.find(ext_fmt_android->externalFormat);
1681 if (it != ahb_ext_formats_map.end()) {
1682 tiling_features = it->second;
1683 }
1684 }
1685#endif
1686 } else if (image_tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT) {
Lionel Landwerlin1da35792021-12-14 16:54:13 +02001687 layer_data::unordered_set<uint64_t> drm_format_modifiers;
Spencer Fricke6bba8c72020-04-06 07:41:21 -07001688 const VkImageDrmFormatModifierExplicitCreateInfoEXT *drm_explicit =
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07001689 LvlFindInChain<VkImageDrmFormatModifierExplicitCreateInfoEXT>(pCreateInfo->pNext);
Spencer Fricke6bba8c72020-04-06 07:41:21 -07001690 const VkImageDrmFormatModifierListCreateInfoEXT *drm_implicit =
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07001691 LvlFindInChain<VkImageDrmFormatModifierListCreateInfoEXT>(pCreateInfo->pNext);
Spencer Fricke6bba8c72020-04-06 07:41:21 -07001692
1693 if (drm_explicit != nullptr) {
Lionel Landwerlin1da35792021-12-14 16:54:13 +02001694 drm_format_modifiers.insert(drm_explicit->drmFormatModifier);
Spencer Fricke6bba8c72020-04-06 07:41:21 -07001695 } else {
1696 // VUID 02261 makes sure its only explict or implict in parameter checking
1697 assert(drm_implicit != nullptr);
1698 for (uint32_t i = 0; i < drm_implicit->drmFormatModifierCount; i++) {
Lionel Landwerlin1da35792021-12-14 16:54:13 +02001699 drm_format_modifiers.insert(drm_implicit->pDrmFormatModifiers[i]);
Spencer Fricke6bba8c72020-04-06 07:41:21 -07001700 }
1701 }
1702
Lionel Landwerlin1da35792021-12-14 16:54:13 +02001703 auto fmt_drm_props = LvlInitStruct<VkDrmFormatModifierPropertiesListEXT>();
1704 auto fmt_props_2 = LvlInitStruct<VkFormatProperties2>(&fmt_drm_props);
1705 DispatchGetPhysicalDeviceFormatProperties2(physical_device, image_format, &fmt_props_2);
Lionel Landwerlin09351a72020-06-22 18:15:59 +03001706 std::vector<VkDrmFormatModifierPropertiesEXT> drm_properties;
Lionel Landwerlin1da35792021-12-14 16:54:13 +02001707 drm_properties.resize(fmt_drm_props.drmFormatModifierCount);
1708 fmt_drm_props.pDrmFormatModifierProperties = drm_properties.data();
1709 DispatchGetPhysicalDeviceFormatProperties2(physical_device, image_format, &fmt_props_2);
Spencer Fricke6bba8c72020-04-06 07:41:21 -07001710
Lionel Landwerlin1da35792021-12-14 16:54:13 +02001711 for (uint32_t i = 0; i < fmt_drm_props.drmFormatModifierCount; i++) {
1712 if (drm_format_modifiers.find(fmt_drm_props.pDrmFormatModifierProperties[i].drmFormatModifier) !=
1713 drm_format_modifiers.end()) {
1714 tiling_features |= fmt_drm_props.pDrmFormatModifierProperties[i].drmFormatModifierTilingFeatures;
Spencer Fricke6bba8c72020-04-06 07:41:21 -07001715 }
1716 }
1717 } else {
Lionel Landwerlin21719f62021-12-09 11:40:09 +02001718 VkFormatProperties3KHR format_properties = GetPDFormatProperties(image_format);
Spencer Fricke6bba8c72020-04-06 07:41:21 -07001719 tiling_features = (image_tiling == VK_IMAGE_TILING_LINEAR) ? format_properties.linearTilingFeatures
1720 : format_properties.optimalTilingFeatures;
1721 }
1722
Spencer Fricke3c2a8232020-04-19 18:47:25 -07001723 // Lack of disjoint format feature support while using the flag
1724 if (FormatIsMultiplane(image_format) && ((pCreateInfo->flags & VK_IMAGE_CREATE_DISJOINT_BIT) != 0) &&
Lionel Landwerlin21719f62021-12-09 11:40:09 +02001725 ((tiling_features & VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR) == 0)) {
Spencer Fricke3c2a8232020-04-19 18:47:25 -07001726 skip |= LogError(device, "VUID-VkImageCreateInfo-imageCreateFormatFeatures-02260",
1727 "vkCreateImage(): can't use VK_IMAGE_CREATE_DISJOINT_BIT because %s doesn't support "
1728 "VK_FORMAT_FEATURE_DISJOINT_BIT based on imageCreateFormatFeatures.",
1729 string_VkFormat(pCreateInfo->format));
1730 }
Spencer Fricke6bba8c72020-04-06 07:41:21 -07001731
1732 return skip;
1733}
1734
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07001735bool CoreChecks::PreCallValidateCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
Jeff Bolz5c801d12019-10-09 10:38:45 -05001736 const VkAllocationCallbacks *pAllocator, VkImage *pImage) const {
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -06001737 bool skip = false;
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001738
sfricke-samsung45996a42021-09-16 13:45:27 -07001739 if (IsExtEnabled(device_extensions.vk_android_external_memory_android_hardware_buffer)) {
Mark Lobodzinskie9b99792019-03-07 16:34:29 -07001740 skip |= ValidateCreateImageANDROID(report_data, pCreateInfo);
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001741 } else { // These checks are omitted or replaced when Android HW Buffer extension is active
1742 if (pCreateInfo->format == VK_FORMAT_UNDEFINED) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001743 return LogError(device, "VUID-VkImageCreateInfo-format-00943",
1744 "vkCreateImage(): VkFormat for image must not be VK_FORMAT_UNDEFINED.");
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06001745 }
Jeremy Hayes96dcd812017-03-14 14:04:19 -06001746 }
1747
Mark Lobodzinskidef4c092019-06-18 13:08:01 -06001748 if (pCreateInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) {
1749 if (VK_IMAGE_TYPE_2D != pCreateInfo->imageType) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001750 skip |= LogError(device, "VUID-VkImageCreateInfo-flags-00949",
1751 "vkCreateImage(): Image type must be VK_IMAGE_TYPE_2D when VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT "
1752 "flag bit is set");
Mark Lobodzinskidef4c092019-06-18 13:08:01 -06001753 }
Dave Houlton130c0212018-01-29 13:39:56 -07001754 }
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001755
Mark Lobodzinski79b5d5b2019-04-19 12:27:10 -06001756 const VkPhysicalDeviceLimits *device_limits = &phys_dev_props.limits;
Dave Houlton130c0212018-01-29 13:39:56 -07001757 VkImageUsageFlags attach_flags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
1758 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
1759 if ((pCreateInfo->usage & attach_flags) && (pCreateInfo->extent.width > device_limits->maxFramebufferWidth)) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001760 skip |= LogError(device, "VUID-VkImageCreateInfo-usage-00964",
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08001761 "vkCreateImage(): Image usage flags include a frame buffer attachment bit and image width (%u) exceeds "
1762 "device maxFramebufferWidth (%u).",
1763 pCreateInfo->extent.width, device_limits->maxFramebufferWidth);
Dave Houlton130c0212018-01-29 13:39:56 -07001764 }
1765
1766 if ((pCreateInfo->usage & attach_flags) && (pCreateInfo->extent.height > device_limits->maxFramebufferHeight)) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001767 skip |= LogError(device, "VUID-VkImageCreateInfo-usage-00965",
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08001768 "vkCreateImage(): Image usage flags include a frame buffer attachment bit and image height (%u) exceeds "
1769 "device maxFramebufferHeight (%u).",
1770 pCreateInfo->extent.height, device_limits->maxFramebufferHeight);
Dave Houlton130c0212018-01-29 13:39:56 -07001771 }
1772
ziga-lunarg44cba6e2021-07-13 17:58:06 +02001773 VkImageCreateFlags sparseFlags =
1774 VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | VK_IMAGE_CREATE_SPARSE_ALIASED_BIT;
1775 if ((pCreateInfo->flags & sparseFlags) && (pCreateInfo->usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT)) {
1776 skip |= LogError(
1777 device, "VUID-VkImageCreateInfo-None-01925",
1778 "vkCreateImage(): images using sparse memory cannot have VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT set");
1779 }
1780
Agarwal, Arpit78509112022-02-17 15:29:05 -07001781 if (!enabled_features.fragment_density_map_offset_features.fragmentDensityMapOffset) {
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07001782 uint32_t ceiling_width = static_cast<uint32_t>(ceil(
1783 static_cast<float>(device_limits->maxFramebufferWidth) /
1784 std::max(static_cast<float>(phys_dev_ext_props.fragment_density_map_props.minFragmentDensityTexelSize.width), 1.0f)));
ByumjinConffx991b6062019-08-14 15:17:53 -07001785 if ((pCreateInfo->usage & VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT) && (pCreateInfo->extent.width > ceiling_width)) {
1786 skip |=
Agarwal, Arpit78509112022-02-17 15:29:05 -07001787 LogError(device, "VUID-VkImageCreateInfo-fragmentDensityMapOffset-06514",
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001788 "vkCreateImage(): Image usage flags include a fragment density map bit and image width (%u) exceeds the "
1789 "ceiling of device "
1790 "maxFramebufferWidth (%u) / minFragmentDensityTexelSize.width (%u). The ceiling value: %u",
1791 pCreateInfo->extent.width, device_limits->maxFramebufferWidth,
1792 phys_dev_ext_props.fragment_density_map_props.minFragmentDensityTexelSize.width, ceiling_width);
ByumjinConffx991b6062019-08-14 15:17:53 -07001793 }
1794
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07001795 uint32_t ceiling_height = static_cast<uint32_t>(ceil(
1796 static_cast<float>(device_limits->maxFramebufferHeight) /
1797 std::max(static_cast<float>(phys_dev_ext_props.fragment_density_map_props.minFragmentDensityTexelSize.height), 1.0f)));
ByumjinConffx991b6062019-08-14 15:17:53 -07001798 if ((pCreateInfo->usage & VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT) && (pCreateInfo->extent.height > ceiling_height)) {
1799 skip |=
Agarwal, Arpit78509112022-02-17 15:29:05 -07001800 LogError(device, "VUID-VkImageCreateInfo-fragmentDensityMapOffset-06515",
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001801 "vkCreateImage(): Image usage flags include a fragment density map bit and image height (%u) exceeds the "
1802 "ceiling of device "
1803 "maxFramebufferHeight (%u) / minFragmentDensityTexelSize.height (%u). The ceiling value: %u",
1804 pCreateInfo->extent.height, device_limits->maxFramebufferHeight,
1805 phys_dev_ext_props.fragment_density_map_props.minFragmentDensityTexelSize.height, ceiling_height);
ByumjinConffx991b6062019-08-14 15:17:53 -07001806 }
1807 }
1808
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001809 VkImageFormatProperties format_limits = {};
Mark Lobodzinskib8d149f2019-10-02 16:42:32 -06001810 VkResult result = VK_SUCCESS;
1811 if (pCreateInfo->tiling != VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT) {
1812 result = DispatchGetPhysicalDeviceImageFormatProperties(physical_device, pCreateInfo->format, pCreateInfo->imageType,
1813 pCreateInfo->tiling, pCreateInfo->usage, pCreateInfo->flags,
1814 &format_limits);
1815 } else {
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07001816 auto modifier_list = LvlFindInChain<VkImageDrmFormatModifierListCreateInfoEXT>(pCreateInfo->pNext);
1817 auto explicit_modifier = LvlFindInChain<VkImageDrmFormatModifierExplicitCreateInfoEXT>(pCreateInfo->pNext);
Lionel Landwerlind8b1aa12020-06-22 21:22:05 +03001818 if (modifier_list) {
1819 for (uint32_t i = 0; i < modifier_list->drmFormatModifierCount; i++) {
Mark Lobodzinski6fe9e702020-12-30 15:36:39 -07001820 auto drm_format_modifier = LvlInitStruct<VkPhysicalDeviceImageDrmFormatModifierInfoEXT>();
Lionel Landwerlind8b1aa12020-06-22 21:22:05 +03001821 drm_format_modifier.drmFormatModifier = modifier_list->pDrmFormatModifiers[i];
Mark Lobodzinski6fe9e702020-12-30 15:36:39 -07001822 auto image_format_info = LvlInitStruct<VkPhysicalDeviceImageFormatInfo2>(&drm_format_modifier);
Lionel Landwerlind8b1aa12020-06-22 21:22:05 +03001823 image_format_info.type = pCreateInfo->imageType;
1824 image_format_info.format = pCreateInfo->format;
1825 image_format_info.tiling = pCreateInfo->tiling;
1826 image_format_info.usage = pCreateInfo->usage;
1827 image_format_info.flags = pCreateInfo->flags;
Mark Lobodzinski6fe9e702020-12-30 15:36:39 -07001828 auto image_format_properties = LvlInitStruct<VkImageFormatProperties2>();
Lionel Landwerlind8b1aa12020-06-22 21:22:05 +03001829
1830 result =
1831 DispatchGetPhysicalDeviceImageFormatProperties2(physical_device, &image_format_info, &image_format_properties);
1832 format_limits = image_format_properties.imageFormatProperties;
1833
1834 /* The application gives a list of modifier and the driver
1835 * selects one. If one is wrong, stop there.
1836 */
1837 if (result != VK_SUCCESS) break;
1838 }
1839 } else if (explicit_modifier) {
Mark Lobodzinski6fe9e702020-12-30 15:36:39 -07001840 auto drm_format_modifier = LvlInitStruct<VkPhysicalDeviceImageDrmFormatModifierInfoEXT>();
Lionel Landwerlind8b1aa12020-06-22 21:22:05 +03001841 drm_format_modifier.drmFormatModifier = explicit_modifier->drmFormatModifier;
Mark Lobodzinski6fe9e702020-12-30 15:36:39 -07001842 auto image_format_info = LvlInitStruct<VkPhysicalDeviceImageFormatInfo2>(&drm_format_modifier);
Lionel Landwerlind8b1aa12020-06-22 21:22:05 +03001843 image_format_info.type = pCreateInfo->imageType;
1844 image_format_info.format = pCreateInfo->format;
1845 image_format_info.tiling = pCreateInfo->tiling;
1846 image_format_info.usage = pCreateInfo->usage;
1847 image_format_info.flags = pCreateInfo->flags;
Mark Lobodzinski6fe9e702020-12-30 15:36:39 -07001848 auto image_format_properties = LvlInitStruct<VkImageFormatProperties2>();
Lionel Landwerlind8b1aa12020-06-22 21:22:05 +03001849
1850 result = DispatchGetPhysicalDeviceImageFormatProperties2(physical_device, &image_format_info, &image_format_properties);
1851 format_limits = image_format_properties.imageFormatProperties;
1852 }
Mark Lobodzinskib8d149f2019-10-02 16:42:32 -06001853 }
Mark Lobodzinski41dc7a82019-10-02 16:02:13 -06001854
sfricke-samsunga6d30f62020-06-20 20:22:00 -07001855 // 1. vkGetPhysicalDeviceImageFormatProperties[2] only success code is VK_SUCCESS
1856 // 2. If call returns an error, then "imageCreateImageFormatPropertiesList" is defined to be the empty list
1857 // 3. All values in 02251 are undefined if "imageCreateImageFormatPropertiesList" is empty.
1858 if (result != VK_SUCCESS) {
1859 // External memory will always have a "imageCreateImageFormatPropertiesList" so skip
Lockee87f87c2019-04-23 17:53:10 -06001860#ifdef VK_USE_PLATFORM_ANDROID_KHR
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07001861 if (!LvlFindInChain<VkExternalFormatANDROID>(pCreateInfo->pNext)) {
Lockee87f87c2019-04-23 17:53:10 -06001862#endif // VK_USE_PLATFORM_ANDROID_KHR
sfricke-samsunga6d30f62020-06-20 20:22:00 -07001863 skip |= LogError(device, "VUID-VkImageCreateInfo-imageCreateMaxMipLevels-02251",
Spencer Frickec46fc6d2020-04-16 06:23:05 -07001864 "vkCreateImage(): Format %s is not supported for this combination of parameters and "
sfricke-samsunga6d30f62020-06-20 20:22:00 -07001865 "VkGetPhysicalDeviceImageFormatProperties returned back %s.",
1866 string_VkFormat(pCreateInfo->format), string_VkResult(result));
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07001867#ifdef VK_USE_PLATFORM_ANDROID_KHR
1868 }
1869#endif // VK_USE_PLATFORM_ANDROID_KHR
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001870 } else {
1871 if (pCreateInfo->mipLevels > format_limits.maxMipLevels) {
1872 const char *format_string = string_VkFormat(pCreateInfo->format);
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001873 skip |= LogError(device, "VUID-VkImageCreateInfo-mipLevels-02255",
1874 "vkCreateImage(): Image mip levels=%d exceed image format maxMipLevels=%d for format %s.",
1875 pCreateInfo->mipLevels, format_limits.maxMipLevels, format_string);
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001876 }
Dave Houlton130c0212018-01-29 13:39:56 -07001877
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07001878 uint64_t texel_count = static_cast<uint64_t>(pCreateInfo->extent.width) *
1879 static_cast<uint64_t>(pCreateInfo->extent.height) *
1880 static_cast<uint64_t>(pCreateInfo->extent.depth) * static_cast<uint64_t>(pCreateInfo->arrayLayers) *
1881 static_cast<uint64_t>(pCreateInfo->samples);
Dave Houlton130c0212018-01-29 13:39:56 -07001882
sfricke-samsung2e827212021-09-28 07:52:08 -07001883 // Depth/Stencil formats size can't be accurately calculated
1884 if (!FormatIsDepthAndStencil(pCreateInfo->format)) {
1885 uint64_t total_size =
1886 static_cast<uint64_t>(std::ceil(FormatTexelSize(pCreateInfo->format) * static_cast<double>(texel_count)));
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001887
sfricke-samsung2e827212021-09-28 07:52:08 -07001888 // Round up to imageGranularity boundary
1889 VkDeviceSize image_granularity = phys_dev_props.limits.bufferImageGranularity;
1890 uint64_t ig_mask = image_granularity - 1;
1891 total_size = (total_size + ig_mask) & ~ig_mask;
1892
1893 if (total_size > format_limits.maxResourceSize) {
1894 skip |= LogWarning(device, kVUID_Core_Image_InvalidFormatLimitsViolation,
1895 "vkCreateImage(): resource size exceeds allowable maximum Image resource size = 0x%" PRIxLEAST64
1896 ", maximum resource size = 0x%" PRIxLEAST64 " ",
1897 total_size, format_limits.maxResourceSize);
1898 }
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001899 }
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001900
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001901 if (pCreateInfo->arrayLayers > format_limits.maxArrayLayers) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001902 skip |= LogError(device, "VUID-VkImageCreateInfo-arrayLayers-02256",
1903 "vkCreateImage(): arrayLayers=%d exceeds allowable maximum supported by format of %d.",
1904 pCreateInfo->arrayLayers, format_limits.maxArrayLayers);
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001905 }
1906
1907 if ((pCreateInfo->samples & format_limits.sampleCounts) == 0) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001908 skip |= LogError(device, "VUID-VkImageCreateInfo-samples-02258",
1909 "vkCreateImage(): samples %s is not supported by format 0x%.8X.",
1910 string_VkSampleCountFlagBits(pCreateInfo->samples), format_limits.sampleCounts);
Graeme Leese2cd2a1f2018-11-19 15:11:45 +00001911 }
sfricke-samsung612f3622020-06-20 20:42:46 -07001912
1913 if (pCreateInfo->extent.width > format_limits.maxExtent.width) {
1914 skip |= LogError(device, "VUID-VkImageCreateInfo-extent-02252",
1915 "vkCreateImage(): extent.width %u exceeds allowable maximum image extent width %u.",
1916 pCreateInfo->extent.width, format_limits.maxExtent.width);
1917 }
1918
1919 if (pCreateInfo->extent.height > format_limits.maxExtent.height) {
1920 skip |= LogError(device, "VUID-VkImageCreateInfo-extent-02253",
1921 "vkCreateImage(): extent.height %u exceeds allowable maximum image extent height %u.",
1922 pCreateInfo->extent.height, format_limits.maxExtent.height);
1923 }
1924
1925 if (pCreateInfo->extent.depth > format_limits.maxExtent.depth) {
1926 skip |= LogError(device, "VUID-VkImageCreateInfo-extent-02254",
1927 "vkCreateImage(): extent.depth %u exceeds allowable maximum image extent depth %u.",
1928 pCreateInfo->extent.depth, format_limits.maxExtent.depth);
1929 }
Mark Lobodzinski90224de2017-01-26 15:23:11 -07001930 }
1931
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001932 // Tests for "Formats requiring sampler YCBCR conversion for VK_IMAGE_ASPECT_COLOR_BIT image views"
sfricke-samsung10b35ce2021-09-29 08:50:20 -07001933 if (FormatRequiresYcbcrConversionExplicitly(pCreateInfo->format)) {
sfricke-samsungcead0802020-01-30 22:20:10 -08001934 if (!enabled_features.ycbcr_image_array_features.ycbcrImageArrays && pCreateInfo->arrayLayers != 1) {
sfricke-samsung45996a42021-09-16 13:45:27 -07001935 const char *error_vuid = IsExtEnabled(device_extensions.vk_ext_ycbcr_image_arrays)
Mike Schuchardt37b8cc12021-10-05 14:31:11 -07001936 ? "VUID-VkImageCreateInfo-format-06414"
1937 : "VUID-VkImageCreateInfo-format-06413";
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001938 skip |= LogError(device, error_vuid,
1939 "vkCreateImage(): arrayLayers = %d, but when the ycbcrImagesArrays feature is not enabled and using a "
1940 "YCbCr Conversion format, arrayLayers must be 1",
1941 pCreateInfo->arrayLayers);
sfricke-samsungcead0802020-01-30 22:20:10 -08001942 }
1943
1944 if (pCreateInfo->mipLevels != 1) {
Mike Schuchardt37b8cc12021-10-05 14:31:11 -07001945 skip |= LogError(device, "VUID-VkImageCreateInfo-format-06410",
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001946 "vkCreateImage(): mipLevels = %d, but when using a YCbCr Conversion format, mipLevels must be 1",
tmerilehtica733542022-04-13 14:00:29 +03001947 pCreateInfo->mipLevels);
sfricke-samsungcead0802020-01-30 22:20:10 -08001948 }
1949
1950 if (pCreateInfo->samples != VK_SAMPLE_COUNT_1_BIT) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001951 skip |= LogError(
Mike Schuchardt37b8cc12021-10-05 14:31:11 -07001952 device, "VUID-VkImageCreateInfo-format-06411",
sfricke-samsungcead0802020-01-30 22:20:10 -08001953 "vkCreateImage(): samples = %s, but when using a YCbCr Conversion format, samples must be VK_SAMPLE_COUNT_1_BIT",
1954 string_VkSampleCountFlagBits(pCreateInfo->samples));
1955 }
1956
1957 if (pCreateInfo->imageType != VK_IMAGE_TYPE_2D) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001958 skip |= LogError(
Mike Schuchardt37b8cc12021-10-05 14:31:11 -07001959 device, "VUID-VkImageCreateInfo-format-06412",
sfricke-samsungcead0802020-01-30 22:20:10 -08001960 "vkCreateImage(): imageType = %s, but when using a YCbCr Conversion format, imageType must be VK_IMAGE_TYPE_2D ",
1961 string_VkImageType(pCreateInfo->imageType));
1962 }
1963 }
1964
sfricke-samsung45996a42021-09-16 13:45:27 -07001965 if (IsExtEnabled(device_extensions.vk_khr_maintenance2)) {
Spencer Fricke48db59b2020-03-23 10:31:46 -07001966 if (pCreateInfo->flags & VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT) {
sfricke-samsung08796682021-09-13 07:47:20 -07001967 if (!FormatIsCompressed(pCreateInfo->format)) {
Spencer Fricke48db59b2020-03-23 10:31:46 -07001968 skip |= LogError(device, "VUID-VkImageCreateInfo-flags-01572",
1969 "vkCreateImage(): If pCreateInfo->flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, "
sfricke-samsung08796682021-09-13 07:47:20 -07001970 "format must be a compressed image format, but is %s",
Spencer Fricke48db59b2020-03-23 10:31:46 -07001971 string_VkFormat(pCreateInfo->format));
Lenny Komowb79f04a2017-09-18 17:07:00 -06001972 }
1973 if (!(pCreateInfo->flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT)) {
Spencer Fricke48db59b2020-03-23 10:31:46 -07001974 skip |= LogError(device, "VUID-VkImageCreateInfo-flags-01573",
1975 "vkCreateImage(): If pCreateInfo->flags contains VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, "
1976 "flags must also contain VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT.");
Lenny Komowb79f04a2017-09-18 17:07:00 -06001977 }
1978 }
1979 }
1980
Mark Lobodzinski08ee03c2019-02-04 10:57:47 -07001981 if (pCreateInfo->sharingMode == VK_SHARING_MODE_CONCURRENT && pCreateInfo->pQueueFamilyIndices) {
sfricke-samsung45996a42021-09-16 13:45:27 -07001982 const char *vuid = IsExtEnabled(device_extensions.vk_khr_get_physical_device_properties2)
1983 ? "VUID-VkImageCreateInfo-sharingMode-01420"
1984 : "VUID-VkImageCreateInfo-sharingMode-01392";
Mark Lobodzinski314b9162020-07-16 15:33:08 -06001985 skip |= ValidatePhysicalDeviceQueueFamilies(pCreateInfo->queueFamilyIndexCount, pCreateInfo->pQueueFamilyIndices,
ziga-lunarge2e283d2021-08-01 09:55:04 +02001986 "vkCreateImage", "pCreateInfo->pQueueFamilyIndices", vuid);
Mark Lobodzinski08ee03c2019-02-04 10:57:47 -07001987 }
1988
unknown2c877272019-07-11 12:56:50 -06001989 if (!FormatIsMultiplane(pCreateInfo->format) && !(pCreateInfo->flags & VK_IMAGE_CREATE_ALIAS_BIT) &&
1990 (pCreateInfo->flags & VK_IMAGE_CREATE_DISJOINT_BIT)) {
1991 skip |=
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07001992 LogError(device, "VUID-VkImageCreateInfo-format-01577",
1993 "vkCreateImage(): format is %s and flags are %s. The flags should not include VK_IMAGE_CREATE_DISJOINT_BIT.",
1994 string_VkFormat(pCreateInfo->format), string_VkImageCreateFlags(pCreateInfo->flags).c_str());
unknown2c877272019-07-11 12:56:50 -06001995 }
Spencer Fricke6bba8c72020-04-06 07:41:21 -07001996
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07001997 const auto swapchain_create_info = LvlFindInChain<VkImageSwapchainCreateInfoKHR>(pCreateInfo->pNext);
sfricke-samsungddaf72b2020-06-23 21:39:28 -07001998 if (swapchain_create_info != nullptr) {
1999 if (swapchain_create_info->swapchain != VK_NULL_HANDLE) {
Jeremy Gebbenf4449392022-01-28 10:09:10 -07002000 auto swapchain_state = Get<SWAPCHAIN_NODE>(swapchain_create_info->swapchain);
sfricke-samsungddaf72b2020-06-23 21:39:28 -07002001 const VkSwapchainCreateFlagsKHR swapchain_flags = swapchain_state->createInfo.flags;
2002
2003 // Validate rest of Swapchain Image create check that require swapchain state
2004 const char *vuid = "VUID-VkImageSwapchainCreateInfoKHR-swapchain-00995";
2005 if (((swapchain_flags & VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR) != 0) &&
2006 ((pCreateInfo->flags & VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT) == 0)) {
2007 skip |= LogError(
2008 device, vuid,
2009 "vkCreateImage(): Swapchain was created with VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR flag so "
2010 "all swapchain images must have the VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT flag set.");
2011 }
2012 if (((swapchain_flags & VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR) != 0) &&
2013 ((pCreateInfo->flags & VK_IMAGE_CREATE_PROTECTED_BIT) == 0)) {
2014 skip |= LogError(device, vuid,
2015 "vkCreateImage(): Swapchain was created with VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR flag so all "
2016 "swapchain images must have the VK_IMAGE_CREATE_PROTECTED_BIT flag set.");
2017 }
Mike Schuchardt2df08912020-12-15 16:28:09 -08002018 const VkImageCreateFlags mutable_flags = (VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT);
sfricke-samsungddaf72b2020-06-23 21:39:28 -07002019 if (((swapchain_flags & VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR) != 0) &&
2020 ((pCreateInfo->flags & mutable_flags) != mutable_flags)) {
2021 skip |= LogError(device, vuid,
2022 "vkCreateImage(): Swapchain was created with VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR flag so "
2023 "all swapchain images must have the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT and "
Mike Schuchardt2df08912020-12-15 16:28:09 -08002024 "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT flags both set.");
sfricke-samsungddaf72b2020-06-23 21:39:28 -07002025 }
2026 }
2027 }
2028
sfricke-samsungedce77a2020-07-03 22:35:13 -07002029 if ((pCreateInfo->flags & VK_IMAGE_CREATE_PROTECTED_BIT) != 0) {
2030 if (enabled_features.core11.protectedMemory == VK_FALSE) {
2031 skip |= LogError(device, "VUID-VkImageCreateInfo-flags-01890",
2032 "vkCreateImage(): the protectedMemory device feature is disabled: Images cannot be created with the "
2033 "VK_IMAGE_CREATE_PROTECTED_BIT set.");
2034 }
2035 const VkImageCreateFlags invalid_flags =
2036 VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | VK_IMAGE_CREATE_SPARSE_ALIASED_BIT;
2037 if ((pCreateInfo->flags & invalid_flags) != 0) {
2038 skip |= LogError(device, "VUID-VkImageCreateInfo-None-01891",
2039 "vkCreateImage(): VK_IMAGE_CREATE_PROTECTED_BIT is set so no sparse create flags can be used at same "
2040 "time (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | "
2041 "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT).");
2042 }
2043 }
2044
Spencer Fricke6bba8c72020-04-06 07:41:21 -07002045 skip |= ValidateImageFormatFeatures(pCreateInfo);
2046
Nathaniel Cesarioc02c2512020-11-13 12:04:24 -07002047 // Check compatibility with VK_KHR_portability_subset
sfricke-samsung45996a42021-09-16 13:45:27 -07002048 if (IsExtEnabled(device_extensions.vk_khr_portability_subset)) {
Nathaniel Cesarioc02c2512020-11-13 12:04:24 -07002049 if (VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT & pCreateInfo->flags &&
2050 VK_FALSE == enabled_features.portability_subset_features.imageView2DOn3DImage) {
2051 skip |= LogError(device, "VUID-VkImageCreateInfo-imageView2DOn3DImage-04459",
2052 "vkCreateImage (portability error): VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT is not supported.");
2053 }
2054 if ((VK_SAMPLE_COUNT_1_BIT != pCreateInfo->samples) && (1 != pCreateInfo->arrayLayers) &&
2055 (VK_FALSE == enabled_features.portability_subset_features.multisampleArrayImage)) {
2056 skip |=
2057 LogError(device, "VUID-VkImageCreateInfo-multisampleArrayImage-04460",
2058 "vkCreateImage (portability error): Cannot create an image with samples/texel > 1 && arrayLayers != 1");
2059 }
2060 }
2061
ziga-lunarg63f8d7a2021-07-20 22:10:31 +02002062 const auto external_memory_create_info_nv = LvlFindInChain<VkExternalMemoryImageCreateInfoNV>(pCreateInfo->pNext);
ziga-lunarg62aa24f2021-10-09 11:58:30 +02002063 const auto external_memory_create_info = LvlFindInChain<VkExternalMemoryImageCreateInfo>(pCreateInfo->pNext);
2064 if (external_memory_create_info_nv != nullptr && external_memory_create_info != nullptr) {
2065 skip |= LogError(device, "VUID-VkImageCreateInfo-pNext-00988",
2066 "vkCreateImage(): VkImageCreateInfo struct has both VkExternalMemoryImageCreateInfoNV and "
2067 "VkExternalMemoryImageCreateInfo chained structs.");
2068 }
2069 if (external_memory_create_info) {
2070 if (external_memory_create_info->handleTypes != 0 && pCreateInfo->initialLayout != VK_IMAGE_LAYOUT_UNDEFINED) {
2071 skip |= LogError(
2072 device, "VUID-VkImageCreateInfo-pNext-01443",
2073 "vkCreateImage: VkImageCreateInfo pNext chain includes VkExternalMemoryImageCreateInfo with handleTypes %" PRIu32
2074 " but pCreateInfo->initialLayout is %s.",
2075 external_memory_create_info->handleTypes, string_VkImageLayout(pCreateInfo->initialLayout));
2076 }
2077 } else if (external_memory_create_info_nv) {
2078 if (external_memory_create_info_nv->handleTypes != 0 && pCreateInfo->initialLayout != VK_IMAGE_LAYOUT_UNDEFINED) {
2079 skip |= LogError(
2080 device, "VUID-VkImageCreateInfo-pNext-01443",
2081 "vkCreateImage: VkImageCreateInfo pNext chain includes VkExternalMemoryImageCreateInfoNV with handleTypes %" PRIu32
2082 " but pCreateInfo->initialLayout is %s.",
2083 external_memory_create_info_nv->handleTypes, string_VkImageLayout(pCreateInfo->initialLayout));
ziga-lunarg63f8d7a2021-07-20 22:10:31 +02002084 }
2085 }
2086
ziga-lunarg374fd9a2021-07-18 10:32:52 +02002087 if (device_group_create_info.physicalDeviceCount == 1) {
2088 if (pCreateInfo->flags & VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT) {
2089 skip |= LogError(device, "VUID-VkImageCreateInfo-physicalDeviceCount-01421",
2090 "vkCreateImage: Device was created with VkDeviceGroupDeviceCreateInfo::physicalDeviceCount 1, but "
2091 "flags contain VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT bit.");
2092 }
2093 }
2094
Mark Lobodzinskibdc3b022017-04-24 09:11:35 -06002095 return skip;
Mark Lobodzinski90224de2017-01-26 15:23:11 -07002096}
2097
John Zulauf7eeb6f72019-06-17 11:56:36 -06002098void CoreChecks::PostCallRecordCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
2099 const VkAllocationCallbacks *pAllocator, VkImage *pImage, VkResult result) {
2100 if (VK_SUCCESS != result) return;
2101
2102 StateTracker::PostCallRecordCreateImage(device, pCreateInfo, pAllocator, pImage, result);
Jeremy Gebben4a8881f2022-01-10 17:04:30 -07002103 if ((pCreateInfo->flags & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) != 0) {
2104 // non-sparse images set up their layout maps when memory is bound
2105 auto image_state = Get<IMAGE_STATE>(*pImage);
2106 image_state->SetInitialLayoutMap();
2107 }
Mark Lobodzinski42fe5f72017-01-11 11:36:16 -07002108}
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07002109
Jeff Bolz5c801d12019-10-09 10:38:45 -05002110bool CoreChecks::PreCallValidateDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) const {
Jeremy Gebbenf4449392022-01-28 10:09:10 -07002111 auto image_state = Get<IMAGE_STATE>(image);
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07002112 bool skip = false;
Mark Lobodzinski6b35c8a2019-01-10 10:57:27 -07002113 if (image_state) {
Jeremy Gebben82e11d52021-07-26 09:19:37 -06002114 if (image_state->IsSwapchainImage()) {
sfricke-samsung73452522021-06-17 08:44:46 -07002115 skip |= LogError(device, "VUID-vkDestroyImage-image-04882",
sfricke-samsung9056cc12021-04-18 22:51:00 -07002116 "vkDestroyImage(): %s is a presentable image and it is controlled by the implementation and is "
2117 "destroyed with vkDestroySwapchainKHR.",
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002118 report_data->FormatHandle(image_state->image()).c_str());
sfricke-samsung9056cc12021-04-18 22:51:00 -07002119 }
Jeremy Gebben9f537102021-10-05 16:37:12 -06002120 skip |= ValidateObjectNotInUse(image_state.get(), "vkDestroyImage", "VUID-vkDestroyImage-image-01000");
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07002121 }
2122 return skip;
2123}
2124
John Zulauf7eeb6f72019-06-17 11:56:36 -06002125void CoreChecks::PreCallRecordDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
2126 // Clean up validation specific data
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06002127 auto image_state = Get<IMAGE_STATE>(image);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07002128 qfo_release_image_barrier_map.erase(image);
John Zulauf7eeb6f72019-06-17 11:56:36 -06002129 // Clean up generic image state
2130 StateTracker::PreCallRecordDestroyImage(device, image, pAllocator);
Mark Lobodzinski9ef5d562017-01-27 12:28:30 -07002131}
Mark Lobodzinskic409a582017-01-27 15:16:01 -07002132
sfricke-samsungcd924d92020-05-20 23:51:17 -07002133bool CoreChecks::ValidateImageAttributes(const IMAGE_STATE *image_state, const VkImageSubresourceRange &range,
2134 const char *param_name) const {
Mark Lobodzinskic409a582017-01-27 15:16:01 -07002135 bool skip = false;
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002136 const VkImage image = image_state->image();
sfricke-samsungcd924d92020-05-20 23:51:17 -07002137 const VkFormat format = image_state->createInfo.format;
Mark Lobodzinskic409a582017-01-27 15:16:01 -07002138
2139 if (range.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) {
sfricke-samsungcd924d92020-05-20 23:51:17 -07002140 skip |= LogError(image, "VUID-vkCmdClearColorImage-aspectMask-02498",
2141 "vkCmdClearColorImage(): %s.aspectMasks must only be set to VK_IMAGE_ASPECT_COLOR_BIT.", param_name);
Mark Lobodzinskic409a582017-01-27 15:16:01 -07002142 }
2143
sfricke-samsungcd924d92020-05-20 23:51:17 -07002144 if (FormatIsDepthOrStencil(format)) {
2145 skip |= LogError(image, "VUID-vkCmdClearColorImage-image-00007",
2146 "vkCmdClearColorImage(): %s called with image %s which has a depth/stencil format (%s).", param_name,
2147 report_data->FormatHandle(image).c_str(), string_VkFormat(format));
2148 } else if (FormatIsCompressed(format)) {
2149 skip |= LogError(image, "VUID-vkCmdClearColorImage-image-00007",
2150 "vkCmdClearColorImage(): %s called with image %s which has a compressed format (%s).", param_name,
2151 report_data->FormatHandle(image).c_str(), string_VkFormat(format));
Mark Lobodzinskic409a582017-01-27 15:16:01 -07002152 }
2153
2154 if (!(image_state->createInfo.usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) {
sfricke-samsungcd924d92020-05-20 23:51:17 -07002155 skip |=
2156 LogError(image, "VUID-vkCmdClearColorImage-image-00002",
2157 "vkCmdClearColorImage() %s called with image %s which was created without VK_IMAGE_USAGE_TRANSFER_DST_BIT.",
2158 param_name, report_data->FormatHandle(image).c_str());
Mark Lobodzinskic409a582017-01-27 15:16:01 -07002159 }
2160 return skip;
2161}
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002162
John Zulauf07288512019-07-05 11:09:50 -06002163bool CoreChecks::VerifyClearImageLayout(const CMD_BUFFER_STATE *cb_node, const IMAGE_STATE *image_state,
2164 const VkImageSubresourceRange &range, VkImageLayout dest_image_layout,
2165 const char *func_name) const {
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002166 bool skip = false;
Mark Lobodzinskia4651ba2019-12-18 12:57:46 -07002167 if (strcmp(func_name, "vkCmdClearDepthStencilImage()") == 0) {
2168 if ((dest_image_layout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) && (dest_image_layout != VK_IMAGE_LAYOUT_GENERAL)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002169 skip |= LogError(image_state->image(), "VUID-vkCmdClearDepthStencilImage-imageLayout-00012",
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002170 "%s: Layout for cleared image is %s but can only be TRANSFER_DST_OPTIMAL or GENERAL.", func_name,
2171 string_VkImageLayout(dest_image_layout));
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002172 }
Mark Lobodzinskia4651ba2019-12-18 12:57:46 -07002173
2174 } else {
2175 assert(strcmp(func_name, "vkCmdClearColorImage()") == 0);
sfricke-samsung45996a42021-09-16 13:45:27 -07002176 if (!IsExtEnabled(device_extensions.vk_khr_shared_presentable_image)) {
Mark Lobodzinskia4651ba2019-12-18 12:57:46 -07002177 if ((dest_image_layout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) && (dest_image_layout != VK_IMAGE_LAYOUT_GENERAL)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002178 skip |= LogError(image_state->image(), "VUID-vkCmdClearColorImage-imageLayout-00005",
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002179 "%s: Layout for cleared image is %s but can only be TRANSFER_DST_OPTIMAL or GENERAL.", func_name,
2180 string_VkImageLayout(dest_image_layout));
Mark Lobodzinskia4651ba2019-12-18 12:57:46 -07002181 }
2182 } else {
2183 if ((dest_image_layout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) && (dest_image_layout != VK_IMAGE_LAYOUT_GENERAL) &&
2184 (dest_image_layout != VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR)) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002185 skip |= LogError(
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002186 image_state->image(), "VUID-vkCmdClearColorImage-imageLayout-01394",
Mark Lobodzinskia4651ba2019-12-18 12:57:46 -07002187 "%s: Layout for cleared image is %s but can only be TRANSFER_DST_OPTIMAL, SHARED_PRESENT_KHR, or GENERAL.",
2188 func_name, string_VkImageLayout(dest_image_layout));
2189 }
2190 }
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002191 }
2192
John Zulauff660ad62019-03-23 07:16:05 -06002193 // Cast to const to prevent creation at validate time.
Jeremy Gebben6335df62021-11-01 10:50:13 -06002194 const auto *subresource_map = cb_node->GetImageSubresourceLayoutMap(*image_state);
John Zulauff660ad62019-03-23 07:16:05 -06002195 if (subresource_map) {
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -06002196 LayoutUseCheckAndMessage layout_check(dest_image_layout);
Jeremy Gebben1dfbd172021-05-19 14:00:58 -06002197 auto normalized_isr = image_state->NormalizeSubresourceRange(range);
Tony Barbour55688172020-09-23 15:19:50 -07002198 // IncrementInterval skips over all the subresources that have the same state as we just checked, incrementing to
2199 // the next "constant value" range
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -06002200 skip |= subresource_map->AnyInRange(
2201 normalized_isr, [this, cb_node, &layout_check, func_name](const VkImageSubresource &subres, const LayoutEntry &state) {
2202 bool subres_skip = false;
2203 if (!layout_check.Check(state)) {
2204 const char *error_code = "VUID-vkCmdClearColorImage-imageLayout-00004";
2205 if (strcmp(func_name, "vkCmdClearDepthStencilImage()") == 0) {
2206 error_code = "VUID-vkCmdClearDepthStencilImage-imageLayout-00011";
2207 } else {
2208 assert(strcmp(func_name, "vkCmdClearColorImage()") == 0);
2209 }
2210 subres_skip |= LogError(cb_node->commandBuffer(), error_code,
2211 "%s: Cannot clear an image whose layout is %s and doesn't match the %s layout %s.",
2212 func_name, string_VkImageLayout(layout_check.expected_layout), layout_check.message,
2213 string_VkImageLayout(layout_check.layout));
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002214 }
Jeremy Gebbenf33bcd12022-04-19 08:12:44 -06002215 return subres_skip;
2216 });
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002217 }
2218
2219 return skip;
2220}
2221
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002222bool CoreChecks::PreCallValidateCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
2223 const VkClearColorValue *pColor, uint32_t rangeCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002224 const VkImageSubresourceRange *pRanges) const {
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002225 bool skip = false;
2226 // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
Jeremy Gebbenb68fa022022-01-28 10:08:37 -07002227 auto cb_node = GetRead<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenf4449392022-01-28 10:09:10 -07002228 auto image_state = Get<IMAGE_STATE>(image);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002229 if (cb_node && image_state) {
Jeremy Gebben9f537102021-10-05 16:37:12 -06002230 skip |= ValidateMemoryIsBoundToImage(image_state.get(), "vkCmdClearColorImage()", "VUID-vkCmdClearColorImage-image-00003");
2231 skip |= ValidateCmd(cb_node.get(), CMD_CLEARCOLORIMAGE);
sfricke-samsung45996a42021-09-16 13:45:27 -07002232 if (IsExtEnabled(device_extensions.vk_khr_maintenance1)) {
Lionel Landwerlin21719f62021-12-09 11:40:09 +02002233 skip |= ValidateImageFormatFeatureFlags(image_state.get(), VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR,
2234 "vkCmdClearColorImage", "VUID-vkCmdClearColorImage-image-01993");
Cort Stratton186b1a22018-05-01 20:18:06 -04002235 }
Jeremy Gebben9f537102021-10-05 16:37:12 -06002236 skip |= ValidateProtectedImage(cb_node.get(), image_state.get(), "vkCmdClearColorImage()",
2237 "VUID-vkCmdClearColorImage-commandBuffer-01805");
2238 skip |= ValidateUnprotectedImage(cb_node.get(), image_state.get(), "vkCmdClearColorImage()",
sfricke-samsung022fa252020-07-24 03:26:16 -07002239 "VUID-vkCmdClearColorImage-commandBuffer-01806");
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002240 for (uint32_t i = 0; i < rangeCount; ++i) {
Petr Kraus4d718682017-05-18 03:38:41 +02002241 std::string param_name = "pRanges[" + std::to_string(i) + "]";
Jeremy Gebben9f537102021-10-05 16:37:12 -06002242 skip |= ValidateCmdClearColorSubresourceRange(image_state.get(), pRanges[i], param_name.c_str());
2243 skip |= ValidateImageAttributes(image_state.get(), pRanges[i], param_name.c_str());
2244 skip |= VerifyClearImageLayout(cb_node.get(), image_state.get(), pRanges[i], imageLayout, "vkCmdClearColorImage()");
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002245 }
sfricke-samsunge775d492020-02-28 09:02:25 -08002246 // Tests for "Formats requiring sampler Y’CBCR conversion for VK_IMAGE_ASPECT_COLOR_BIT image views"
sfricke-samsung10b35ce2021-09-29 08:50:20 -07002247 if (FormatRequiresYcbcrConversionExplicitly(image_state->createInfo.format)) {
sfricke-samsunge775d492020-02-28 09:02:25 -08002248 skip |= LogError(device, "VUID-vkCmdClearColorImage-image-01545",
2249 "vkCmdClearColorImage(): format (%s) must not be one of the formats requiring sampler YCBCR "
2250 "conversion for VK_IMAGE_ASPECT_COLOR_BIT image views",
2251 string_VkFormat(image_state->createInfo.format));
2252 }
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002253 }
2254 return skip;
2255}
2256
John Zulaufeabb4462019-07-05 14:13:03 -06002257void CoreChecks::PreCallRecordCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
2258 const VkClearColorValue *pColor, uint32_t rangeCount,
2259 const VkImageSubresourceRange *pRanges) {
2260 StateTracker::PreCallRecordCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
2261
Jeremy Gebben332d4dd2022-01-01 12:40:02 -07002262 auto cb_node = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06002263 auto image_state = Get<IMAGE_STATE>(image);
John Zulaufeabb4462019-07-05 14:13:03 -06002264 if (cb_node && image_state) {
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002265 for (uint32_t i = 0; i < rangeCount; ++i) {
Jeremy Gebben1ec89332021-08-05 13:51:49 -06002266 cb_node->SetImageInitialLayout(image, pRanges[i], imageLayout);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002267 }
2268 }
2269}
2270
sfricke-samsung03f11ef2021-01-23 02:02:15 -08002271bool CoreChecks::ValidateClearDepthStencilValue(VkCommandBuffer commandBuffer, VkClearDepthStencilValue clearValue,
2272 const char *apiName) const {
2273 bool skip = false;
2274
2275 // The extension was not created with a feature bit whichs prevents displaying the 2 variations of the VUIDs
sfricke-samsung45996a42021-09-16 13:45:27 -07002276 if (!IsExtEnabled(device_extensions.vk_ext_depth_range_unrestricted)) {
sfricke-samsung03f11ef2021-01-23 02:02:15 -08002277 if (!(clearValue.depth >= 0.0) || !(clearValue.depth <= 1.0)) {
2278 // Also VUID-VkClearDepthStencilValue-depth-00022
2279 skip |= LogError(commandBuffer, "VUID-VkClearDepthStencilValue-depth-02506",
2280 "%s: VK_EXT_depth_range_unrestricted extension is not enabled and VkClearDepthStencilValue::depth "
2281 "(=%f) is not within the [0.0, 1.0] range.",
2282 apiName, clearValue.depth);
2283 }
2284 }
2285
2286 return skip;
2287}
2288
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07002289bool CoreChecks::PreCallValidateCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
2290 const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002291 const VkImageSubresourceRange *pRanges) const {
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002292 bool skip = false;
Mark Lobodzinski1241a312017-02-01 10:57:21 -07002293
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002294 // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
Jeremy Gebbenb68fa022022-01-28 10:08:37 -07002295 auto cb_node = GetRead<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenf4449392022-01-28 10:09:10 -07002296 auto image_state = Get<IMAGE_STATE>(image);
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002297 if (cb_node && image_state) {
sfricke-samsung30e325a2020-07-25 12:56:13 -07002298 const VkFormat image_format = image_state->createInfo.format;
Jeremy Gebben9f537102021-10-05 16:37:12 -06002299 skip |= ValidateMemoryIsBoundToImage(image_state.get(), "vkCmdClearDepthStencilImage()",
Dave Houltond8ed0212018-05-16 17:18:24 -06002300 "VUID-vkCmdClearDepthStencilImage-image-00010");
Jeremy Gebben9f537102021-10-05 16:37:12 -06002301 skip |= ValidateCmd(cb_node.get(), CMD_CLEARDEPTHSTENCILIMAGE);
sfricke-samsung45996a42021-09-16 13:45:27 -07002302 if (IsExtEnabled(device_extensions.vk_khr_maintenance1)) {
Lionel Landwerlin21719f62021-12-09 11:40:09 +02002303 skip |= ValidateImageFormatFeatureFlags(image_state.get(), VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR,
Jeremy Gebben9f537102021-10-05 16:37:12 -06002304 "vkCmdClearDepthStencilImage", "VUID-vkCmdClearDepthStencilImage-image-01994");
Cort Stratton186b1a22018-05-01 20:18:06 -04002305 }
sfricke-samsung03f11ef2021-01-23 02:02:15 -08002306 skip |= ValidateClearDepthStencilValue(commandBuffer, *pDepthStencil, "vkCmdClearDepthStencilImage()");
Jeremy Gebben9f537102021-10-05 16:37:12 -06002307 skip |= ValidateProtectedImage(cb_node.get(), image_state.get(), "vkCmdClearDepthStencilImage()",
sfricke-samsung022fa252020-07-24 03:26:16 -07002308 "VUID-vkCmdClearDepthStencilImage-commandBuffer-01807");
Jeremy Gebben9f537102021-10-05 16:37:12 -06002309 skip |= ValidateUnprotectedImage(cb_node.get(), image_state.get(), "vkCmdClearDepthStencilImage()",
sfricke-samsung022fa252020-07-24 03:26:16 -07002310 "VUID-vkCmdClearDepthStencilImage-commandBuffer-01808");
Andrew Fobel3abeb992020-01-20 16:33:22 -05002311
2312 bool any_include_aspect_depth_bit = false;
2313 bool any_include_aspect_stencil_bit = false;
2314
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002315 for (uint32_t i = 0; i < rangeCount; ++i) {
Petr Kraus4d718682017-05-18 03:38:41 +02002316 std::string param_name = "pRanges[" + std::to_string(i) + "]";
Jeremy Gebben9f537102021-10-05 16:37:12 -06002317 skip |= ValidateCmdClearDepthSubresourceRange(image_state.get(), pRanges[i], param_name.c_str());
2318 skip |=
2319 VerifyClearImageLayout(cb_node.get(), image_state.get(), pRanges[i], imageLayout, "vkCmdClearDepthStencilImage()");
Mark Lobodzinski1241a312017-02-01 10:57:21 -07002320 // Image aspect must be depth or stencil or both
Dave Houlton12befb92018-06-26 17:16:46 -06002321 VkImageAspectFlags valid_aspects = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
2322 if (((pRanges[i].aspectMask & valid_aspects) == 0) || ((pRanges[i].aspectMask & ~valid_aspects) != 0)) {
sfricke-samsungcd924d92020-05-20 23:51:17 -07002323 skip |= LogError(commandBuffer, "VUID-vkCmdClearDepthStencilImage-aspectMask-02824",
2324 "vkCmdClearDepthStencilImage(): pRanges[%u].aspectMask can only be VK_IMAGE_ASPECT_DEPTH_BIT "
2325 "and/or VK_IMAGE_ASPECT_STENCIL_BIT.",
2326 i);
Mark Lobodzinski1241a312017-02-01 10:57:21 -07002327 }
Andrew Fobel3abeb992020-01-20 16:33:22 -05002328 if ((pRanges[i].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != 0) {
2329 any_include_aspect_depth_bit = true;
sfricke-samsung30e325a2020-07-25 12:56:13 -07002330 if (FormatHasDepth(image_format) == false) {
2331 skip |= LogError(commandBuffer, "VUID-vkCmdClearDepthStencilImage-image-02826",
2332 "vkCmdClearDepthStencilImage(): pRanges[%u].aspectMask has a VK_IMAGE_ASPECT_DEPTH_BIT but %s "
2333 "doesn't have a depth component.",
2334 i, string_VkFormat(image_format));
2335 }
Andrew Fobel3abeb992020-01-20 16:33:22 -05002336 }
2337 if ((pRanges[i].aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != 0) {
2338 any_include_aspect_stencil_bit = true;
sfricke-samsung30e325a2020-07-25 12:56:13 -07002339 if (FormatHasStencil(image_format) == false) {
2340 skip |= LogError(commandBuffer, "VUID-vkCmdClearDepthStencilImage-image-02825",
2341 "vkCmdClearDepthStencilImage(): pRanges[%u].aspectMask has a VK_IMAGE_ASPECT_STENCIL_BIT but "
2342 "%s doesn't have a stencil component.",
2343 i, string_VkFormat(image_format));
2344 }
Andrew Fobel3abeb992020-01-20 16:33:22 -05002345 }
2346 }
2347 if (any_include_aspect_stencil_bit) {
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07002348 const auto image_stencil_struct = LvlFindInChain<VkImageStencilUsageCreateInfo>(image_state->createInfo.pNext);
Andrew Fobel3abeb992020-01-20 16:33:22 -05002349 if (image_stencil_struct != nullptr) {
2350 if ((image_stencil_struct->stencilUsage & VK_IMAGE_USAGE_TRANSFER_DST_BIT) == 0) {
2351 skip |=
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002352 LogError(device, "VUID-vkCmdClearDepthStencilImage-pRanges-02658",
2353 "vkCmdClearDepthStencilImage(): an element of pRanges.aspect includes VK_IMAGE_ASPECT_STENCIL_BIT "
2354 "and image was created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_DST_BIT must be "
2355 "included in VkImageStencilUsageCreateInfo::stencilUsage used to create image");
Andrew Fobel3abeb992020-01-20 16:33:22 -05002356 }
2357 } else {
2358 if ((image_state->createInfo.usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT) == 0) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002359 skip |= LogError(
2360 device, "VUID-vkCmdClearDepthStencilImage-pRanges-02659",
Andrew Fobel3abeb992020-01-20 16:33:22 -05002361 "vkCmdClearDepthStencilImage(): an element of pRanges.aspect includes VK_IMAGE_ASPECT_STENCIL_BIT and "
2362 "image was not created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_DST_BIT must be included "
2363 "in VkImageCreateInfo::usage used to create image");
2364 }
2365 }
2366 }
2367 if (any_include_aspect_depth_bit && (image_state->createInfo.usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT) == 0) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002368 skip |= LogError(device, "VUID-vkCmdClearDepthStencilImage-pRanges-02660",
2369 "vkCmdClearDepthStencilImage(): an element of pRanges.aspect includes VK_IMAGE_ASPECT_DEPTH_BIT, "
2370 "VK_IMAGE_USAGE_TRANSFER_DST_BIT must be included in VkImageCreateInfo::usage used to create image");
Mark Lobodzinski1241a312017-02-01 10:57:21 -07002371 }
sfricke-samsung30e325a2020-07-25 12:56:13 -07002372 if (image_state && !FormatIsDepthOrStencil(image_format)) {
sfricke-samsungcd924d92020-05-20 23:51:17 -07002373 skip |= LogError(image, "VUID-vkCmdClearDepthStencilImage-image-00014",
2374 "vkCmdClearDepthStencilImage(): called with image %s which doesn't have a depth/stencil format (%s).",
sfricke-samsung30e325a2020-07-25 12:56:13 -07002375 report_data->FormatHandle(image).c_str(), string_VkFormat(image_format));
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002376 }
Tobin Ehlis4af8c242017-11-30 13:47:11 -07002377 if (VK_IMAGE_USAGE_TRANSFER_DST_BIT != (VK_IMAGE_USAGE_TRANSFER_DST_BIT & image_state->createInfo.usage)) {
sfricke-samsungcd924d92020-05-20 23:51:17 -07002378 skip |= LogError(image, "VUID-vkCmdClearDepthStencilImage-image-00009",
2379 "vkCmdClearDepthStencilImage(): called with image %s which was not created with the "
2380 "VK_IMAGE_USAGE_TRANSFER_DST_BIT set.",
2381 report_data->FormatHandle(image).c_str());
Tobin Ehlis4af8c242017-11-30 13:47:11 -07002382 }
Mark Lobodzinskid81d1012017-02-01 09:03:06 -07002383 }
2384 return skip;
2385}
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002386
John Zulaufeabb4462019-07-05 14:13:03 -06002387void CoreChecks::PreCallRecordCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
2388 const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
2389 const VkImageSubresourceRange *pRanges) {
2390 StateTracker::PreCallRecordCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
Jeremy Gebben332d4dd2022-01-01 12:40:02 -07002391
2392 auto cb_node = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06002393 auto image_state = Get<IMAGE_STATE>(image);
John Zulaufeabb4462019-07-05 14:13:03 -06002394 if (cb_node && image_state) {
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07002395 for (uint32_t i = 0; i < rangeCount; ++i) {
Jeremy Gebben1ec89332021-08-05 13:51:49 -06002396 cb_node->SetImageInitialLayout(image, pRanges[i], imageLayout);
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07002397 }
2398 }
2399}
2400
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002401// Returns true if [x, xoffset] and [y, yoffset] overlap
2402static bool RangesIntersect(int32_t start, uint32_t start_offset, int32_t end, uint32_t end_offset) {
2403 bool result = false;
2404 uint32_t intersection_min = std::max(static_cast<uint32_t>(start), static_cast<uint32_t>(end));
2405 uint32_t intersection_max = std::min(static_cast<uint32_t>(start) + start_offset, static_cast<uint32_t>(end) + end_offset);
2406
2407 if (intersection_max > intersection_min) {
2408 result = true;
2409 }
2410 return result;
2411}
2412
Jeff Leger178b1e52020-10-05 12:22:23 -04002413// Returns true if source area of first vkImageCopy/vkImageCopy2KHR region intersects dest area of second region
Dave Houltonc991cc92018-03-06 11:08:51 -07002414// It is assumed that these are copy regions within a single image (otherwise no possibility of collision)
Jeff Leger178b1e52020-10-05 12:22:23 -04002415template <typename RegionType>
sfricke-samsung71f04e32022-03-16 01:21:21 -05002416static bool RegionIntersects(const RegionType *region0, const RegionType *region1, VkImageType type, bool is_multiplane) {
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002417 bool result = false;
Dave Houltonf5217612018-02-02 16:18:52 -07002418
Dave Houltonc991cc92018-03-06 11:08:51 -07002419 // Separate planes within a multiplane image cannot intersect
sfricke-samsung71f04e32022-03-16 01:21:21 -05002420 if (is_multiplane && (region0->srcSubresource.aspectMask != region1->dstSubresource.aspectMask)) {
Dave Houltonf5217612018-02-02 16:18:52 -07002421 return result;
2422 }
2423
sfricke-samsung71f04e32022-03-16 01:21:21 -05002424 if ((region0->srcSubresource.mipLevel == region1->dstSubresource.mipLevel) &&
2425 (RangesIntersect(region0->srcSubresource.baseArrayLayer, region0->srcSubresource.layerCount,
2426 region1->dstSubresource.baseArrayLayer, region1->dstSubresource.layerCount))) {
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002427 result = true;
2428 switch (type) {
2429 case VK_IMAGE_TYPE_3D:
sfricke-samsung71f04e32022-03-16 01:21:21 -05002430 result &= RangesIntersect(region0->srcOffset.z, region0->extent.depth, region1->dstOffset.z, region1->extent.depth);
Tobin Ehlis648b1cf2018-04-13 15:24:13 -06002431 // fall through
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002432 case VK_IMAGE_TYPE_2D:
sfricke-samsung71f04e32022-03-16 01:21:21 -05002433 result &=
2434 RangesIntersect(region0->srcOffset.y, region0->extent.height, region1->dstOffset.y, region1->extent.height);
Tobin Ehlis648b1cf2018-04-13 15:24:13 -06002435 // fall through
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002436 case VK_IMAGE_TYPE_1D:
sfricke-samsung71f04e32022-03-16 01:21:21 -05002437 result &= RangesIntersect(region0->srcOffset.x, region0->extent.width, region1->dstOffset.x, region1->extent.width);
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002438 break;
2439 default:
2440 // Unrecognized or new IMAGE_TYPE enums will be caught in parameter_validation
2441 assert(false);
2442 }
2443 }
2444 return result;
2445}
2446
aitor-lunarg607fe732022-03-31 22:00:08 +02002447template <typename RegionType>
2448static bool RegionIntersectsBlit(const RegionType *region0, const RegionType *region1, VkImageType type, bool is_multiplane) {
2449 bool result = false;
2450
2451 // Separate planes within a multiplane image cannot intersect
2452 if (is_multiplane && (region0->srcSubresource.aspectMask != region1->dstSubresource.aspectMask)) {
2453 return result;
2454 }
2455
2456 if ((region0->srcSubresource.mipLevel == region1->dstSubresource.mipLevel) &&
2457 (RangesIntersect(region0->srcSubresource.baseArrayLayer, region0->srcSubresource.layerCount,
2458 region1->dstSubresource.baseArrayLayer, region1->dstSubresource.layerCount))) {
2459 result = true;
2460 switch (type) {
2461 case VK_IMAGE_TYPE_3D:
2462 result &= RangesIntersect(region0->srcOffsets[0].z, region0->srcOffsets[1].z - region0->srcOffsets[0].z,
2463 region1->dstOffsets[0].z, region1->dstOffsets[1].z - region1->dstOffsets[0].z);
2464 // fall through
2465 case VK_IMAGE_TYPE_2D:
2466 result &= RangesIntersect(region0->srcOffsets[0].y, region0->srcOffsets[1].y - region0->srcOffsets[0].y,
2467 region1->dstOffsets[0].y, region1->dstOffsets[1].y - region1->dstOffsets[0].y);
2468 // fall through
2469 case VK_IMAGE_TYPE_1D:
2470 result &= RangesIntersect(region0->srcOffsets[0].x, region0->srcOffsets[1].x - region0->srcOffsets[0].x,
2471 region1->dstOffsets[0].x, region1->dstOffsets[1].x - region1->dstOffsets[0].x);
2472 break;
2473 default:
2474 // Unrecognized or new IMAGE_TYPE enums will be caught in parameter_validation
2475 assert(false);
2476 }
2477 }
2478 return result;
2479}
2480
Dave Houltonfc1a4052017-04-27 14:32:45 -06002481// Returns non-zero if offset and extent exceed image extents
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07002482static const uint32_t kXBit = 1;
2483static const uint32_t kYBit = 2;
2484static const uint32_t kZBit = 4;
Dave Houlton1150cf52017-04-27 14:38:11 -06002485static uint32_t ExceedsBounds(const VkOffset3D *offset, const VkExtent3D *extent, const VkExtent3D *image_extent) {
Dave Houltonfc1a4052017-04-27 14:32:45 -06002486 uint32_t result = 0;
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002487 // Extents/depths cannot be negative but checks left in for clarity
Dave Houlton9dae7ec2017-03-01 16:23:25 -07002488 if ((offset->z + extent->depth > image_extent->depth) || (offset->z < 0) ||
2489 ((offset->z + static_cast<int32_t>(extent->depth)) < 0)) {
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07002490 result |= kZBit;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07002491 }
2492 if ((offset->y + extent->height > image_extent->height) || (offset->y < 0) ||
2493 ((offset->y + static_cast<int32_t>(extent->height)) < 0)) {
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07002494 result |= kYBit;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07002495 }
2496 if ((offset->x + extent->width > image_extent->width) || (offset->x < 0) ||
2497 ((offset->x + static_cast<int32_t>(extent->width)) < 0)) {
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07002498 result |= kXBit;
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002499 }
2500 return result;
2501}
2502
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002503// Test if two VkExtent3D structs are equivalent
2504static inline bool IsExtentEqual(const VkExtent3D *extent, const VkExtent3D *other_extent) {
2505 bool result = true;
2506 if ((extent->width != other_extent->width) || (extent->height != other_extent->height) ||
2507 (extent->depth != other_extent->depth)) {
2508 result = false;
2509 }
2510 return result;
2511}
2512
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002513// Test if the extent argument has all dimensions set to 0.
Dave Houlton9dae7ec2017-03-01 16:23:25 -07002514static inline bool IsExtentAllZeroes(const VkExtent3D *extent) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002515 return ((extent->width == 0) && (extent->height == 0) && (extent->depth == 0));
2516}
2517
2518// Returns the image transfer granularity for a specific image scaled by compressed block size if necessary.
John Zulaufe2b7bcb2019-07-05 16:08:39 -06002519VkExtent3D CoreChecks::GetScaledItg(const CMD_BUFFER_STATE *cb_node, const IMAGE_STATE *img) const {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002520 // Default to (0, 0, 0) granularity in case we can't find the real granularity for the physical device.
2521 VkExtent3D granularity = {0, 0, 0};
Jeremy Gebbencd7fa282021-10-27 10:25:32 -06002522 const auto pool = cb_node->command_pool;
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07002523 if (pool) {
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06002524 granularity = physical_device_state->queue_family_properties[pool->queueFamilyIndex].minImageTransferGranularity;
sfricke-samsung01da6312021-10-20 07:51:32 -07002525 if (FormatIsBlockedImage(img->createInfo.format)) {
Dave Houltona585d132019-01-18 13:05:42 -07002526 auto block_size = FormatTexelBlockExtent(img->createInfo.format);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002527 granularity.width *= block_size.width;
2528 granularity.height *= block_size.height;
2529 }
2530 }
2531 return granularity;
2532}
2533
2534// Test elements of a VkExtent3D structure against alignment constraints contained in another VkExtent3D structure
2535static inline bool IsExtentAligned(const VkExtent3D *extent, const VkExtent3D *granularity) {
2536 bool valid = true;
Dave Houlton1d2022c2017-03-29 11:43:58 -06002537 if ((SafeModulo(extent->depth, granularity->depth) != 0) || (SafeModulo(extent->width, granularity->width) != 0) ||
2538 (SafeModulo(extent->height, granularity->height) != 0)) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002539 valid = false;
2540 }
2541 return valid;
2542}
2543
2544// Check elements of a VkOffset3D structure against a queue family's Image Transfer Granularity values
Mark Lobodzinski33a34b82019-04-25 11:38:36 -06002545bool CoreChecks::CheckItgOffset(const CMD_BUFFER_STATE *cb_node, const VkOffset3D *offset, const VkExtent3D *granularity,
John Zulaufe2b7bcb2019-07-05 16:08:39 -06002546 const uint32_t i, const char *function, const char *member, const char *vuid) const {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002547 bool skip = false;
2548 VkExtent3D offset_extent = {};
2549 offset_extent.width = static_cast<uint32_t>(abs(offset->x));
2550 offset_extent.height = static_cast<uint32_t>(abs(offset->y));
2551 offset_extent.depth = static_cast<uint32_t>(abs(offset->z));
Dave Houlton9dae7ec2017-03-01 16:23:25 -07002552 if (IsExtentAllZeroes(granularity)) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002553 // 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 -07002554 if (IsExtentAllZeroes(&offset_extent) == false) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002555 skip |= LogError(cb_node->commandBuffer(), vuid,
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002556 "%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 "
2557 "image transfer granularity is (w=0, h=0, d=0).",
2558 function, i, member, offset->x, offset->y, offset->z);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002559 }
2560 } else {
2561 // If the queue family image transfer granularity is not (0, 0, 0), then the offset dimensions must always be even
2562 // integer multiples of the image transfer granularity.
2563 if (IsExtentAligned(&offset_extent, granularity) == false) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002564 skip |= LogError(cb_node->commandBuffer(), vuid,
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002565 "%s: pRegion[%d].%s (x=%d, y=%d, z=%d) dimensions must be even integer multiples of this command "
2566 "buffer's queue family image transfer granularity (w=%d, h=%d, d=%d).",
2567 function, i, member, offset->x, offset->y, offset->z, granularity->width, granularity->height,
2568 granularity->depth);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002569 }
2570 }
2571 return skip;
2572}
2573
2574// Check elements of a VkExtent3D structure against a queue family's Image Transfer Granularity values
Mark Lobodzinski33a34b82019-04-25 11:38:36 -06002575bool CoreChecks::CheckItgExtent(const CMD_BUFFER_STATE *cb_node, const VkExtent3D *extent, const VkOffset3D *offset,
Mark Lobodzinskifbeb0ca2019-03-09 11:48:22 -07002576 const VkExtent3D *granularity, const VkExtent3D *subresource_extent, const VkImageType image_type,
John Zulaufe2b7bcb2019-07-05 16:08:39 -06002577 const uint32_t i, const char *function, const char *member, const char *vuid) const {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002578 bool skip = false;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07002579 if (IsExtentAllZeroes(granularity)) {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002580 // If the queue family image transfer granularity is (0, 0, 0), then the extent must always match the image
2581 // subresource extent.
2582 if (IsExtentEqual(extent, subresource_extent) == false) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002583 skip |= LogError(cb_node->commandBuffer(), vuid,
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002584 "%s: pRegion[%d].%s (w=%d, h=%d, d=%d) must match the image subresource extents (w=%d, h=%d, d=%d) "
2585 "when the command buffer's queue family image transfer granularity is (w=0, h=0, d=0).",
2586 function, i, member, extent->width, extent->height, extent->depth, subresource_extent->width,
2587 subresource_extent->height, subresource_extent->depth);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002588 }
2589 } else {
2590 // If the queue family image transfer granularity is not (0, 0, 0), then the extent dimensions must always be even
2591 // integer multiples of the image transfer granularity or the offset + extent dimensions must always match the image
2592 // subresource extent dimensions.
2593 VkExtent3D offset_extent_sum = {};
2594 offset_extent_sum.width = static_cast<uint32_t>(abs(offset->x)) + extent->width;
2595 offset_extent_sum.height = static_cast<uint32_t>(abs(offset->y)) + extent->height;
2596 offset_extent_sum.depth = static_cast<uint32_t>(abs(offset->z)) + extent->depth;
Mark Lobodzinski283ade62017-10-09 16:36:49 -06002597 bool x_ok = true;
2598 bool y_ok = true;
2599 bool z_ok = true;
2600 switch (image_type) {
2601 case VK_IMAGE_TYPE_3D:
2602 z_ok = ((0 == SafeModulo(extent->depth, granularity->depth)) ||
2603 (subresource_extent->depth == offset_extent_sum.depth));
Tobin Ehlis648b1cf2018-04-13 15:24:13 -06002604 // fall through
Mark Lobodzinski283ade62017-10-09 16:36:49 -06002605 case VK_IMAGE_TYPE_2D:
2606 y_ok = ((0 == SafeModulo(extent->height, granularity->height)) ||
2607 (subresource_extent->height == offset_extent_sum.height));
Tobin Ehlis648b1cf2018-04-13 15:24:13 -06002608 // fall through
Mark Lobodzinski283ade62017-10-09 16:36:49 -06002609 case VK_IMAGE_TYPE_1D:
2610 x_ok = ((0 == SafeModulo(extent->width, granularity->width)) ||
2611 (subresource_extent->width == offset_extent_sum.width));
2612 break;
2613 default:
2614 // Unrecognized or new IMAGE_TYPE enums will be caught in parameter_validation
2615 assert(false);
2616 }
Dave Houlton6f9059e2017-05-02 17:15:13 -06002617 if (!(x_ok && y_ok && z_ok)) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002618 skip |=
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002619 LogError(cb_node->commandBuffer(), vuid,
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002620 "%s: pRegion[%d].%s (w=%d, h=%d, d=%d) dimensions must be even integer multiples of this command "
2621 "buffer's queue family image transfer granularity (w=%d, h=%d, d=%d) or offset (x=%d, y=%d, z=%d) + "
2622 "extent (w=%d, h=%d, d=%d) must match the image subresource extents (w=%d, h=%d, d=%d).",
2623 function, i, member, extent->width, extent->height, extent->depth, granularity->width, granularity->height,
2624 granularity->depth, offset->x, offset->y, offset->z, extent->width, extent->height, extent->depth,
2625 subresource_extent->width, subresource_extent->height, subresource_extent->depth);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002626 }
2627 }
2628 return skip;
2629}
2630
Mark Lobodzinski33a34b82019-04-25 11:38:36 -06002631bool CoreChecks::ValidateImageMipLevel(const CMD_BUFFER_STATE *cb_node, const IMAGE_STATE *img, uint32_t mip_level,
John Zulaufe2b7bcb2019-07-05 16:08:39 -06002632 const uint32_t i, const char *function, const char *member, const char *vuid) const {
Cort Strattonff1542a2018-05-27 10:49:28 -07002633 bool skip = false;
2634 if (mip_level >= img->createInfo.mipLevels) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002635 skip |= LogError(cb_node->commandBuffer(), vuid, "In %s, pRegions[%u].%s.mipLevel is %u, but provided %s has %u mip levels.",
2636 function, i, member, mip_level, report_data->FormatHandle(img->image()).c_str(), img->createInfo.mipLevels);
Cort Strattonff1542a2018-05-27 10:49:28 -07002637 }
2638 return skip;
2639}
2640
Mark Lobodzinski33a34b82019-04-25 11:38:36 -06002641bool CoreChecks::ValidateImageArrayLayerRange(const CMD_BUFFER_STATE *cb_node, const IMAGE_STATE *img, const uint32_t base_layer,
Mark Lobodzinskifbeb0ca2019-03-09 11:48:22 -07002642 const uint32_t layer_count, const uint32_t i, const char *function,
John Zulaufe2b7bcb2019-07-05 16:08:39 -06002643 const char *member, const char *vuid) const {
Cort Strattonff1542a2018-05-27 10:49:28 -07002644 bool skip = false;
2645 if (base_layer >= img->createInfo.arrayLayers || layer_count > img->createInfo.arrayLayers ||
2646 (base_layer + layer_count) > img->createInfo.arrayLayers) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002647 skip |= LogError(cb_node->commandBuffer(), vuid,
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002648 "In %s, pRegions[%u].%s.baseArrayLayer is %u and .layerCount is "
2649 "%u, but provided %s has %u array layers.",
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002650 function, i, member, base_layer, layer_count, report_data->FormatHandle(img->image()).c_str(),
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002651 img->createInfo.arrayLayers);
Cort Strattonff1542a2018-05-27 10:49:28 -07002652 }
2653 return skip;
2654}
2655
Tony Barbour845d29b2021-11-09 11:43:14 -07002656// Check valid usage Image Transfer Granularity requirements for elements of a VkBufferImageCopy/VkBufferImageCopy2 structure
sfricke-samsung71f04e32022-03-16 01:21:21 -05002657template <typename RegionType>
Mark Lobodzinski33a34b82019-04-25 11:38:36 -06002658bool CoreChecks::ValidateCopyBufferImageTransferGranularityRequirements(const CMD_BUFFER_STATE *cb_node, const IMAGE_STATE *img,
sfricke-samsung71f04e32022-03-16 01:21:21 -05002659 const RegionType *region, const uint32_t i,
John Zulaufe3d1c8a2019-08-12 14:34:58 -06002660 const char *function, const char *vuid) const {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002661 bool skip = false;
Mark Lobodzinskifbeb0ca2019-03-09 11:48:22 -07002662 VkExtent3D granularity = GetScaledItg(cb_node, img);
2663 skip |= CheckItgOffset(cb_node, &region->imageOffset, &granularity, i, function, "imageOffset", vuid);
Jeremy Gebben1dfbd172021-05-19 14:00:58 -06002664 VkExtent3D subresource_extent = img->GetSubresourceExtent(region->imageSubresource);
Mark Lobodzinskifbeb0ca2019-03-09 11:48:22 -07002665 skip |= CheckItgExtent(cb_node, &region->imageExtent, &region->imageOffset, &granularity, &subresource_extent,
Cort Stratton420ebd42018-05-04 01:12:23 -04002666 img->createInfo.imageType, i, function, "imageExtent", vuid);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002667 return skip;
2668}
2669
Jeff Leger178b1e52020-10-05 12:22:23 -04002670// Check valid usage Image Transfer Granularity requirements for elements of a VkImageCopy/VkImageCopy2KHR structure
2671template <typename RegionType>
Mark Lobodzinski33a34b82019-04-25 11:38:36 -06002672bool CoreChecks::ValidateCopyImageTransferGranularityRequirements(const CMD_BUFFER_STATE *cb_node, const IMAGE_STATE *src_img,
Jeff Leger178b1e52020-10-05 12:22:23 -04002673 const IMAGE_STATE *dst_img, const RegionType *region,
2674 const uint32_t i, const char *function,
Tony-LunarGb61514a2021-11-02 12:36:51 -06002675 CMD_TYPE cmd_type) const {
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002676 bool skip = false;
Tony-LunarGb61514a2021-11-02 12:36:51 -06002677 const bool is_2 = (cmd_type == CMD_COPYIMAGE2KHR || cmd_type == CMD_COPYIMAGE2);
Jeff Leger178b1e52020-10-05 12:22:23 -04002678 const char *vuid;
2679
Mark Lobodzinskid0788802017-10-19 15:38:59 -06002680 // Source image checks
Mark Lobodzinskifbeb0ca2019-03-09 11:48:22 -07002681 VkExtent3D granularity = GetScaledItg(cb_node, src_img);
Tony-LunarGb61514a2021-11-02 12:36:51 -06002682 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcOffset-01783" : "VUID-vkCmdCopyImage-srcOffset-01783";
Jeff Leger178b1e52020-10-05 12:22:23 -04002683 skip |= CheckItgOffset(cb_node, &region->srcOffset, &granularity, i, function, "srcOffset", vuid);
Jeremy Gebben1dfbd172021-05-19 14:00:58 -06002684 VkExtent3D subresource_extent = src_img->GetSubresourceExtent(region->srcSubresource);
Dave Houlton94a00372017-12-14 15:08:47 -07002685 const VkExtent3D extent = region->extent;
Tony-LunarGb61514a2021-11-02 12:36:51 -06002686 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcOffset-01783" : "VUID-vkCmdCopyImage-srcOffset-01783";
Mark Lobodzinskifbeb0ca2019-03-09 11:48:22 -07002687 skip |= CheckItgExtent(cb_node, &extent, &region->srcOffset, &granularity, &subresource_extent, src_img->createInfo.imageType,
Jeff Leger178b1e52020-10-05 12:22:23 -04002688 i, function, "extent", vuid);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002689
Mark Lobodzinskid0788802017-10-19 15:38:59 -06002690 // Destination image checks
Mark Lobodzinskifbeb0ca2019-03-09 11:48:22 -07002691 granularity = GetScaledItg(cb_node, dst_img);
Tony-LunarGb61514a2021-11-02 12:36:51 -06002692 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstOffset-01784" : "VUID-vkCmdCopyImage-dstOffset-01784";
Jeff Leger178b1e52020-10-05 12:22:23 -04002693 skip |= CheckItgOffset(cb_node, &region->dstOffset, &granularity, i, function, "dstOffset", vuid);
Dave Houltonee281a52017-12-08 13:51:02 -07002694 // Adjust dest extent, if necessary
Dave Houlton94a00372017-12-14 15:08:47 -07002695 const VkExtent3D dest_effective_extent =
2696 GetAdjustedDestImageExtent(src_img->createInfo.format, dst_img->createInfo.format, extent);
Jeremy Gebben1dfbd172021-05-19 14:00:58 -06002697 subresource_extent = dst_img->GetSubresourceExtent(region->dstSubresource);
Tony-LunarGb61514a2021-11-02 12:36:51 -06002698 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstOffset-01784" : "VUID-vkCmdCopyImage-dstOffset-01784";
Mark Lobodzinskifbeb0ca2019-03-09 11:48:22 -07002699 skip |= CheckItgExtent(cb_node, &dest_effective_extent, &region->dstOffset, &granularity, &subresource_extent,
Jeff Leger178b1e52020-10-05 12:22:23 -04002700 dst_img->createInfo.imageType, i, function, "extent", vuid);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07002701 return skip;
2702}
2703
Jeff Leger178b1e52020-10-05 12:22:23 -04002704// Validate contents of a VkImageCopy or VkImageCopy2KHR struct
sfricke-samsung71f04e32022-03-16 01:21:21 -05002705template <typename RegionType>
2706bool CoreChecks::ValidateImageCopyData(const uint32_t regionCount, const RegionType *pRegions, const IMAGE_STATE *src_state,
2707 const IMAGE_STATE *dst_state, CMD_TYPE cmd_type) const {
Dave Houlton6f9059e2017-05-02 17:15:13 -06002708 bool skip = false;
Tony-LunarGb61514a2021-11-02 12:36:51 -06002709 const bool is_2 = (cmd_type == CMD_COPYIMAGE2KHR || cmd_type == CMD_COPYIMAGE2);
2710 const char *func_name = CommandTypeString(cmd_type);
Jeff Leger178b1e52020-10-05 12:22:23 -04002711 const char *vuid;
Dave Houlton6f9059e2017-05-02 17:15:13 -06002712
2713 for (uint32_t i = 0; i < regionCount; i++) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05002714 const RegionType region = pRegions[i];
Dave Houltonee281a52017-12-08 13:51:02 -07002715
2716 // For comp<->uncomp copies, the copy extent for the dest image must be adjusted
Dave Houlton94a00372017-12-14 15:08:47 -07002717 const VkExtent3D src_copy_extent = region.extent;
2718 const VkExtent3D dst_copy_extent =
Dave Houltonee281a52017-12-08 13:51:02 -07002719 GetAdjustedDestImageExtent(src_state->createInfo.format, dst_state->createInfo.format, region.extent);
2720
Dave Houlton6f9059e2017-05-02 17:15:13 -06002721 bool slice_override = false;
2722 uint32_t depth_slices = 0;
2723
2724 // Special case for copying between a 1D/2D array and a 3D image
2725 // TBD: This seems like the only way to reconcile 3 mutually-exclusive VU checks for 2D/3D copies. Heads up.
2726 if ((VK_IMAGE_TYPE_3D == src_state->createInfo.imageType) && (VK_IMAGE_TYPE_3D != dst_state->createInfo.imageType)) {
Dave Houltonee281a52017-12-08 13:51:02 -07002727 depth_slices = region.dstSubresource.layerCount; // Slice count from 2D subresource
Dave Houlton6f9059e2017-05-02 17:15:13 -06002728 slice_override = (depth_slices != 1);
2729 } 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 -07002730 depth_slices = region.srcSubresource.layerCount; // Slice count from 2D subresource
Dave Houlton6f9059e2017-05-02 17:15:13 -06002731 slice_override = (depth_slices != 1);
2732 }
2733
2734 // Do all checks on source image
Dave Houlton6f9059e2017-05-02 17:15:13 -06002735 if (src_state->createInfo.imageType == VK_IMAGE_TYPE_1D) {
Dave Houltonee281a52017-12-08 13:51:02 -07002736 if ((0 != region.srcOffset.y) || (1 != src_copy_extent.height)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002737 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-00146" : "VUID-vkCmdCopyImage-srcImage-00146";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002738 skip |= LogError(src_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04002739 "%s: pRegion[%d] srcOffset.y is %d and extent.height is %d. For 1D images these must "
2740 "be 0 and 1, respectively.",
2741 func_name, i, region.srcOffset.y, src_copy_extent.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002742 }
2743 }
2744
Dave Houlton533be9f2018-03-26 17:08:30 -06002745 if ((src_state->createInfo.imageType == VK_IMAGE_TYPE_1D) && ((0 != region.srcOffset.z) || (1 != src_copy_extent.depth))) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002746 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-01785" : "VUID-vkCmdCopyImage-srcImage-01785";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002747 skip |= LogError(src_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04002748 "%s: pRegion[%d] srcOffset.z is %d and extent.depth is %d. For 1D images "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002749 "these must be 0 and 1, respectively.",
Jeff Leger178b1e52020-10-05 12:22:23 -04002750 func_name, i, region.srcOffset.z, src_copy_extent.depth);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002751 }
2752
Dave Houlton533be9f2018-03-26 17:08:30 -06002753 if ((src_state->createInfo.imageType == VK_IMAGE_TYPE_2D) && (0 != region.srcOffset.z)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002754 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-01787" : "VUID-vkCmdCopyImage-srcImage-01787";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002755 skip |= LogError(src_state->image(), vuid, "%s: pRegion[%d] srcOffset.z is %d. For 2D images the z-offset must be 0.",
Jeff Leger178b1e52020-10-05 12:22:23 -04002756 func_name, i, region.srcOffset.z);
Dave Houlton533be9f2018-03-26 17:08:30 -06002757 }
2758
sfricke-samsung01da6312021-10-20 07:51:32 -07002759 // Source checks that apply only to "blocked images"
2760 if (FormatIsBlockedImage(src_state->createInfo.format)) {
Dave Houltona585d132019-01-18 13:05:42 -07002761 const VkExtent3D block_size = FormatTexelBlockExtent(src_state->createInfo.format);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002762 // image offsets must be multiples of block dimensions
Dave Houltonee281a52017-12-08 13:51:02 -07002763 if ((SafeModulo(region.srcOffset.x, block_size.width) != 0) ||
2764 (SafeModulo(region.srcOffset.y, block_size.height) != 0) ||
2765 (SafeModulo(region.srcOffset.z, block_size.depth) != 0)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002766 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-01727" : "VUID-vkCmdCopyImage-srcImage-01727";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002767 skip |= LogError(src_state->image(), vuid,
sfricke-samsung01da6312021-10-20 07:51:32 -07002768 "%s: pRegion[%d] srcOffset (%d, %d) must be multiples of the blocked image's "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002769 "texel width & height (%d, %d).",
Jeff Leger178b1e52020-10-05 12:22:23 -04002770 func_name, i, region.srcOffset.x, region.srcOffset.y, block_size.width, block_size.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002771 }
2772
Jeremy Gebben1dfbd172021-05-19 14:00:58 -06002773 const VkExtent3D mip_extent = src_state->GetSubresourceExtent(region.srcSubresource);
Dave Houltonee281a52017-12-08 13:51:02 -07002774 if ((SafeModulo(src_copy_extent.width, block_size.width) != 0) &&
2775 (src_copy_extent.width + region.srcOffset.x != mip_extent.width)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002776 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-01728" : "VUID-vkCmdCopyImage-srcImage-01728";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002777 skip |= LogError(src_state->image(), vuid,
sfricke-samsung01da6312021-10-20 07:51:32 -07002778 "%s: pRegion[%d] extent width (%d) must be a multiple of the blocked texture block "
Jeff Leger178b1e52020-10-05 12:22:23 -04002779 "width (%d), or when added to srcOffset.x (%d) must equal the image subresource width (%d).",
2780 func_name, i, src_copy_extent.width, block_size.width, region.srcOffset.x, mip_extent.width);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002781 }
2782
Mark Lobodzinskid0788802017-10-19 15:38:59 -06002783 // Extent height must be a multiple of block height, or extent+offset height must equal subresource height
Dave Houltonee281a52017-12-08 13:51:02 -07002784 if ((SafeModulo(src_copy_extent.height, block_size.height) != 0) &&
2785 (src_copy_extent.height + region.srcOffset.y != mip_extent.height)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002786 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-01729" : "VUID-vkCmdCopyImage-srcImage-01729";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002787 skip |= LogError(src_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04002788 "%s: pRegion[%d] extent height (%d) must be a multiple of the compressed texture block "
2789 "height (%d), or when added to srcOffset.y (%d) must equal the image subresource height (%d).",
2790 func_name, i, src_copy_extent.height, block_size.height, region.srcOffset.y, mip_extent.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002791 }
2792
Mark Lobodzinskid0788802017-10-19 15:38:59 -06002793 // Extent depth must be a multiple of block depth, or extent+offset depth must equal subresource depth
Dave Houltonee281a52017-12-08 13:51:02 -07002794 uint32_t copy_depth = (slice_override ? depth_slices : src_copy_extent.depth);
2795 if ((SafeModulo(copy_depth, block_size.depth) != 0) && (copy_depth + region.srcOffset.z != mip_extent.depth)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002796 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-01730" : "VUID-vkCmdCopyImage-srcImage-01730";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002797 skip |= LogError(src_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04002798 "%s: pRegion[%d] extent width (%d) must be a multiple of the compressed texture block "
2799 "depth (%d), or when added to srcOffset.z (%d) must equal the image subresource depth (%d).",
2800 func_name, i, src_copy_extent.depth, block_size.depth, region.srcOffset.z, mip_extent.depth);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002801 }
2802 } // Compressed
2803
2804 // Do all checks on dest image
Dave Houlton6f9059e2017-05-02 17:15:13 -06002805 if (dst_state->createInfo.imageType == VK_IMAGE_TYPE_1D) {
Dave Houltonee281a52017-12-08 13:51:02 -07002806 if ((0 != region.dstOffset.y) || (1 != dst_copy_extent.height)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002807 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-00152" : "VUID-vkCmdCopyImage-dstImage-00152";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002808 skip |= LogError(dst_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04002809 "%s: pRegion[%d] dstOffset.y is %d and dst_copy_extent.height is %d. For 1D images "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002810 "these must be 0 and 1, respectively.",
Jeff Leger178b1e52020-10-05 12:22:23 -04002811 func_name, i, region.dstOffset.y, dst_copy_extent.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002812 }
2813 }
2814
Dave Houlton533be9f2018-03-26 17:08:30 -06002815 if ((dst_state->createInfo.imageType == VK_IMAGE_TYPE_1D) && ((0 != region.dstOffset.z) || (1 != dst_copy_extent.depth))) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002816 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-01786" : "VUID-vkCmdCopyImage-dstImage-01786";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002817 skip |= LogError(dst_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04002818 "%s: pRegion[%d] dstOffset.z is %d and extent.depth is %d. For 1D images these must be 0 "
2819 "and 1, respectively.",
2820 func_name, i, region.dstOffset.z, dst_copy_extent.depth);
Dave Houlton533be9f2018-03-26 17:08:30 -06002821 }
2822
Dave Houlton533be9f2018-03-26 17:08:30 -06002823 if ((dst_state->createInfo.imageType == VK_IMAGE_TYPE_2D) && (0 != region.dstOffset.z)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002824 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-01788" : "VUID-vkCmdCopyImage-dstImage-01788";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002825 skip |= LogError(dst_state->image(), vuid, "%s: pRegion[%d] dstOffset.z is %d. For 2D images the z-offset must be 0.",
Jeff Leger178b1e52020-10-05 12:22:23 -04002826 func_name, i, region.dstOffset.z);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002827 }
2828
sfricke-samsung30b094c2020-05-30 11:42:11 -07002829 // Handle difference between Maintenance 1
sfricke-samsung45996a42021-09-16 13:45:27 -07002830 if (IsExtEnabled(device_extensions.vk_khr_maintenance1)) {
sfricke-samsung30b094c2020-05-30 11:42:11 -07002831 if (src_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
2832 if ((0 != region.srcSubresource.baseArrayLayer) || (1 != region.srcSubresource.layerCount)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002833 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-04443" : "VUID-vkCmdCopyImage-srcImage-04443";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002834 skip |= LogError(src_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04002835 "%s: pRegion[%d] srcSubresource.baseArrayLayer is %d and srcSubresource.layerCount "
2836 "is %d. For VK_IMAGE_TYPE_3D images these must be 0 and 1, respectively.",
2837 func_name, i, region.srcSubresource.baseArrayLayer, region.srcSubresource.layerCount);
sfricke-samsung30b094c2020-05-30 11:42:11 -07002838 }
2839 }
Dave Houlton6f9059e2017-05-02 17:15:13 -06002840 if (dst_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
Dave Houltonee281a52017-12-08 13:51:02 -07002841 if ((0 != region.dstSubresource.baseArrayLayer) || (1 != region.dstSubresource.layerCount)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002842 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-04444" : "VUID-vkCmdCopyImage-dstImage-04444";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002843 skip |= LogError(dst_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04002844 "%s: pRegion[%d] dstSubresource.baseArrayLayer is %d and dstSubresource.layerCount "
2845 "is %d. For VK_IMAGE_TYPE_3D images these must be 0 and 1, respectively.",
2846 func_name, i, region.dstSubresource.baseArrayLayer, region.dstSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002847 }
2848 }
2849 } else { // Pre maint 1
2850 if (src_state->createInfo.imageType == VK_IMAGE_TYPE_3D || dst_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
sfricke-samsung30b094c2020-05-30 11:42:11 -07002851 if ((0 != region.srcSubresource.baseArrayLayer) || (1 != region.srcSubresource.layerCount)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002852 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-00139" : "VUID-vkCmdCopyImage-srcImage-00139";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002853 skip |= LogError(src_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04002854 "%s: pRegion[%d] srcSubresource.baseArrayLayer is %d and "
sfricke-samsung30b094c2020-05-30 11:42:11 -07002855 "srcSubresource.layerCount is %d. For copies with either source or dest of type "
2856 "VK_IMAGE_TYPE_3D, these must be 0 and 1, respectively.",
Jeff Leger178b1e52020-10-05 12:22:23 -04002857 func_name, i, region.srcSubresource.baseArrayLayer, region.srcSubresource.layerCount);
sfricke-samsung30b094c2020-05-30 11:42:11 -07002858 }
Dave Houltonee281a52017-12-08 13:51:02 -07002859 if ((0 != region.dstSubresource.baseArrayLayer) || (1 != region.dstSubresource.layerCount)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002860 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-00139" : "VUID-vkCmdCopyImage-srcImage-00139";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002861 skip |= LogError(dst_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04002862 "%s: pRegion[%d] dstSubresource.baseArrayLayer is %d and "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002863 "dstSubresource.layerCount is %d. For copies with either source or dest of type "
2864 "VK_IMAGE_TYPE_3D, these must be 0 and 1, respectively.",
Jeff Leger178b1e52020-10-05 12:22:23 -04002865 func_name, i, region.dstSubresource.baseArrayLayer, region.dstSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002866 }
2867 }
2868 }
2869
sfricke-samsung01da6312021-10-20 07:51:32 -07002870 // Dest checks that apply only to "blocked images"
2871 if (FormatIsBlockedImage(dst_state->createInfo.format)) {
Dave Houltona585d132019-01-18 13:05:42 -07002872 const VkExtent3D block_size = FormatTexelBlockExtent(dst_state->createInfo.format);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002873
2874 // image offsets must be multiples of block dimensions
Dave Houltonee281a52017-12-08 13:51:02 -07002875 if ((SafeModulo(region.dstOffset.x, block_size.width) != 0) ||
2876 (SafeModulo(region.dstOffset.y, block_size.height) != 0) ||
2877 (SafeModulo(region.dstOffset.z, block_size.depth) != 0)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002878 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-01731" : "VUID-vkCmdCopyImage-dstImage-01731";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002879 skip |= LogError(dst_state->image(), vuid,
sfricke-samsung01da6312021-10-20 07:51:32 -07002880 "%s: pRegion[%d] dstOffset (%d, %d) must be multiples of the blocked image's "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002881 "texel width & height (%d, %d).",
Jeff Leger178b1e52020-10-05 12:22:23 -04002882 func_name, i, region.dstOffset.x, region.dstOffset.y, block_size.width, block_size.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002883 }
2884
Jeremy Gebben1dfbd172021-05-19 14:00:58 -06002885 const VkExtent3D mip_extent = dst_state->GetSubresourceExtent(region.dstSubresource);
Dave Houltonee281a52017-12-08 13:51:02 -07002886 if ((SafeModulo(dst_copy_extent.width, block_size.width) != 0) &&
2887 (dst_copy_extent.width + region.dstOffset.x != mip_extent.width)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002888 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-01732" : "VUID-vkCmdCopyImage-dstImage-01732";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002889 skip |= LogError(dst_state->image(), vuid,
sfricke-samsung01da6312021-10-20 07:51:32 -07002890 "%s: pRegion[%d] dst_copy_extent width (%d) must be a multiple of the blocked texture "
Jeff Leger178b1e52020-10-05 12:22:23 -04002891 "block width (%d), or when added to dstOffset.x (%d) must equal the image subresource width (%d).",
2892 func_name, i, dst_copy_extent.width, block_size.width, region.dstOffset.x, mip_extent.width);
Mark Lobodzinskid0788802017-10-19 15:38:59 -06002893 }
2894
Dave Houltonee281a52017-12-08 13:51:02 -07002895 // Extent height must be a multiple of block height, or dst_copy_extent+offset height must equal subresource height
2896 if ((SafeModulo(dst_copy_extent.height, block_size.height) != 0) &&
2897 (dst_copy_extent.height + region.dstOffset.y != mip_extent.height)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002898 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-01733" : "VUID-vkCmdCopyImage-dstImage-01733";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002899 skip |= LogError(dst_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04002900 "%s: pRegion[%d] dst_copy_extent height (%d) must be a multiple of the compressed "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07002901 "texture block height (%d), or when added to dstOffset.y (%d) must equal the image subresource "
2902 "height (%d).",
Jeff Leger178b1e52020-10-05 12:22:23 -04002903 func_name, i, dst_copy_extent.height, block_size.height, region.dstOffset.y, mip_extent.height);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002904 }
2905
Dave Houltonee281a52017-12-08 13:51:02 -07002906 // Extent depth must be a multiple of block depth, or dst_copy_extent+offset depth must equal subresource depth
2907 uint32_t copy_depth = (slice_override ? depth_slices : dst_copy_extent.depth);
2908 if ((SafeModulo(copy_depth, block_size.depth) != 0) && (copy_depth + region.dstOffset.z != mip_extent.depth)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002909 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-01734" : "VUID-vkCmdCopyImage-dstImage-01734";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002910 skip |= LogError(dst_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04002911 "%s: pRegion[%d] dst_copy_extent width (%d) must be a multiple of the compressed texture "
2912 "block depth (%d), or when added to dstOffset.z (%d) must equal the image subresource depth (%d).",
2913 func_name, i, dst_copy_extent.depth, block_size.depth, region.dstOffset.z, mip_extent.depth);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002914 }
2915 } // Compressed
2916 }
2917 return skip;
2918}
2919
Jeff Leger178b1e52020-10-05 12:22:23 -04002920template <typename RegionType>
2921bool CoreChecks::ValidateCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
2922 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
Tony-LunarGb61514a2021-11-02 12:36:51 -06002923 const RegionType *pRegions, CMD_TYPE cmd_type) const {
Jeremy Gebbenb68fa022022-01-28 10:08:37 -07002924 auto cb_node = GetRead<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenf4449392022-01-28 10:09:10 -07002925 auto src_image_state = Get<IMAGE_STATE>(srcImage);
2926 auto dst_image_state = Get<IMAGE_STATE>(dstImage);
sfricke-samsungdce5f692020-03-07 13:59:31 -08002927 const VkFormat src_format = src_image_state->createInfo.format;
2928 const VkFormat dst_format = dst_image_state->createInfo.format;
Tony-LunarGb61514a2021-11-02 12:36:51 -06002929 const bool is_2 = (cmd_type == CMD_COPYIMAGE2KHR || cmd_type == CMD_COPYIMAGE2);;
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002930 bool skip = false;
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07002931
sfricke-samsung85584a72021-09-30 21:43:38 -07002932 const char *func_name = CommandTypeString(cmd_type);
Jeff Leger178b1e52020-10-05 12:22:23 -04002933 const char *vuid;
Tony-LunarGb61514a2021-11-02 12:36:51 -06002934 skip = ValidateImageCopyData(regionCount, pRegions, src_image_state.get(), dst_image_state.get(), cmd_type);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002935
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06002936 VkCommandBuffer command_buffer = cb_node->commandBuffer();
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002937
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07002938 for (uint32_t i = 0; i < regionCount; i++) {
Jeff Leger178b1e52020-10-05 12:22:23 -04002939 const RegionType region = pRegions[i];
Dave Houltonee281a52017-12-08 13:51:02 -07002940
2941 // For comp/uncomp copies, the copy extent for the dest image must be adjusted
2942 VkExtent3D src_copy_extent = region.extent;
sfricke-samsungdce5f692020-03-07 13:59:31 -08002943 VkExtent3D dst_copy_extent = GetAdjustedDestImageExtent(src_format, dst_format, region.extent);
Dave Houltonee281a52017-12-08 13:51:02 -07002944
Dave Houlton6f9059e2017-05-02 17:15:13 -06002945 bool slice_override = false;
2946 uint32_t depth_slices = 0;
2947
2948 // Special case for copying between a 1D/2D array and a 3D image
2949 // TBD: This seems like the only way to reconcile 3 mutually-exclusive VU checks for 2D/3D copies. Heads up.
2950 if ((VK_IMAGE_TYPE_3D == src_image_state->createInfo.imageType) &&
2951 (VK_IMAGE_TYPE_3D != dst_image_state->createInfo.imageType)) {
Dave Houltonee281a52017-12-08 13:51:02 -07002952 depth_slices = region.dstSubresource.layerCount; // Slice count from 2D subresource
Dave Houlton6f9059e2017-05-02 17:15:13 -06002953 slice_override = (depth_slices != 1);
2954 } else if ((VK_IMAGE_TYPE_3D == dst_image_state->createInfo.imageType) &&
2955 (VK_IMAGE_TYPE_3D != src_image_state->createInfo.imageType)) {
Dave Houltonee281a52017-12-08 13:51:02 -07002956 depth_slices = region.srcSubresource.layerCount; // Slice count from 2D subresource
Dave Houlton6f9059e2017-05-02 17:15:13 -06002957 slice_override = (depth_slices != 1);
2958 }
2959
Jeremy Gebben9f537102021-10-05 16:37:12 -06002960 skip |= ValidateImageSubresourceLayers(cb_node.get(), &region.srcSubresource, func_name, "srcSubresource", i);
2961 skip |= ValidateImageSubresourceLayers(cb_node.get(), &region.dstSubresource, func_name, "dstSubresource", i);
Tony-LunarGb61514a2021-11-02 12:36:51 -06002962 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcSubresource-01696" : "VUID-vkCmdCopyImage-srcSubresource-01696";
2963 skip |=
2964 ValidateImageMipLevel(cb_node.get(), src_image_state.get(), region.srcSubresource.mipLevel, i, func_name, "srcSubresource", vuid);
2965 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstSubresource-01697" : "VUID-vkCmdCopyImage-dstSubresource-01697";
2966 skip |=
2967 ValidateImageMipLevel(cb_node.get(), dst_image_state.get(), region.dstSubresource.mipLevel, i, func_name, "dstSubresource", vuid);
2968 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcSubresource-01698" : "VUID-vkCmdCopyImage-srcSubresource-01698";
Jeremy Gebben9f537102021-10-05 16:37:12 -06002969 skip |= ValidateImageArrayLayerRange(cb_node.get(), src_image_state.get(), region.srcSubresource.baseArrayLayer,
Jeff Leger178b1e52020-10-05 12:22:23 -04002970 region.srcSubresource.layerCount, i, func_name, "srcSubresource", vuid);
Tony-LunarGb61514a2021-11-02 12:36:51 -06002971 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstSubresource-01699" : "VUID-vkCmdCopyImage-dstSubresource-01699";
Jeremy Gebben9f537102021-10-05 16:37:12 -06002972 skip |= ValidateImageArrayLayerRange(cb_node.get(), dst_image_state.get(), region.dstSubresource.baseArrayLayer,
Jeff Leger178b1e52020-10-05 12:22:23 -04002973 region.dstSubresource.layerCount, i, func_name, "dstSubresource", vuid);
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07002974
sfricke-samsung45996a42021-09-16 13:45:27 -07002975 if (IsExtEnabled(device_extensions.vk_khr_maintenance1)) {
Dave Houlton6f9059e2017-05-02 17:15:13 -06002976 // No chance of mismatch if we're overriding depth slice count
2977 if (!slice_override) {
2978 // The number of depth slices in srcSubresource and dstSubresource must match
2979 // Depth comes from layerCount for 1D,2D resources, from extent.depth for 3D
2980 uint32_t src_slices =
Dave Houltonee281a52017-12-08 13:51:02 -07002981 (VK_IMAGE_TYPE_3D == src_image_state->createInfo.imageType ? src_copy_extent.depth
2982 : region.srcSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002983 uint32_t dst_slices =
Dave Houltonee281a52017-12-08 13:51:02 -07002984 (VK_IMAGE_TYPE_3D == dst_image_state->createInfo.imageType ? dst_copy_extent.depth
2985 : region.dstSubresource.layerCount);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002986 if (src_slices != dst_slices) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002987 vuid = is_2 ? "VUID-VkImageCopy2-extent-00140" : "VUID-VkImageCopy-extent-00140";
Jeff Leger178b1e52020-10-05 12:22:23 -04002988 skip |= LogError(command_buffer, vuid,
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08002989 "%s: number of depth slices in source (%u) and destination (%u) subresources for pRegions[%u] "
2990 "do not match.",
2991 func_name, src_slices, dst_slices, i);
Dave Houlton6f9059e2017-05-02 17:15:13 -06002992 }
2993 }
2994 } else {
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06002995 // For each region the layerCount member of srcSubresource and dstSubresource must match
Dave Houltonee281a52017-12-08 13:51:02 -07002996 if (region.srcSubresource.layerCount != region.dstSubresource.layerCount) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06002997 vuid = is_2 ? "VUID-VkImageCopy2-layerCount-00138" : "VUID-VkImageCopy-layerCount-00138";
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08002998 skip |=
2999 LogError(command_buffer, vuid,
3000 "%s: number of layers in source (%u) and destination (%u) subresources for pRegions[%u] do not match",
3001 func_name, region.srcSubresource.layerCount, region.dstSubresource.layerCount, i);
Mike Schuchardt64b5bb72017-03-21 16:33:26 -06003002 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07003003 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07003004
Dave Houltonc991cc92018-03-06 11:08:51 -07003005 // Do multiplane-specific checks, if extension enabled
sfricke-samsung45996a42021-09-16 13:45:27 -07003006 if (IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion)) {
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003007 if ((!FormatIsMultiplane(src_format)) && (!FormatIsMultiplane(dst_format))) {
3008 // If neither image is multi-plane the aspectMask member of src and dst must match
3009 if (region.srcSubresource.aspectMask != region.dstSubresource.aspectMask) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003010 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-01551" : "VUID-vkCmdCopyImage-srcImage-01551";
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003011 skip |= LogError(command_buffer, vuid,
3012 "%s: Copy between non-multiplane images with differing aspectMasks in pRegions[%u] with "
3013 "source (0x%x) destination (0x%x).",
3014 func_name, i, region.srcSubresource.aspectMask, region.dstSubresource.aspectMask);
3015 }
3016 } else {
3017 // Source image multiplane checks
3018 uint32_t planes = FormatPlaneCount(src_format);
3019 VkImageAspectFlags aspect = region.srcSubresource.aspectMask;
3020 if ((2 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003021 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-01552" : "VUID-vkCmdCopyImage-srcImage-01552";
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003022 skip |= LogError(command_buffer, vuid,
3023 "%s: pRegions[%u].srcSubresource.aspectMask (0x%x) is invalid for 2-plane format.", func_name,
3024 i, aspect);
3025 }
3026 if ((3 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT) &&
3027 (aspect != VK_IMAGE_ASPECT_PLANE_2_BIT)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003028 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-01553" : "VUID-vkCmdCopyImage-srcImage-01553";
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003029 skip |= LogError(command_buffer, vuid,
3030 "%s: pRegions[%u].srcSubresource.aspectMask (0x%x) is invalid for 3-plane format.", func_name,
3031 i, aspect);
3032 }
3033 // Single-plane to multi-plane
3034 if ((!FormatIsMultiplane(src_format)) && (FormatIsMultiplane(dst_format)) &&
3035 (VK_IMAGE_ASPECT_COLOR_BIT != aspect)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003036 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-01557" : "VUID-vkCmdCopyImage-dstImage-01557";
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003037 skip |= LogError(command_buffer, vuid,
3038 "%s: pRegions[%u].srcSubresource.aspectMask (0x%x) is not VK_IMAGE_ASPECT_COLOR_BIT.",
3039 func_name, i, aspect);
3040 }
Dave Houltonc991cc92018-03-06 11:08:51 -07003041
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003042 // Dest image multiplane checks
3043 planes = FormatPlaneCount(dst_format);
3044 aspect = region.dstSubresource.aspectMask;
3045 if ((2 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003046 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-01554" : "VUID-vkCmdCopyImage-dstImage-01554";
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003047 skip |= LogError(command_buffer, vuid,
3048 "%s: pRegions[%u].dstSubresource.aspectMask (0x%x) is invalid for 2-plane format.", func_name,
3049 i, aspect);
3050 }
3051 if ((3 == planes) && (aspect != VK_IMAGE_ASPECT_PLANE_0_BIT) && (aspect != VK_IMAGE_ASPECT_PLANE_1_BIT) &&
3052 (aspect != VK_IMAGE_ASPECT_PLANE_2_BIT)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003053 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-01555" : "VUID-vkCmdCopyImage-dstImage-01555";
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003054 skip |= LogError(command_buffer, vuid,
3055 "%s: pRegions[%u].dstSubresource.aspectMask (0x%x) is invalid for 3-plane format.", func_name,
3056 i, aspect);
3057 }
3058 // Multi-plane to single-plane
3059 if ((FormatIsMultiplane(src_format)) && (!FormatIsMultiplane(dst_format)) &&
3060 (VK_IMAGE_ASPECT_COLOR_BIT != aspect)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003061 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-01556" : "VUID-vkCmdCopyImage-srcImage-01556";
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003062 skip |= LogError(command_buffer, vuid,
3063 "%s: pRegions[%u].dstSubresource.aspectMask (0x%x) is not VK_IMAGE_ASPECT_COLOR_BIT.",
3064 func_name, i, aspect);
3065 }
3066 }
3067 } else {
3068 // !vk_khr_sampler_ycbcr_conversion
Dave Houltonf5217612018-02-02 16:18:52 -07003069 // not multi-plane, the aspectMask member of srcSubresource and dstSubresource must match
3070 if (region.srcSubresource.aspectMask != region.dstSubresource.aspectMask) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003071 vuid = is_2 ? "VUID-VkImageCopy2-aspectMask-00137" : "VUID-VkImageCopy-aspectMask-00137";
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003072 skip |= LogError(
3073 command_buffer, vuid,
3074 "%s: Copy between images with differing aspectMasks in pRegions[%u] with source (0x%x) destination (0x%x).",
3075 func_name, i, region.srcSubresource.aspectMask, region.dstSubresource.aspectMask);
Dave Houltonf5217612018-02-02 16:18:52 -07003076 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07003077 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07003078
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06003079 // For each region, the aspectMask member of srcSubresource must be present in the source image
sfricke-samsungdce5f692020-03-07 13:59:31 -08003080 if (!VerifyAspectsPresent(region.srcSubresource.aspectMask, src_format)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003081 vuid = is_2 ? "VUID-VkCopyImageInfo2-aspectMask-00142" : "VUID-vkCmdCopyImage-aspectMask-00142";
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003082 skip |=
3083 LogError(command_buffer, vuid,
3084 "%s: pRegions[%u].srcSubresource.aspectMask (0x%x) cannot specify aspects not present in source image.",
3085 func_name, i, region.srcSubresource.aspectMask);
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06003086 }
3087
3088 // For each region, the aspectMask member of dstSubresource must be present in the destination image
sfricke-samsungdce5f692020-03-07 13:59:31 -08003089 if (!VerifyAspectsPresent(region.dstSubresource.aspectMask, dst_format)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003090 vuid = is_2 ? "VUID-VkCopyImageInfo2-aspectMask-00143" : "VUID-vkCmdCopyImage-aspectMask-00143";
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003091 skip |= LogError(
3092 command_buffer, vuid,
3093 "%s: pRegions[%u].dstSubresource.aspectMask (0x%x) cannot specify aspects not present in destination image.",
3094 func_name, i, region.dstSubresource.aspectMask);
Dave Houlton4eaaf3a2017-03-14 11:31:20 -06003095 }
3096
sfricke-samsung5f11b0e2022-03-22 14:12:15 -05003097 // Make sure not a empty region
3098 if (src_copy_extent.width == 0) {
3099 vuid = is_2 ? "VUID-VkImageCopy2-extent-06668" : "VUID-VkImageCopy-extent-06668";
3100 skip |=
3101 LogError(command_buffer, vuid,
3102 "%s: pRegion[%" PRIu32 "] extent.width must not be zero as empty copies are not allowed.", func_name, i);
3103 }
3104 if (src_copy_extent.height == 0) {
3105 vuid = is_2 ? "VUID-VkImageCopy2-extent-06669" : "VUID-VkImageCopy-extent-06669";
3106 skip |=
3107 LogError(command_buffer, vuid,
3108 "%s: pRegion[%" PRIu32 "] extent.height must not be zero as empty copies are not allowed.", func_name, i);
3109 }
3110 if (src_copy_extent.depth == 0) {
3111 vuid = is_2 ? "VUID-VkImageCopy2-extent-06670" : "VUID-VkImageCopy-extent-06670";
3112 skip |=
3113 LogError(command_buffer, vuid,
3114 "%s: pRegion[%" PRIu32 "] extent.depth must not be zero as empty copies are not allowed.", func_name, i);
3115 }
3116
Dave Houltonfc1a4052017-04-27 14:32:45 -06003117 // Each dimension offset + extent limits must fall with image subresource extent
Jeremy Gebben1dfbd172021-05-19 14:00:58 -06003118 VkExtent3D subresource_extent = src_image_state->GetSubresourceExtent(region.srcSubresource);
Dave Houltonee281a52017-12-08 13:51:02 -07003119 if (slice_override) src_copy_extent.depth = depth_slices;
3120 uint32_t extent_check = ExceedsBounds(&(region.srcOffset), &src_copy_extent, &subresource_extent);
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07003121 if (extent_check & kXBit) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003122 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcOffset-00144" : "VUID-vkCmdCopyImage-srcOffset-00144";
Jeff Leger178b1e52020-10-05 12:22:23 -04003123 skip |= LogError(command_buffer, vuid,
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003124 "%s: Source image pRegion[%u] x-dimension offset [%1d] + extent [%1d] exceeds subResource "
Jeff Leger178b1e52020-10-05 12:22:23 -04003125 "width [%1d].",
3126 func_name, i, region.srcOffset.x, src_copy_extent.width, subresource_extent.width);
Dave Houltonfc1a4052017-04-27 14:32:45 -06003127 }
3128
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07003129 if (extent_check & kYBit) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003130 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcOffset-00145" : "VUID-vkCmdCopyImage-srcOffset-00145";
Jeff Leger178b1e52020-10-05 12:22:23 -04003131 skip |= LogError(command_buffer, vuid,
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003132 "%s: Source image pRegion[%u] y-dimension offset [%1d] + extent [%1d] exceeds subResource "
Jeff Leger178b1e52020-10-05 12:22:23 -04003133 "height [%1d].",
3134 func_name, i, region.srcOffset.y, src_copy_extent.height, subresource_extent.height);
Dave Houltonfc1a4052017-04-27 14:32:45 -06003135 }
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07003136 if (extent_check & kZBit) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003137 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcOffset-00147" : "VUID-vkCmdCopyImage-srcOffset-00147";
Jeff Leger178b1e52020-10-05 12:22:23 -04003138 skip |= LogError(command_buffer, vuid,
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003139 "%s: Source image pRegion[%u] z-dimension offset [%1d] + extent [%1d] exceeds subResource "
Jeff Leger178b1e52020-10-05 12:22:23 -04003140 "depth [%1d].",
3141 func_name, i, region.srcOffset.z, src_copy_extent.depth, subresource_extent.depth);
Dave Houltonfc1a4052017-04-27 14:32:45 -06003142 }
3143
Dave Houltonee281a52017-12-08 13:51:02 -07003144 // Adjust dest extent if necessary
Jeremy Gebben1dfbd172021-05-19 14:00:58 -06003145 subresource_extent = dst_image_state->GetSubresourceExtent(region.dstSubresource);
Dave Houltonee281a52017-12-08 13:51:02 -07003146 if (slice_override) dst_copy_extent.depth = depth_slices;
3147
3148 extent_check = ExceedsBounds(&(region.dstOffset), &dst_copy_extent, &subresource_extent);
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07003149 if (extent_check & kXBit) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003150 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstOffset-00150" : "VUID-vkCmdCopyImage-dstOffset-00150";
Jeff Leger178b1e52020-10-05 12:22:23 -04003151 skip |= LogError(command_buffer, vuid,
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003152 "%s: Dest image pRegion[%u] x-dimension offset [%1d] + extent [%1d] exceeds subResource "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07003153 "width [%1d].",
Jeff Leger178b1e52020-10-05 12:22:23 -04003154 func_name, i, region.dstOffset.x, dst_copy_extent.width, subresource_extent.width);
Dave Houltonfc1a4052017-04-27 14:32:45 -06003155 }
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07003156 if (extent_check & kYBit) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003157 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstOffset-00151" : "VUID-vkCmdCopyImage-dstOffset-00151";
Jeff Leger178b1e52020-10-05 12:22:23 -04003158 skip |= LogError(command_buffer, vuid,
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003159 "%s): Dest image pRegion[%u] y-dimension offset [%1d] + extent [%1d] exceeds subResource "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07003160 "height [%1d].",
Jeff Leger178b1e52020-10-05 12:22:23 -04003161 func_name, i, region.dstOffset.y, dst_copy_extent.height, subresource_extent.height);
Dave Houltonfc1a4052017-04-27 14:32:45 -06003162 }
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07003163 if (extent_check & kZBit) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003164 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstOffset-00153" : "VUID-vkCmdCopyImage-dstOffset-00153";
Jeff Leger178b1e52020-10-05 12:22:23 -04003165 skip |= LogError(command_buffer, vuid,
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003166 "%s: Dest image pRegion[%u] z-dimension offset [%1d] + extent [%1d] exceeds subResource "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07003167 "depth [%1d].",
Jeff Leger178b1e52020-10-05 12:22:23 -04003168 func_name, i, region.dstOffset.z, dst_copy_extent.depth, subresource_extent.depth);
Dave Houltonfc1a4052017-04-27 14:32:45 -06003169 }
3170
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07003171 // The union of all source regions, and the union of all destination regions, specified by the elements of regions,
3172 // must not overlap in memory
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003173 if (src_image_state->image() == dst_image_state->image()) {
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07003174 for (uint32_t j = 0; j < regionCount; j++) {
3175 if (RegionIntersects(&region, &pRegions[j], src_image_state->createInfo.imageType,
sfricke-samsungdce5f692020-03-07 13:59:31 -08003176 FormatIsMultiplane(src_format))) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003177 vuid = is_2 ? "VUID-VkCopyImageInfo2-pRegions-00124" : "VUID-vkCmdCopyImage-pRegions-00124";
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003178 skip |= LogError(command_buffer, vuid, "%s: pRegion[%u] src overlaps with pRegions[%u].", func_name, i, j);
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07003179 }
3180 }
3181 }
sfricke-samsung48172ca2020-02-13 23:38:11 -08003182
3183 // Check depth for 2D as post Maintaince 1 requires both while prior only required one to be 2D
sfricke-samsung45996a42021-09-16 13:45:27 -07003184 if (IsExtEnabled(device_extensions.vk_khr_maintenance1)) {
sfricke-samsung48172ca2020-02-13 23:38:11 -08003185 if (((VK_IMAGE_TYPE_2D == src_image_state->createInfo.imageType) &&
3186 (VK_IMAGE_TYPE_2D == dst_image_state->createInfo.imageType)) &&
3187 (src_copy_extent.depth != 1)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003188 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-01790" : "VUID-vkCmdCopyImage-srcImage-01790";
Jeff Leger178b1e52020-10-05 12:22:23 -04003189 skip |= LogError(command_buffer, vuid,
3190 "%s: pRegion[%u] both srcImage and dstImage are 2D and extent.depth is %u and has to be 1",
3191 func_name, i, src_copy_extent.depth);
sfricke-samsung48172ca2020-02-13 23:38:11 -08003192 }
3193 } else {
3194 if (((VK_IMAGE_TYPE_2D == src_image_state->createInfo.imageType) ||
3195 (VK_IMAGE_TYPE_2D == dst_image_state->createInfo.imageType)) &&
3196 (src_copy_extent.depth != 1)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003197 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-01789" : "VUID-vkCmdCopyImage-srcImage-01789";
Jeff Leger178b1e52020-10-05 12:22:23 -04003198 skip |= LogError(command_buffer, vuid,
3199 "%s: pRegion[%u] either srcImage or dstImage is 2D and extent.depth is %u and has to be 1",
3200 func_name, i, src_copy_extent.depth);
sfricke-samsung48172ca2020-02-13 23:38:11 -08003201 }
3202 }
3203
3204 // Check if 2D with 3D and depth not equal to 2D layerCount
3205 if ((VK_IMAGE_TYPE_2D == src_image_state->createInfo.imageType) &&
3206 (VK_IMAGE_TYPE_3D == dst_image_state->createInfo.imageType) &&
3207 (src_copy_extent.depth != region.srcSubresource.layerCount)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003208 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-01791" : "VUID-vkCmdCopyImage-srcImage-01791";
Jeff Leger178b1e52020-10-05 12:22:23 -04003209 skip |= LogError(command_buffer, vuid,
3210 "%s: pRegion[%u] srcImage is 2D, dstImage is 3D and extent.depth is %u and has to be "
sfricke-samsung48172ca2020-02-13 23:38:11 -08003211 "srcSubresource.layerCount (%u)",
Jeff Leger178b1e52020-10-05 12:22:23 -04003212 func_name, i, src_copy_extent.depth, region.srcSubresource.layerCount);
sfricke-samsung48172ca2020-02-13 23:38:11 -08003213 } else if ((VK_IMAGE_TYPE_3D == src_image_state->createInfo.imageType) &&
3214 (VK_IMAGE_TYPE_2D == dst_image_state->createInfo.imageType) &&
3215 (src_copy_extent.depth != region.dstSubresource.layerCount)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003216 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-01792" : "VUID-vkCmdCopyImage-dstImage-01792";
Jeff Leger178b1e52020-10-05 12:22:23 -04003217 skip |= LogError(command_buffer, vuid,
3218 "%s: pRegion[%u] srcImage is 3D, dstImage is 2D and extent.depth is %u and has to be "
sfricke-samsung48172ca2020-02-13 23:38:11 -08003219 "dstSubresource.layerCount (%u)",
Jeff Leger178b1e52020-10-05 12:22:23 -04003220 func_name, i, src_copy_extent.depth, region.dstSubresource.layerCount);
sfricke-samsung48172ca2020-02-13 23:38:11 -08003221 }
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003222
3223 // Check for multi-plane format compatiblity
3224 if (FormatIsMultiplane(src_format) || FormatIsMultiplane(dst_format)) {
sfricke-samsung73e755c2021-09-30 08:34:57 -07003225 const VkFormat src_plane_format = FormatIsMultiplane(src_format)
3226 ? FindMultiplaneCompatibleFormat(src_format, region.srcSubresource.aspectMask)
3227 : src_format;
3228 const VkFormat dst_plane_format = FormatIsMultiplane(dst_format)
3229 ? FindMultiplaneCompatibleFormat(dst_format, region.dstSubresource.aspectMask)
3230 : dst_format;
3231 const size_t src_format_size = FormatElementSize(src_plane_format);
3232 const size_t dst_format_size = FormatElementSize(dst_plane_format);
3233
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003234 // If size is still zero, then format is invalid and will be caught in another VU
3235 if ((src_format_size != dst_format_size) && (src_format_size != 0) && (dst_format_size != 0)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003236 vuid = is_2 ? "VUID-VkCopyImageInfo2-None-01549" : "VUID-vkCmdCopyImage-None-01549";
Jeff Leger178b1e52020-10-05 12:22:23 -04003237 skip |= LogError(command_buffer, vuid,
3238 "%s: pRegions[%u] called with non-compatible image formats. "
3239 "The src format %s with aspectMask %s is not compatible with dst format %s aspectMask %s.",
3240 func_name, i, string_VkFormat(src_format),
3241 string_VkImageAspectFlags(region.srcSubresource.aspectMask).c_str(), string_VkFormat(dst_format),
3242 string_VkImageAspectFlags(region.dstSubresource.aspectMask).c_str());
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003243 }
3244 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07003245 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07003246
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003247 // The formats of non-multiplane src_image and dst_image must be compatible. Formats are considered compatible if their texel
3248 // size in bytes is the same between both formats. For example, VK_FORMAT_R8G8B8A8_UNORM is compatible with VK_FORMAT_R32_UINT
3249 // because because both texels are 4 bytes in size.
3250 if (!FormatIsMultiplane(src_format) && !FormatIsMultiplane(dst_format)) {
Jeff Leger178b1e52020-10-05 12:22:23 -04003251 const char *compatible_vuid =
sfricke-samsung45996a42021-09-16 13:45:27 -07003252 IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion)
Tony-LunarGb61514a2021-11-02 12:36:51 -06003253 ? (is_2 ? "VUID-VkCopyImageInfo2-srcImage-01548" : "VUID-vkCmdCopyImage-srcImage-01548")
3254 : (is_2 ? "VUID-VkCopyImageInfo2-srcImage-00135" : "VUID-vkCmdCopyImage-srcImage-00135");
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003255 // Depth/stencil formats must match exactly.
3256 if (FormatIsDepthOrStencil(src_format) || FormatIsDepthOrStencil(dst_format)) {
3257 if (src_format != dst_format) {
3258 skip |= LogError(command_buffer, compatible_vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04003259 "%s: Depth/stencil formats must match exactly for src (%s) and dst (%s).", func_name,
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003260 string_VkFormat(src_format), string_VkFormat(dst_format));
3261 }
3262 } else {
Jeff Leger178b1e52020-10-05 12:22:23 -04003263 if (FormatElementSize(src_format) != FormatElementSize(dst_format)) {
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003264 skip |= LogError(command_buffer, compatible_vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04003265 "%s: Unmatched image format sizes. "
Jeremy Gebbenda6b48f2021-05-13 10:46:18 -06003266 "The src format %s has size of %" PRIu32 " and dst format %s has size of %" PRIu32 ".",
Jeff Leger178b1e52020-10-05 12:22:23 -04003267 func_name, string_VkFormat(src_format), FormatElementSize(src_format), string_VkFormat(dst_format),
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003268 FormatElementSize(dst_format));
3269 }
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07003270 }
3271 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07003272
Dave Houlton33c22b72017-02-28 13:16:02 -07003273 // Source and dest image sample counts must match
3274 if (src_image_state->createInfo.samples != dst_image_state->createInfo.samples) {
Jeff Leger178b1e52020-10-05 12:22:23 -04003275 std::stringstream ss;
3276 ss << func_name << " called on image pair with non-identical sample counts.";
Tony-LunarGb61514a2021-11-02 12:36:51 -06003277 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-00136" : "VUID-vkCmdCopyImage-srcImage-00136";
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08003278 skip |=
3279 LogError(command_buffer, vuid, "%s: The src image sample count (%s) dose not match the dst image sample count (%s).",
3280 func_name, string_VkSampleCountFlagBits(src_image_state->createInfo.samples),
3281 string_VkSampleCountFlagBits(dst_image_state->createInfo.samples));
Dave Houlton33c22b72017-02-28 13:16:02 -07003282 }
3283
sfricke-samsung45996a42021-09-16 13:45:27 -07003284 vuid = IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion)
Tony-LunarGb61514a2021-11-02 12:36:51 -06003285 ? (is_2 ? "VUID-VkCopyImageInfo2-srcImage-01546" : "VUID-vkCmdCopyImage-srcImage-01546")
3286 : (is_2 ? "VUID-VkCopyImageInfo2-srcImage-00127" : "VUID-vkCmdCopyImage-srcImage-00127");
Jeremy Gebben9f537102021-10-05 16:37:12 -06003287 skip |= ValidateMemoryIsBoundToImage(src_image_state.get(), func_name, vuid);
sfricke-samsung45996a42021-09-16 13:45:27 -07003288 vuid = IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion)
Tony-LunarGb61514a2021-11-02 12:36:51 -06003289 ? (is_2 ? "VUID-VkCopyImageInfo2-dstImage-01547" : "VUID-vkCmdCopyImage-dstImage-01547")
3290 : (is_2 ? "VUID-VkCopyImageInfo2-dstImage-00132" : "VUID-vkCmdCopyImage-dstImage-00132");
Jeremy Gebben9f537102021-10-05 16:37:12 -06003291 skip |= ValidateMemoryIsBoundToImage(dst_image_state.get(), func_name, vuid);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07003292 // Validate that SRC & DST images have correct usage flags set
Tony-LunarGb61514a2021-11-02 12:36:51 -06003293 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-00126" : "VUID-vkCmdCopyImage-srcImage-00126";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003294 skip |= ValidateImageUsageFlags(src_image_state.get(), VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, vuid, func_name,
Jeff Leger178b1e52020-10-05 12:22:23 -04003295 "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
Tony-LunarGb61514a2021-11-02 12:36:51 -06003296 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-00131" : "VUID-vkCmdCopyImage-dstImage-00131";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003297 skip |= ValidateImageUsageFlags(dst_image_state.get(), VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, vuid, func_name,
Jeff Leger178b1e52020-10-05 12:22:23 -04003298 "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
Tony-LunarGb61514a2021-11-02 12:36:51 -06003299 vuid = is_2 ? "VUID-vkCmdCopyImage2-commandBuffer-01825" : "VUID-vkCmdCopyImage-commandBuffer-01825";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003300 skip |= ValidateProtectedImage(cb_node.get(), src_image_state.get(), func_name, vuid);
Tony-LunarGb61514a2021-11-02 12:36:51 -06003301 vuid = is_2 ? "VUID-vkCmdCopyImage2-commandBuffer-01826" : "VUID-vkCmdCopyImage-commandBuffer-01826";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003302 skip |= ValidateProtectedImage(cb_node.get(), dst_image_state.get(), func_name, vuid);
Tony-LunarGb61514a2021-11-02 12:36:51 -06003303 vuid = is_2 ? "VUID-vkCmdCopyImage2-commandBuffer-01827" : "VUID-vkCmdCopyImage-commandBuffer-01827";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003304 skip |= ValidateUnprotectedImage(cb_node.get(), dst_image_state.get(), func_name, vuid);
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02003305
3306 // Validation for VK_EXT_fragment_density_map
3307 if (src_image_state->createInfo.flags & VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003308 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-02542" : "VUID-vkCmdCopyImage-dstImage-02542";
Jeff Leger178b1e52020-10-05 12:22:23 -04003309 skip |=
3310 LogError(command_buffer, vuid,
3311 "%s: srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT", func_name);
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02003312 }
3313 if (dst_image_state->createInfo.flags & VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003314 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-02542" : "VUID-vkCmdCopyImage-dstImage-02542";
Jeff Leger178b1e52020-10-05 12:22:23 -04003315 skip |=
3316 LogError(command_buffer, vuid,
3317 "%s: dstImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT", func_name);
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02003318 }
3319
sfricke-samsung45996a42021-09-16 13:45:27 -07003320 if (IsExtEnabled(device_extensions.vk_khr_maintenance1)) {
Tony-LunarGb61514a2021-11-02 12:36:51 -06003321 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImage-01995" : "VUID-vkCmdCopyImage-srcImage-01995";
3322 skip |= ValidateImageFormatFeatureFlags(src_image_state.get(), VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT, func_name, vuid);
3323 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImage-01996" : "VUID-vkCmdCopyImage-dstImage-01996";
3324 skip |= ValidateImageFormatFeatureFlags(dst_image_state.get(), VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT, func_name, vuid);
Cort Stratton186b1a22018-05-01 20:18:06 -04003325 }
Jeremy Gebben9f537102021-10-05 16:37:12 -06003326 skip |= ValidateCmd(cb_node.get(), cmd_type);
Tobin Ehlisc8266452017-04-07 12:20:30 -06003327 bool hit_error = false;
Jeff Leger178b1e52020-10-05 12:22:23 -04003328
3329 const char *invalid_src_layout_vuid =
sfricke-samsung45996a42021-09-16 13:45:27 -07003330 (src_image_state->shared_presentable && IsExtEnabled(device_extensions.vk_khr_shared_presentable_image))
Tony-LunarGb61514a2021-11-02 12:36:51 -06003331 ? (is_2 ? "VUID-VkCopyImageInfo2-srcImageLayout-01917" : "VUID-vkCmdCopyImage-srcImageLayout-01917")
3332 : (is_2 ? "VUID-VkCopyImageInfo2-srcImageLayout-00129" : "VUID-vkCmdCopyImage-srcImageLayout-00129");
Jeff Leger178b1e52020-10-05 12:22:23 -04003333 const char *invalid_dst_layout_vuid =
sfricke-samsung45996a42021-09-16 13:45:27 -07003334 (dst_image_state->shared_presentable && IsExtEnabled(device_extensions.vk_khr_shared_presentable_image))
Tony-LunarGb61514a2021-11-02 12:36:51 -06003335 ? (is_2 ? "VUID-VkCopyImageInfo2-dstImageLayout-01395" : "VUID-vkCmdCopyImage-dstImageLayout-01395")
3336 : (is_2 ? "VUID-VkCopyImageInfo2-dstImageLayout-00134" : "VUID-vkCmdCopyImage-dstImageLayout-00134");
Jeff Leger178b1e52020-10-05 12:22:23 -04003337
aitor-lunargd0d85e12022-01-28 16:56:49 +01003338 bool same_image = (src_image_state == dst_image_state);
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07003339 for (uint32_t i = 0; i < regionCount; ++i) {
aitor-lunargd0d85e12022-01-28 16:56:49 +01003340 // When performing copy from and to same subresource, VK_IMAGE_LAYOUT_GENERAL is the only option
sfricke-samsung71f04e32022-03-16 01:21:21 -05003341 const RegionType region = pRegions[i];
3342 const auto &src_sub = region.srcSubresource;
3343 const auto &dst_sub = region.dstSubresource;
aitor-lunargd0d85e12022-01-28 16:56:49 +01003344 bool same_subresource =
3345 (same_image && (src_sub.mipLevel == dst_sub.mipLevel) && (src_sub.baseArrayLayer == dst_sub.baseArrayLayer));
3346 VkImageLayout source_optimal = (same_subresource ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
3347 VkImageLayout destination_optimal = (same_subresource ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
Tony-LunarGb61514a2021-11-02 12:36:51 -06003348 vuid = is_2 ? "VUID-VkCopyImageInfo2-srcImageLayout-00128" : "VUID-vkCmdCopyImage-srcImageLayout-00128";
sfricke-samsung71f04e32022-03-16 01:21:21 -05003349 skip |= VerifyImageLayout(cb_node.get(), src_image_state.get(), region.srcSubresource, srcImageLayout, source_optimal,
aitor-lunargd0d85e12022-01-28 16:56:49 +01003350 func_name, invalid_src_layout_vuid, vuid, &hit_error);
Tony-LunarGb61514a2021-11-02 12:36:51 -06003351 vuid = is_2 ? "VUID-VkCopyImageInfo2-dstImageLayout-00133" : "VUID-vkCmdCopyImage-dstImageLayout-00133";
sfricke-samsung71f04e32022-03-16 01:21:21 -05003352 skip |= VerifyImageLayout(cb_node.get(), dst_image_state.get(), region.dstSubresource, dstImageLayout, destination_optimal,
3353 func_name, invalid_dst_layout_vuid, vuid, &hit_error);
Jeremy Gebben9f537102021-10-05 16:37:12 -06003354 skip |= ValidateCopyImageTransferGranularityRequirements(cb_node.get(), src_image_state.get(), dst_image_state.get(),
sfricke-samsung71f04e32022-03-16 01:21:21 -05003355 &region, i, func_name, cmd_type);
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07003356 }
3357
Mark Lobodzinskib39d2ec2017-02-02 14:38:47 -07003358 return skip;
3359}
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07003360
Jeff Leger178b1e52020-10-05 12:22:23 -04003361bool CoreChecks::PreCallValidateCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
3362 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
3363 const VkImageCopy *pRegions) const {
3364 return ValidateCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions,
Tony-LunarGb61514a2021-11-02 12:36:51 -06003365 CMD_COPYIMAGE);
Jeff Leger178b1e52020-10-05 12:22:23 -04003366}
3367
3368bool CoreChecks::PreCallValidateCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR *pCopyImageInfo) const {
3369 return ValidateCmdCopyImage(commandBuffer, pCopyImageInfo->srcImage, pCopyImageInfo->srcImageLayout, pCopyImageInfo->dstImage,
3370 pCopyImageInfo->dstImageLayout, pCopyImageInfo->regionCount, pCopyImageInfo->pRegions,
Tony-LunarGb61514a2021-11-02 12:36:51 -06003371 CMD_COPYIMAGE2KHR);
3372}
3373
3374bool CoreChecks::PreCallValidateCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo) const {
3375 return ValidateCmdCopyImage(commandBuffer, pCopyImageInfo->srcImage, pCopyImageInfo->srcImageLayout, pCopyImageInfo->dstImage,
3376 pCopyImageInfo->dstImageLayout, pCopyImageInfo->regionCount, pCopyImageInfo->pRegions,
3377 CMD_COPYIMAGE2);
Jeff Leger178b1e52020-10-05 12:22:23 -04003378}
3379
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003380void CoreChecks::PreCallRecordCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
3381 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
3382 const VkImageCopy *pRegions) {
John Zulauf8f6d4ee2019-07-05 16:31:57 -06003383 StateTracker::PreCallRecordCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount,
3384 pRegions);
Jeremy Gebben332d4dd2022-01-01 12:40:02 -07003385 auto cb_node = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06003386 auto src_image_state = Get<IMAGE_STATE>(srcImage);
3387 auto dst_image_state = Get<IMAGE_STATE>(dstImage);
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07003388
Tobin Ehlise35b66a2017-03-15 12:18:31 -06003389 // Make sure that all image slices are updated to correct layout
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07003390 for (uint32_t i = 0; i < regionCount; ++i) {
Jeremy Gebben1ec89332021-08-05 13:51:49 -06003391 cb_node->SetImageInitialLayout(*src_image_state, pRegions[i].srcSubresource, srcImageLayout);
3392 cb_node->SetImageInitialLayout(*dst_image_state, pRegions[i].dstSubresource, dstImageLayout);
Tobin Ehlise35b66a2017-03-15 12:18:31 -06003393 }
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07003394}
3395
sfricke-samsungd750f812022-02-04 10:23:34 -08003396void CoreChecks::RecordCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo) {
Jeremy Gebben332d4dd2022-01-01 12:40:02 -07003397 auto cb_node = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06003398 auto src_image_state = Get<IMAGE_STATE>(pCopyImageInfo->srcImage);
3399 auto dst_image_state = Get<IMAGE_STATE>(pCopyImageInfo->dstImage);
Jeff Leger178b1e52020-10-05 12:22:23 -04003400
3401 // Make sure that all image slices are updated to correct layout
3402 for (uint32_t i = 0; i < pCopyImageInfo->regionCount; ++i) {
Jeremy Gebben1ec89332021-08-05 13:51:49 -06003403 cb_node->SetImageInitialLayout(*src_image_state, pCopyImageInfo->pRegions[i].srcSubresource,
3404 pCopyImageInfo->srcImageLayout);
3405 cb_node->SetImageInitialLayout(*dst_image_state, pCopyImageInfo->pRegions[i].dstSubresource,
3406 pCopyImageInfo->dstImageLayout);
Jeff Leger178b1e52020-10-05 12:22:23 -04003407 }
3408}
3409
Tony-LunarGb61514a2021-11-02 12:36:51 -06003410void CoreChecks::PreCallRecordCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR *pCopyImageInfo) {
3411 StateTracker::PreCallRecordCmdCopyImage2KHR(commandBuffer, pCopyImageInfo);
3412 RecordCmdCopyImage2(commandBuffer, pCopyImageInfo);
3413}
3414
3415void CoreChecks::PreCallRecordCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo) {
3416 StateTracker::PreCallRecordCmdCopyImage2(commandBuffer, pCopyImageInfo);
3417 RecordCmdCopyImage2(commandBuffer, pCopyImageInfo);
3418}
3419
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07003420// Returns true if sub_rect is entirely contained within rect
3421static inline bool ContainsRect(VkRect2D rect, VkRect2D sub_rect) {
3422 if ((sub_rect.offset.x < rect.offset.x) || (sub_rect.offset.x + sub_rect.extent.width > rect.offset.x + rect.extent.width) ||
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07003423 (sub_rect.offset.y < rect.offset.y) || (sub_rect.offset.y + sub_rect.extent.height > rect.offset.y + rect.extent.height)) {
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07003424 return false;
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07003425 }
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07003426 return true;
3427}
3428
Jeremy Gebben057f9d52021-11-05 14:12:31 -06003429bool CoreChecks::ValidateClearAttachmentExtent(const CMD_BUFFER_STATE &cb_node, uint32_t attachment_index,
amhagana448ea52021-11-02 14:09:14 -04003430 const IMAGE_VIEW_STATE* image_view_state,
3431 const VkRect2D &render_area, uint32_t rect_count, const VkClearRect *clear_rects) const {
John Zulauf3a548ef2019-02-01 16:14:07 -07003432 bool skip = false;
John Zulauf3a548ef2019-02-01 16:14:07 -07003433
3434 for (uint32_t j = 0; j < rect_count; j++) {
3435 if (!ContainsRect(render_area, clear_rects[j].rect)) {
Jeremy Gebben057f9d52021-11-05 14:12:31 -06003436 skip |= LogError(cb_node.Handle(), "VUID-vkCmdClearAttachments-pRects-00016",
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07003437 "vkCmdClearAttachments(): The area defined by pRects[%d] is not contained in the area of "
3438 "the current render pass instance.",
3439 j);
John Zulauf3a548ef2019-02-01 16:14:07 -07003440 }
3441
3442 if (image_view_state) {
3443 // The layers specified by a given element of pRects must be contained within every attachment that
3444 // pAttachments refers to
ziga-lunargff6485c2021-10-08 18:18:32 +02003445 const uint32_t attachment_layer_count = image_view_state->GetAttachmentLayerCount();
John Zulauf3a548ef2019-02-01 16:14:07 -07003446 if ((clear_rects[j].baseArrayLayer >= attachment_layer_count) ||
3447 (clear_rects[j].baseArrayLayer + clear_rects[j].layerCount > attachment_layer_count)) {
Jeremy Gebben057f9d52021-11-05 14:12:31 -06003448 skip |= LogError(cb_node.Handle(), "VUID-vkCmdClearAttachments-pRects-00017",
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07003449 "vkCmdClearAttachments(): The layers defined in pRects[%d] are not contained in the layers "
3450 "of pAttachment[%d].",
3451 j, attachment_index);
John Zulauf3a548ef2019-02-01 16:14:07 -07003452 }
3453 }
3454 }
3455 return skip;
3456}
3457
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003458bool CoreChecks::PreCallValidateCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
3459 const VkClearAttachment *pAttachments, uint32_t rectCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003460 const VkClearRect *pRects) const {
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07003461 bool skip = false;
Jeremy Gebbenb68fa022022-01-28 10:08:37 -07003462 auto cb_node = GetRead<CMD_BUFFER_STATE>(commandBuffer);
Petr Kraus2dffb382019-08-10 02:52:12 +02003463 if (!cb_node) return skip;
3464
Jeremy Gebben9f537102021-10-05 16:37:12 -06003465 skip |= ValidateCmd(cb_node.get(), CMD_CLEARATTACHMENTS);
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07003466
3467 // Validate that attachment is in reference list of active subpass
3468 if (cb_node->activeRenderPass) {
Mike Schuchardt2df08912020-12-15 16:28:09 -08003469 const VkRenderPassCreateInfo2 *renderpass_create_info = cb_node->activeRenderPass->createInfo.ptr();
John Zulauff2582972019-02-09 14:53:30 -07003470 const uint32_t renderpass_attachment_count = renderpass_create_info->attachmentCount;
Mike Schuchardt2df08912020-12-15 16:28:09 -08003471 const VkSubpassDescription2 *subpass_desc = &renderpass_create_info->pSubpasses[cb_node->activeSubpass];
locke-lunargaecf2152020-05-12 17:15:41 -06003472 const auto *framebuffer = cb_node->activeFramebuffer.get();
Aaron Hagan1656b2b2021-12-21 11:52:41 -05003473 const auto &render_area = (cb_node->activeRenderPass->use_dynamic_rendering) ?
3474 cb_node->activeRenderPass->dynamic_rendering_begin_rendering_info.renderArea :
3475 cb_node->activeRenderPassBeginInfo.renderArea;
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07003476
John Zulauf3a548ef2019-02-01 16:14:07 -07003477 for (uint32_t attachment_index = 0; attachment_index < attachmentCount; attachment_index++) {
3478 auto clear_desc = &pAttachments[attachment_index];
3479 uint32_t fb_attachment = VK_ATTACHMENT_UNUSED;
sfricke-samsungfdf91c82020-10-26 03:31:28 -07003480 const VkImageAspectFlags aspect_mask = clear_desc->aspectMask;
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07003481
sfricke-samsungfdf91c82020-10-26 03:31:28 -07003482 if (aspect_mask & VK_IMAGE_ASPECT_METADATA_BIT) {
3483 skip |= LogError(commandBuffer, "VUID-VkClearAttachment-aspectMask-00020",
3484 "vkCmdClearAttachments() pAttachments[%u] mask contains VK_IMAGE_ASPECT_METADATA_BIT",
3485 attachment_index);
3486 } else if (aspect_mask & (VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT | VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT |
3487 VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT | VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT)) {
3488 skip |=
3489 LogError(commandBuffer, "VUID-VkClearAttachment-aspectMask-02246",
3490 "vkCmdClearAttachments() pAttachments[%u] mask contains a VK_IMAGE_ASPECT_MEMORY_PLANE_*_BIT_EXT bit",
3491 attachment_index);
3492 } else if (aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) {
John Zulauff2582972019-02-09 14:53:30 -07003493 uint32_t color_attachment = VK_ATTACHMENT_UNUSED;
Aaron Haganc6bafff2021-11-29 23:30:07 -05003494 if (subpass_desc) {
amhagana448ea52021-11-02 14:09:14 -04003495 if (clear_desc->colorAttachment < subpass_desc->colorAttachmentCount) {
3496 color_attachment = subpass_desc->pColorAttachments[clear_desc->colorAttachment].attachment;
3497 if ((color_attachment != VK_ATTACHMENT_UNUSED) && (color_attachment >= renderpass_attachment_count)) {
3498 skip |= LogError(
3499 commandBuffer, "VUID-vkCmdClearAttachments-aspectMask-02501",
3500 "vkCmdClearAttachments() pAttachments[%u].colorAttachment=%u is not VK_ATTACHMENT_UNUSED "
3501 "and not a valid attachment for %s attachmentCount=%u. Subpass %u pColorAttachment[%u]=%u.",
3502 attachment_index, clear_desc->colorAttachment,
3503 report_data->FormatHandle(cb_node->activeRenderPass->renderPass()).c_str(), cb_node->activeSubpass,
3504 clear_desc->colorAttachment, color_attachment, renderpass_attachment_count);
Lockee9aeebf2019-03-03 23:50:08 -07003505
amhagana448ea52021-11-02 14:09:14 -04003506 color_attachment = VK_ATTACHMENT_UNUSED; // Defensive, prevent lookup past end of renderpass attachment
3507 }
3508 } else {
3509 skip |= LogError(commandBuffer, "VUID-vkCmdClearAttachments-aspectMask-02501",
3510 "vkCmdClearAttachments() pAttachments[%u].colorAttachment=%u out of range for %s"
3511 " subpass %u. colorAttachmentCount=%u",
3512 attachment_index, clear_desc->colorAttachment,
3513 report_data->FormatHandle(cb_node->activeRenderPass->renderPass()).c_str(),
3514 cb_node->activeSubpass, subpass_desc->colorAttachmentCount);
John Zulauff2582972019-02-09 14:53:30 -07003515 }
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07003516 }
John Zulauff2582972019-02-09 14:53:30 -07003517 fb_attachment = color_attachment;
3518
sfricke-samsungf1f35ce2020-10-26 03:35:35 -07003519 if ((clear_desc->aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) ||
3520 (clear_desc->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT)) {
3521 skip |= LogError(commandBuffer, "VUID-VkClearAttachment-aspectMask-00019",
3522 "vkCmdClearAttachments() pAttachments[%u] aspectMask must set only VK_IMAGE_ASPECT_COLOR_BIT "
3523 "of a color attachment.",
3524 attachment_index);
Mark Lobodzinskiac7e51e2017-02-02 15:50:27 -07003525 }
3526 } else { // Must be depth and/or stencil
Tony-LunarG1b2f8302020-10-29 13:26:23 -06003527 bool subpass_depth = false;
3528 bool subpass_stencil = false;
amhagana448ea52021-11-02 14:09:14 -04003529 if (subpass_desc) {
3530 if (subpass_desc->pDepthStencilAttachment &&
3531 (subpass_desc->pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED)) {
3532 auto index = subpass_desc->pDepthStencilAttachment->attachment;
3533 subpass_depth = FormatHasDepth(renderpass_create_info->pAttachments[index].format);
3534 subpass_stencil = FormatHasStencil(renderpass_create_info->pAttachments[index].format);
Tony-LunarG1b2f8302020-10-29 13:26:23 -06003535 }
amhagana448ea52021-11-02 14:09:14 -04003536 if (!subpass_desc->pDepthStencilAttachment ||
3537 (subpass_desc->pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED)) {
3538 if ((clear_desc->aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) && !subpass_depth) {
3539 skip |= LogError(
3540 commandBuffer, "VUID-vkCmdClearAttachments-aspectMask-02502",
3541 "vkCmdClearAttachments() pAttachments[%u] aspectMask has VK_IMAGE_ASPECT_DEPTH_BIT but there is no "
3542 "depth attachment in subpass",
3543 attachment_index);
3544 }
3545 if ((clear_desc->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) && !subpass_stencil) {
sfricke-samsungf1f35ce2020-10-26 03:35:35 -07003546 skip |= LogError(
3547 commandBuffer, "VUID-vkCmdClearAttachments-aspectMask-02503",
3548 "vkCmdClearAttachments() pAttachments[%u] aspectMask has VK_IMAGE_ASPECT_STENCIL_BIT but there is no "
amhagana448ea52021-11-02 14:09:14 -04003549 "stencil attachment in subpass",
3550 attachment_index);
3551 }
3552 } else {
3553 fb_attachment = subpass_desc->pDepthStencilAttachment->attachment;
sfricke-samsungf1f35ce2020-10-26 03:35:35 -07003554 }
amhagana448ea52021-11-02 14:09:14 -04003555 if (subpass_depth) {
3556 skip |= ValidateClearDepthStencilValue(commandBuffer, clear_desc->clearValue.depthStencil,
3557 "vkCmdClearAttachments()");
3558 }
sfricke-samsung03f11ef2021-01-23 02:02:15 -08003559 }
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07003560 }
John Zulauf3a548ef2019-02-01 16:14:07 -07003561 if (cb_node->createInfo.level == VK_COMMAND_BUFFER_LEVEL_PRIMARY) {
amhagana448ea52021-11-02 14:09:14 -04003562 const IMAGE_VIEW_STATE* image_view_state = nullptr;
3563 if (framebuffer && (fb_attachment != VK_ATTACHMENT_UNUSED) && (fb_attachment < framebuffer->createInfo.attachmentCount)) {
3564 image_view_state = cb_node->GetActiveAttachmentImageViewState(fb_attachment);
3565 }
Jeremy Gebben057f9d52021-11-05 14:12:31 -06003566 skip |= ValidateClearAttachmentExtent(*cb_node, attachment_index, image_view_state, render_area,
Mark Lobodzinskif933db92019-03-09 12:58:03 -07003567 rectCount, pRects);
John Zulauf441558b2019-08-12 11:47:39 -06003568 }
sfricke-samsung3d0c0b12020-08-04 00:21:37 -07003569
3570 // Once the framebuffer attachment is found, can get the image view state
3571 if (framebuffer && (fb_attachment != VK_ATTACHMENT_UNUSED) &&
3572 (fb_attachment < framebuffer->createInfo.attachmentCount)) {
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06003573 const auto *image_view_state = cb_node->GetActiveAttachmentImageViewState(fb_attachment);
sfricke-samsung3d0c0b12020-08-04 00:21:37 -07003574 if (image_view_state != nullptr) {
Jeremy Gebben9f537102021-10-05 16:37:12 -06003575 skip |= ValidateProtectedImage(cb_node.get(), image_view_state->image_state.get(), "vkCmdClearAttachments()",
sfricke-samsung3d0c0b12020-08-04 00:21:37 -07003576 "VUID-vkCmdClearAttachments-commandBuffer-02504");
Jeremy Gebben9f537102021-10-05 16:37:12 -06003577 skip |= ValidateUnprotectedImage(cb_node.get(), image_view_state->image_state.get(), "vkCmdClearAttachments()",
sfricke-samsung3d0c0b12020-08-04 00:21:37 -07003578 "VUID-vkCmdClearAttachments-commandBuffer-02505");
3579 }
3580 }
ziga-lunargfa335aa2021-08-05 16:59:39 +02003581
amhagana448ea52021-11-02 14:09:14 -04003582 // When a subpass uses a non-zero view mask, multiview functionality is considered to be enabled
3583 if (subpass_desc && (subpass_desc->viewMask > 0)) {
3584 for (uint32_t i = 0; i < rectCount; ++i) {
3585 if (pRects[i].baseArrayLayer != 0 || pRects[i].layerCount != 1) {
3586 skip |= LogError(commandBuffer, "VUID-vkCmdClearAttachments-baseArrayLayer-00018",
3587 "vkCmdClearAttachments(): pRects[%" PRIu32 "] baseArrayLayer is %" PRIu32
3588 " and layerCount is %" PRIu32 ", but the render pass instance uses multiview.",
3589 i, pRects[i].baseArrayLayer, pRects[i].layerCount);
3590 }
ziga-lunargfa335aa2021-08-05 16:59:39 +02003591 }
3592 }
3593 }
John Zulauf441558b2019-08-12 11:47:39 -06003594 }
3595 return skip;
3596}
3597
3598void CoreChecks::PreCallRecordCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
3599 const VkClearAttachment *pAttachments, uint32_t rectCount,
3600 const VkClearRect *pRects) {
Jeremy Gebben332d4dd2022-01-01 12:40:02 -07003601 auto cb_node = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
John Zulauf441558b2019-08-12 11:47:39 -06003602 if (cb_node->activeRenderPass && (cb_node->createInfo.level == VK_COMMAND_BUFFER_LEVEL_SECONDARY)) {
John Zulauf441558b2019-08-12 11:47:39 -06003603 std::shared_ptr<std::vector<VkClearRect>> clear_rect_copy;
Aaron Haganc6bafff2021-11-29 23:30:07 -05003604 if (cb_node->activeRenderPass->use_dynamic_rendering_inherited) {
3605 for (uint32_t attachment_index = 0; attachment_index < attachmentCount; attachment_index++) {
3606 const auto clear_desc = &pAttachments[attachment_index];
3607 auto colorAttachmentCount = cb_node->activeRenderPass->inheritance_rendering_info.colorAttachmentCount;
3608 int image_index = -1;
3609 if ((clear_desc->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) &&
3610 (clear_desc->colorAttachment < colorAttachmentCount)) {
3611 image_index = cb_node->GetDynamicColorAttachmentImageIndex(clear_desc->colorAttachment);
3612 }
3613 else if (clear_desc->aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT)) {
3614 image_index = cb_node->GetDynamicDepthAttachmentImageIndex();
3615 }
3616 else if (clear_desc->aspectMask & (VK_IMAGE_ASPECT_STENCIL_BIT)) {
3617 image_index = cb_node->GetDynamicStencilAttachmentImageIndex();
3618 }
amhagana448ea52021-11-02 14:09:14 -04003619
Aaron Haganc6bafff2021-11-29 23:30:07 -05003620 if (image_index != -1) {
3621 if (!clear_rect_copy) {
3622 // We need a copy of the clear rectangles that will persist until the last lambda executes
3623 // but we want to create it as lazily as possible
3624 clear_rect_copy.reset(new std::vector<VkClearRect>(pRects, pRects + rectCount));
amhagana448ea52021-11-02 14:09:14 -04003625 }
Aaron Haganc6bafff2021-11-29 23:30:07 -05003626 // if a secondary level command buffer inherits the framebuffer from the primary command buffer
3627 // (see VkCommandBufferInheritanceInfo), this validation must be deferred until queue submit time
3628 auto val_fn = [this, attachment_index, image_index, rectCount, clear_rect_copy](
3629 const CMD_BUFFER_STATE &secondary, const CMD_BUFFER_STATE *prim_cb,
3630 const FRAMEBUFFER_STATE *fb) {
3631 assert(rectCount == clear_rect_copy->size());
3632 bool skip = false;
3633 const IMAGE_VIEW_STATE* image_view_state = nullptr;
3634 if (image_index != -1) {
3635 image_view_state = (*prim_cb->active_attachments)[image_index];
3636 }
3637 skip = ValidateClearAttachmentExtent(secondary, attachment_index, image_view_state,
3638 prim_cb->activeRenderPass->dynamic_rendering_begin_rendering_info.renderArea,
3639 rectCount, clear_rect_copy->data());
3640 return skip;
3641 };
3642 cb_node->cmd_execute_commands_functions.emplace_back(val_fn);
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07003643 }
amhagana448ea52021-11-02 14:09:14 -04003644 }
3645 }
Aaron Haganc6bafff2021-11-29 23:30:07 -05003646 else if (cb_node->activeRenderPass->use_dynamic_rendering == false)
amhagana448ea52021-11-02 14:09:14 -04003647 {
3648 const VkRenderPassCreateInfo2* renderpass_create_info = cb_node->activeRenderPass->createInfo.ptr();
3649 const VkSubpassDescription2* subpass_desc = &renderpass_create_info->pSubpasses[cb_node->activeSubpass];
sfricke-samsung21286f82021-11-16 08:21:46 -08003650
amhagana448ea52021-11-02 14:09:14 -04003651 for (uint32_t attachment_index = 0; attachment_index < attachmentCount; attachment_index++) {
3652 const auto clear_desc = &pAttachments[attachment_index];
3653 uint32_t fb_attachment = VK_ATTACHMENT_UNUSED;
3654 if ((clear_desc->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) &&
3655 (clear_desc->colorAttachment < subpass_desc->colorAttachmentCount)) {
3656 fb_attachment = subpass_desc->pColorAttachments[clear_desc->colorAttachment].attachment;
3657 }
3658 else if ((clear_desc->aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) &&
3659 subpass_desc->pDepthStencilAttachment) {
3660 fb_attachment = subpass_desc->pDepthStencilAttachment->attachment;
3661 }
3662 if (fb_attachment != VK_ATTACHMENT_UNUSED) {
3663 if (!clear_rect_copy) {
3664 // We need a copy of the clear rectangles that will persist until the last lambda executes
3665 // but we want to create it as lazily as possible
3666 clear_rect_copy.reset(new std::vector<VkClearRect>(pRects, pRects + rectCount));
3667 }
3668 // if a secondary level command buffer inherits the framebuffer from the primary command buffer
3669 // (see VkCommandBufferInheritanceInfo), this validation must be deferred until queue submit time
Jeremy Gebben057f9d52021-11-05 14:12:31 -06003670 auto val_fn = [this, attachment_index, fb_attachment, rectCount, clear_rect_copy](
3671 const CMD_BUFFER_STATE &secondary, const CMD_BUFFER_STATE *prim_cb,
3672 const FRAMEBUFFER_STATE *fb) {
amhagana448ea52021-11-02 14:09:14 -04003673 assert(rectCount == clear_rect_copy->size());
3674 const auto& render_area = prim_cb->activeRenderPassBeginInfo.renderArea;
3675 bool skip = false;
3676 const IMAGE_VIEW_STATE* image_view_state = nullptr;
3677 if (fb && (fb_attachment != VK_ATTACHMENT_UNUSED) && (fb_attachment < fb->createInfo.attachmentCount)) {
3678 image_view_state = prim_cb->GetActiveAttachmentImageViewState(fb_attachment);
3679 }
Jeremy Gebben057f9d52021-11-05 14:12:31 -06003680 skip = ValidateClearAttachmentExtent(secondary, attachment_index, image_view_state, render_area, rectCount,
3681 clear_rect_copy->data());
amhagana448ea52021-11-02 14:09:14 -04003682 return skip;
3683 };
3684 cb_node->cmd_execute_commands_functions.emplace_back(val_fn);
3685 }
Mark Lobodzinski2def2bf2017-02-02 15:22:50 -07003686 }
3687 }
3688 }
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07003689}
3690
Jeff Leger178b1e52020-10-05 12:22:23 -04003691template <typename RegionType>
3692bool CoreChecks::ValidateCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
3693 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
Tony-LunarG562fc102021-11-12 13:58:35 -07003694 const RegionType *pRegions, CMD_TYPE cmd_type) const {
Jeremy Gebbenb68fa022022-01-28 10:08:37 -07003695 auto cb_node = GetRead<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenf4449392022-01-28 10:09:10 -07003696 auto src_image_state = Get<IMAGE_STATE>(srcImage);
3697 auto dst_image_state = Get<IMAGE_STATE>(dstImage);
Tony-LunarG562fc102021-11-12 13:58:35 -07003698 const bool is_2 = (cmd_type == CMD_RESOLVEIMAGE2KHR || cmd_type == CMD_RESOLVEIMAGE2);
sfricke-samsung85584a72021-09-30 21:43:38 -07003699 const char *func_name = CommandTypeString(cmd_type);
Jeff Leger178b1e52020-10-05 12:22:23 -04003700 const char *vuid;
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07003701
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07003702 bool skip = false;
3703 if (cb_node && src_image_state && dst_image_state) {
Tony-LunarG562fc102021-11-12 13:58:35 -07003704 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcImage-00256" : "VUID-vkCmdResolveImage-srcImage-00256";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003705 skip |= ValidateMemoryIsBoundToImage(src_image_state.get(), func_name, vuid);
Tony-LunarG562fc102021-11-12 13:58:35 -07003706 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstImage-00258" : "VUID-vkCmdResolveImage-dstImage-00258";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003707 skip |= ValidateMemoryIsBoundToImage(dst_image_state.get(), func_name, vuid);
3708 skip |= ValidateCmd(cb_node.get(), cmd_type);
Tony-LunarG562fc102021-11-12 13:58:35 -07003709 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstImage-02003" : "VUID-vkCmdResolveImage-dstImage-02003";
3710 skip |= ValidateImageFormatFeatureFlags(dst_image_state.get(), VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT, func_name, vuid);
3711 vuid = is_2 ? "VUID-vkCmdResolveImage2-commandBuffer-01837" : "VUID-vkCmdResolveImage-commandBuffer-01837";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003712 skip |= ValidateProtectedImage(cb_node.get(), src_image_state.get(), func_name, vuid);
Tony-LunarG562fc102021-11-12 13:58:35 -07003713 vuid = is_2 ? "VUID-vkCmdResolveImage2-commandBuffer-01838" : "VUID-vkCmdResolveImage-commandBuffer-01838";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003714 skip |= ValidateProtectedImage(cb_node.get(), dst_image_state.get(), func_name, vuid);
Tony-LunarG562fc102021-11-12 13:58:35 -07003715 vuid = is_2 ? "VUID-vkCmdResolveImage2-commandBuffer-01839" : "VUID-vkCmdResolveImage-commandBuffer-01839";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003716 skip |= ValidateUnprotectedImage(cb_node.get(), dst_image_state.get(), func_name, vuid);
ziga-lunarg73154fd2022-05-18 14:36:33 +02003717 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcImage-06762" : "VUID-vkCmdResolveImage-srcImage-06762";
3718 skip |= ValidateImageUsageFlags(src_image_state.get(), VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, vuid, func_name,
3719 "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
3720 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcImage-06763" : "VUID-vkCmdResolveImage-srcImage-06763";
3721 skip |= ValidateImageFormatFeatureFlags(src_image_state.get(), VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, func_name, vuid);
3722 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstImage-06764" : "VUID-vkCmdResolveImage-dstImage-06764";
3723 skip |= ValidateImageUsageFlags(dst_image_state.get(), VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, vuid, func_name,
3724 "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
3725 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstImage-06765" : "VUID-vkCmdResolveImage-dstImage-06765";
3726 skip |= ValidateImageFormatFeatureFlags(dst_image_state.get(), VK_FORMAT_FEATURE_TRANSFER_DST_BIT, func_name, vuid);
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07003727
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02003728 // Validation for VK_EXT_fragment_density_map
3729 if (src_image_state->createInfo.flags & VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT) {
Tony-LunarG562fc102021-11-12 13:58:35 -07003730 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstImage-02546" : "VUID-vkCmdResolveImage-dstImage-02546";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003731 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04003732 "%s: srcImage must not have been created with flags containing "
3733 "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT",
3734 func_name);
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02003735 }
3736 if (dst_image_state->createInfo.flags & VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT) {
Tony-LunarG562fc102021-11-12 13:58:35 -07003737 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstImage-02546" : "VUID-vkCmdResolveImage-dstImage-02546";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003738 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04003739 "%s: dstImage must not have been created with flags containing "
3740 "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT",
3741 func_name);
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02003742 }
3743
Cort Stratton7df30962018-05-17 19:45:57 -07003744 bool hit_error = false;
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003745 const char *invalid_src_layout_vuid =
Tony-LunarG562fc102021-11-12 13:58:35 -07003746 is_2 ? ((src_image_state->shared_presentable && IsExtEnabled(device_extensions.vk_khr_shared_presentable_image))
3747 ? "VUID-VkResolveImageInfo2-srcImageLayout-01400"
3748 : "VUID-VkResolveImageInfo2-srcImageLayout-00261")
sfricke-samsung45996a42021-09-16 13:45:27 -07003749 : ((src_image_state->shared_presentable && IsExtEnabled(device_extensions.vk_khr_shared_presentable_image))
Jeff Leger178b1e52020-10-05 12:22:23 -04003750 ? "VUID-vkCmdResolveImage-srcImageLayout-01400"
3751 : "VUID-vkCmdResolveImage-srcImageLayout-00261");
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07003752 const char *invalid_dst_layout_vuid =
Tony-LunarG562fc102021-11-12 13:58:35 -07003753 is_2 ? ((dst_image_state->shared_presentable && IsExtEnabled(device_extensions.vk_khr_shared_presentable_image))
3754 ? "VUID-VkResolveImageInfo2-dstImageLayout-01401"
3755 : "VUID-VkResolveImageInfo2-dstImageLayout-00263")
sfricke-samsung45996a42021-09-16 13:45:27 -07003756 : ((dst_image_state->shared_presentable && IsExtEnabled(device_extensions.vk_khr_shared_presentable_image))
Jeff Leger178b1e52020-10-05 12:22:23 -04003757 ? "VUID-vkCmdResolveImage-dstImageLayout-01401"
3758 : "VUID-vkCmdResolveImage-dstImageLayout-00263");
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07003759 // For each region, the number of layers in the image subresource should not be zero
3760 // For each region, src and dest image aspect must be color only
3761 for (uint32_t i = 0; i < regionCount; i++) {
Jeff Leger178b1e52020-10-05 12:22:23 -04003762 const RegionType region = pRegions[i];
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003763 const VkImageSubresourceLayers src_subresource = region.srcSubresource;
3764 const VkImageSubresourceLayers dst_subresource = region.dstSubresource;
Tony-LunarG562fc102021-11-12 13:58:35 -07003765
Jeremy Gebben9f537102021-10-05 16:37:12 -06003766 skip |= ValidateImageSubresourceLayers(cb_node.get(), &src_subresource, func_name, "srcSubresource", i);
3767 skip |= ValidateImageSubresourceLayers(cb_node.get(), &dst_subresource, func_name, "dstSubresource", i);
Tony-LunarG562fc102021-11-12 13:58:35 -07003768 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcImageLayout-00260" : "VUID-vkCmdResolveImage-srcImageLayout-00260";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003769 skip |= VerifyImageLayout(cb_node.get(), src_image_state.get(), src_subresource, srcImageLayout,
Jeff Leger178b1e52020-10-05 12:22:23 -04003770 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, func_name, invalid_src_layout_vuid, vuid, &hit_error);
Tony-LunarG562fc102021-11-12 13:58:35 -07003771 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstImageLayout-00262" : "VUID-vkCmdResolveImage-dstImageLayout-00262";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003772 skip |= VerifyImageLayout(cb_node.get(), dst_image_state.get(), dst_subresource, dstImageLayout,
Jeff Leger178b1e52020-10-05 12:22:23 -04003773 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, func_name, invalid_dst_layout_vuid, vuid, &hit_error);
Tony-LunarG562fc102021-11-12 13:58:35 -07003774 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcSubresource-01709" : "VUID-vkCmdResolveImage-srcSubresource-01709";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003775 skip |= ValidateImageMipLevel(cb_node.get(), src_image_state.get(), src_subresource.mipLevel, i, func_name,
3776 "srcSubresource", vuid);
Tony-LunarG562fc102021-11-12 13:58:35 -07003777 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstSubresource-01710" : "VUID-vkCmdResolveImage-dstSubresource-01710";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003778 skip |= ValidateImageMipLevel(cb_node.get(), dst_image_state.get(), dst_subresource.mipLevel, i, func_name,
3779 "dstSubresource", vuid);
Tony-LunarG562fc102021-11-12 13:58:35 -07003780 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcSubresource-01711" : "VUID-vkCmdResolveImage-srcSubresource-01711";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003781 skip |= ValidateImageArrayLayerRange(cb_node.get(), src_image_state.get(), src_subresource.baseArrayLayer,
Jeff Leger178b1e52020-10-05 12:22:23 -04003782 src_subresource.layerCount, i, func_name, "srcSubresource", vuid);
Tony-LunarG562fc102021-11-12 13:58:35 -07003783 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstSubresource-01712" : "VUID-vkCmdResolveImage-dstSubresource-01712";
Jeremy Gebben9f537102021-10-05 16:37:12 -06003784 skip |= ValidateImageArrayLayerRange(cb_node.get(), dst_image_state.get(), dst_subresource.baseArrayLayer,
Jeff Leger178b1e52020-10-05 12:22:23 -04003785 dst_subresource.layerCount, i, func_name, "srcSubresource", vuid);
Cort Stratton7df30962018-05-17 19:45:57 -07003786
3787 // layer counts must match
sfricke-samsung2e94fb02020-06-05 21:59:28 -07003788 if (src_subresource.layerCount != dst_subresource.layerCount) {
Tony-LunarG562fc102021-11-12 13:58:35 -07003789 vuid = is_2 ? "VUID-VkImageResolve2-layerCount-00267" : "VUID-VkImageResolve-layerCount-00267";
Jeff Leger178b1e52020-10-05 12:22:23 -04003790 skip |=
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003791 LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04003792 "%s: layerCount in source and destination subresource of pRegions[%u] does not match.", func_name, i);
Mark Lobodzinski50fbef12017-02-06 15:31:33 -07003793 }
Cort Stratton7df30962018-05-17 19:45:57 -07003794 // For each region, src and dest image aspect must be color only
sfricke-samsung2e94fb02020-06-05 21:59:28 -07003795 if ((src_subresource.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) ||
3796 (dst_subresource.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT)) {
Tony-LunarG562fc102021-11-12 13:58:35 -07003797 vuid = is_2 ? "VUID-VkImageResolve2-aspectMask-00266" : "VUID-VkImageResolve-aspectMask-00266";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003798 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04003799 "%s: src and dest aspectMasks for pRegions[%u] must specify only VK_IMAGE_ASPECT_COLOR_BIT.",
3800 func_name, i);
sfricke-samsung2e94fb02020-06-05 21:59:28 -07003801 }
3802
3803 const VkImageType src_image_type = src_image_state->createInfo.imageType;
3804 const VkImageType dst_image_type = dst_image_state->createInfo.imageType;
3805
3806 if ((VK_IMAGE_TYPE_3D == src_image_type) || (VK_IMAGE_TYPE_3D == dst_image_type)) {
Shannon McPherson74b341c2020-09-08 15:43:05 -06003807 if ((0 != src_subresource.baseArrayLayer) || (1 != src_subresource.layerCount)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003808 LogObjectList objlist(cb_node->commandBuffer());
3809 objlist.add(src_image_state->image());
3810 objlist.add(dst_image_state->image());
Tony-LunarG562fc102021-11-12 13:58:35 -07003811 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcImage-04446" : "VUID-vkCmdResolveImage-srcImage-04446";
Jeff Leger178b1e52020-10-05 12:22:23 -04003812 skip |= LogError(objlist, vuid,
3813 "%s: pRegions[%u] baseArrayLayer must be 0 and layerCount must be 1 for all "
Shannon McPherson74b341c2020-09-08 15:43:05 -06003814 "subresources if the src or dst image is 3D.",
Jeff Leger178b1e52020-10-05 12:22:23 -04003815 func_name, i);
Shannon McPherson74b341c2020-09-08 15:43:05 -06003816 }
3817 if ((0 != dst_subresource.baseArrayLayer) || (1 != dst_subresource.layerCount)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003818 LogObjectList objlist(cb_node->commandBuffer());
3819 objlist.add(src_image_state->image());
3820 objlist.add(dst_image_state->image());
Tony-LunarG562fc102021-11-12 13:58:35 -07003821 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcImage-04447" : "VUID-vkCmdResolveImage-srcImage-04447";
Jeff Leger178b1e52020-10-05 12:22:23 -04003822 skip |= LogError(objlist, vuid,
3823 "%s: pRegions[%u] baseArrayLayer must be 0 and layerCount must be 1 for all "
sfricke-samsung2e94fb02020-06-05 21:59:28 -07003824 "subresources if the src or dst image is 3D.",
Jeff Leger178b1e52020-10-05 12:22:23 -04003825 func_name, i);
sfricke-samsung2e94fb02020-06-05 21:59:28 -07003826 }
3827 }
3828
3829 if (VK_IMAGE_TYPE_1D == src_image_type) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05003830 if ((region.srcOffset.y != 0) || (region.extent.height != 1)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003831 LogObjectList objlist(cb_node->commandBuffer());
3832 objlist.add(src_image_state->image());
Tony-LunarG562fc102021-11-12 13:58:35 -07003833 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcImage-00271" : "VUID-vkCmdResolveImage-srcImage-00271";
Jeff Leger178b1e52020-10-05 12:22:23 -04003834 skip |= LogError(objlist, vuid,
3835 "%s: srcImage (%s) is 1D but pRegions[%u] srcOffset.y (%d) is not 0 or "
sfricke-samsung2e94fb02020-06-05 21:59:28 -07003836 "extent.height (%u) is not 1.",
sfricke-samsung71f04e32022-03-16 01:21:21 -05003837 func_name, report_data->FormatHandle(src_image_state->image()).c_str(), i, region.srcOffset.y,
3838 region.extent.height);
sfricke-samsung2e94fb02020-06-05 21:59:28 -07003839 }
3840 }
3841 if ((VK_IMAGE_TYPE_1D == src_image_type) || (VK_IMAGE_TYPE_2D == src_image_type)) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05003842 if ((region.srcOffset.z != 0) || (region.extent.depth != 1)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003843 LogObjectList objlist(cb_node->commandBuffer());
3844 objlist.add(src_image_state->image());
Tony-LunarG562fc102021-11-12 13:58:35 -07003845 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcImage-00273" : "VUID-vkCmdResolveImage-srcImage-00273";
Jeff Leger178b1e52020-10-05 12:22:23 -04003846 skip |= LogError(objlist, vuid,
3847 "%s: srcImage (%s) is 2D but pRegions[%u] srcOffset.z (%d) is not 0 or "
sfricke-samsung2e94fb02020-06-05 21:59:28 -07003848 "extent.depth (%u) is not 1.",
sfricke-samsung71f04e32022-03-16 01:21:21 -05003849 func_name, report_data->FormatHandle(src_image_state->image()).c_str(), i, region.srcOffset.z,
3850 region.extent.depth);
sfricke-samsung2e94fb02020-06-05 21:59:28 -07003851 }
3852 }
3853
3854 if (VK_IMAGE_TYPE_1D == dst_image_type) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05003855 if ((region.dstOffset.y != 0) || (region.extent.height != 1)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003856 LogObjectList objlist(cb_node->commandBuffer());
3857 objlist.add(dst_image_state->image());
Tony-LunarG562fc102021-11-12 13:58:35 -07003858 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstImage-00276" : "VUID-vkCmdResolveImage-dstImage-00276";
Jeff Leger178b1e52020-10-05 12:22:23 -04003859 skip |= LogError(objlist, vuid,
3860 "%s: dstImage (%s) is 1D but pRegions[%u] dstOffset.y (%d) is not 0 or "
sfricke-samsung2e94fb02020-06-05 21:59:28 -07003861 "extent.height (%u) is not 1.",
sfricke-samsung71f04e32022-03-16 01:21:21 -05003862 func_name, report_data->FormatHandle(dst_image_state->image()).c_str(), i, region.dstOffset.y,
3863 region.extent.height);
sfricke-samsung2e94fb02020-06-05 21:59:28 -07003864 }
3865 }
3866 if ((VK_IMAGE_TYPE_1D == dst_image_type) || (VK_IMAGE_TYPE_2D == dst_image_type)) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05003867 if ((region.dstOffset.z != 0) || (region.extent.depth != 1)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003868 LogObjectList objlist(cb_node->commandBuffer());
3869 objlist.add(dst_image_state->image());
Tony-LunarG562fc102021-11-12 13:58:35 -07003870 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstImage-00278" : "VUID-vkCmdResolveImage-dstImage-00278";
Jeff Leger178b1e52020-10-05 12:22:23 -04003871 skip |= LogError(objlist, vuid,
3872 "%s: dstImage (%s) is 2D but pRegions[%u] dstOffset.z (%d) is not 0 or "
sfricke-samsung2e94fb02020-06-05 21:59:28 -07003873 "extent.depth (%u) is not 1.",
sfricke-samsung71f04e32022-03-16 01:21:21 -05003874 func_name, report_data->FormatHandle(dst_image_state->image()).c_str(), i, region.dstOffset.z,
3875 region.extent.depth);
sfricke-samsung2e94fb02020-06-05 21:59:28 -07003876 }
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07003877 }
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003878
3879 // Each srcImage dimension offset + extent limits must fall with image subresource extent
Jeremy Gebben1dfbd172021-05-19 14:00:58 -06003880 VkExtent3D subresource_extent = src_image_state->GetSubresourceExtent(src_subresource);
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003881 // MipLevel bound is checked already and adding extra errors with a "subresource extent of zero" is confusing to
3882 // developer
3883 if (src_subresource.mipLevel < src_image_state->createInfo.mipLevels) {
3884 uint32_t extent_check = ExceedsBounds(&(region.srcOffset), &(region.extent), &subresource_extent);
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07003885 if ((extent_check & kXBit) != 0) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003886 LogObjectList objlist(cb_node->commandBuffer());
3887 objlist.add(src_image_state->image());
Tony-LunarG562fc102021-11-12 13:58:35 -07003888 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcOffset-00269" : "VUID-vkCmdResolveImage-srcOffset-00269";
Jeff Leger178b1e52020-10-05 12:22:23 -04003889 skip |= LogError(objlist, vuid,
3890 "%s: srcImage (%s) pRegions[%u] x-dimension offset [%1d] + extent [%u] "
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003891 "exceeds subResource width [%u].",
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003892 func_name, report_data->FormatHandle(src_image_state->image()).c_str(), i, region.srcOffset.x,
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003893 region.extent.width, subresource_extent.width);
3894 }
3895
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07003896 if ((extent_check & kYBit) != 0) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003897 LogObjectList objlist(cb_node->commandBuffer());
3898 objlist.add(src_image_state->image());
Tony-LunarG562fc102021-11-12 13:58:35 -07003899 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcOffset-00270" : "VUID-vkCmdResolveImage-srcOffset-00270";
Jeff Leger178b1e52020-10-05 12:22:23 -04003900 skip |= LogError(objlist, vuid,
3901 "%s: srcImage (%s) pRegions[%u] y-dimension offset [%1d] + extent [%u] "
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003902 "exceeds subResource height [%u].",
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003903 func_name, report_data->FormatHandle(src_image_state->image()).c_str(), i, region.srcOffset.y,
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003904 region.extent.height, subresource_extent.height);
3905 }
3906
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07003907 if ((extent_check & kZBit) != 0) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003908 LogObjectList objlist(cb_node->commandBuffer());
3909 objlist.add(src_image_state->image());
Tony-LunarG562fc102021-11-12 13:58:35 -07003910 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcOffset-00272" : "VUID-vkCmdResolveImage-srcOffset-00272";
Jeff Leger178b1e52020-10-05 12:22:23 -04003911 skip |= LogError(objlist, vuid,
3912 "%s: srcImage (%s) pRegions[%u] z-dimension offset [%1d] + extent [%u] "
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003913 "exceeds subResource depth [%u].",
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003914 func_name, report_data->FormatHandle(src_image_state->image()).c_str(), i, region.srcOffset.z,
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003915 region.extent.depth, subresource_extent.depth);
3916 }
3917 }
3918
3919 // Each dstImage dimension offset + extent limits must fall with image subresource extent
Jeremy Gebben1dfbd172021-05-19 14:00:58 -06003920 subresource_extent = dst_image_state->GetSubresourceExtent(dst_subresource);
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003921 // MipLevel bound is checked already and adding extra errors with a "subresource extent of zero" is confusing to
3922 // developer
3923 if (dst_subresource.mipLevel < dst_image_state->createInfo.mipLevels) {
3924 uint32_t extent_check = ExceedsBounds(&(region.dstOffset), &(region.extent), &subresource_extent);
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07003925 if ((extent_check & kXBit) != 0) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003926 LogObjectList objlist(cb_node->commandBuffer());
3927 objlist.add(dst_image_state->image());
Tony-LunarG562fc102021-11-12 13:58:35 -07003928 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstOffset-00274" : "VUID-vkCmdResolveImage-dstOffset-00274";
Jeff Leger178b1e52020-10-05 12:22:23 -04003929 skip |= LogError(objlist, vuid,
3930 "%s: dstImage (%s) pRegions[%u] x-dimension offset [%1d] + extent [%u] "
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003931 "exceeds subResource width [%u].",
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003932 func_name, report_data->FormatHandle(dst_image_state->image()).c_str(), i, region.srcOffset.x,
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003933 region.extent.width, subresource_extent.width);
3934 }
3935
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07003936 if ((extent_check & kYBit) != 0) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003937 LogObjectList objlist(cb_node->commandBuffer());
3938 objlist.add(dst_image_state->image());
Tony-LunarG562fc102021-11-12 13:58:35 -07003939 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstOffset-00275" : "VUID-vkCmdResolveImage-dstOffset-00275";
Jeff Leger178b1e52020-10-05 12:22:23 -04003940 skip |= LogError(objlist, vuid,
3941 "%s: dstImage (%s) pRegions[%u] y-dimension offset [%1d] + extent [%u] "
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003942 "exceeds subResource height [%u].",
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003943 func_name, report_data->FormatHandle(dst_image_state->image()).c_str(), i, region.srcOffset.y,
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003944 region.extent.height, subresource_extent.height);
3945 }
3946
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07003947 if ((extent_check & kZBit) != 0) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003948 LogObjectList objlist(cb_node->commandBuffer());
3949 objlist.add(dst_image_state->image());
Tony-LunarG562fc102021-11-12 13:58:35 -07003950 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstOffset-00277" : "VUID-vkCmdResolveImage-dstOffset-00277";
Jeff Leger178b1e52020-10-05 12:22:23 -04003951 skip |= LogError(objlist, vuid,
3952 "%s: dstImage (%s) pRegions[%u] z-dimension offset [%1d] + extent [%u] "
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003953 "exceeds subResource depth [%u].",
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003954 func_name, report_data->FormatHandle(dst_image_state->image()).c_str(), i, region.srcOffset.z,
sfricke-samsungdfeb3172020-07-25 21:17:07 -07003955 region.extent.depth, subresource_extent.depth);
3956 }
3957 }
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07003958 }
3959
3960 if (src_image_state->createInfo.format != dst_image_state->createInfo.format) {
Tony-LunarG562fc102021-11-12 13:58:35 -07003961 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcImage-01386" : "VUID-vkCmdResolveImage-srcImage-01386";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003962 skip |= LogError(cb_node->commandBuffer(), vuid, "%s: srcImage format (%s) and dstImage format (%s) are not the same.",
Jeff Leger178b1e52020-10-05 12:22:23 -04003963 func_name, string_VkFormat(src_image_state->createInfo.format),
3964 string_VkFormat(dst_image_state->createInfo.format));
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07003965 }
3966 if (src_image_state->createInfo.imageType != dst_image_state->createInfo.imageType) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003967 skip |= LogWarning(cb_node->commandBuffer(), kVUID_Core_DrawState_MismatchedImageType,
Jeff Leger178b1e52020-10-05 12:22:23 -04003968 "%s: srcImage type (%s) and dstImage type (%s) are not the same.", func_name,
sfricke-samsungc26350e2020-05-30 12:31:31 -07003969 string_VkImageType(src_image_state->createInfo.imageType),
3970 string_VkImageType(dst_image_state->createInfo.imageType));
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07003971 }
3972 if (src_image_state->createInfo.samples == VK_SAMPLE_COUNT_1_BIT) {
Tony-LunarG562fc102021-11-12 13:58:35 -07003973 vuid = is_2 ? "VUID-VkResolveImageInfo2-srcImage-00257" : "VUID-vkCmdResolveImage-srcImage-00257";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003974 skip |= LogError(cb_node->commandBuffer(), vuid, "%s: srcImage sample count is VK_SAMPLE_COUNT_1_BIT.", func_name);
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07003975 }
3976 if (dst_image_state->createInfo.samples != VK_SAMPLE_COUNT_1_BIT) {
Tony-LunarG562fc102021-11-12 13:58:35 -07003977 vuid = is_2 ? "VUID-VkResolveImageInfo2-dstImage-00259" : "VUID-vkCmdResolveImage-dstImage-00259";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06003978 skip |= LogError(cb_node->commandBuffer(), vuid, "%s: dstImage sample count (%s) is not VK_SAMPLE_COUNT_1_BIT.",
Jeff Leger178b1e52020-10-05 12:22:23 -04003979 func_name, string_VkSampleCountFlagBits(dst_image_state->createInfo.samples));
Mark Lobodzinski2a3368e2017-02-06 15:29:37 -07003980 }
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07003981 } else {
3982 assert(0);
3983 }
3984 return skip;
3985}
3986
Jeff Leger178b1e52020-10-05 12:22:23 -04003987bool CoreChecks::PreCallValidateCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
3988 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
3989 const VkImageResolve *pRegions) const {
3990 return ValidateCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions,
Tony-LunarG562fc102021-11-12 13:58:35 -07003991 CMD_RESOLVEIMAGE);
Jeff Leger178b1e52020-10-05 12:22:23 -04003992}
3993
3994bool CoreChecks::PreCallValidateCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
3995 const VkResolveImageInfo2KHR *pResolveImageInfo) const {
3996 return ValidateCmdResolveImage(commandBuffer, pResolveImageInfo->srcImage, pResolveImageInfo->srcImageLayout,
3997 pResolveImageInfo->dstImage, pResolveImageInfo->dstImageLayout, pResolveImageInfo->regionCount,
Tony-LunarG562fc102021-11-12 13:58:35 -07003998 pResolveImageInfo->pRegions, CMD_RESOLVEIMAGE2KHR);
3999}
4000
4001bool CoreChecks::PreCallValidateCmdResolveImage2(VkCommandBuffer commandBuffer,
4002 const VkResolveImageInfo2 *pResolveImageInfo) const {
4003 return ValidateCmdResolveImage(commandBuffer, pResolveImageInfo->srcImage, pResolveImageInfo->srcImageLayout,
4004 pResolveImageInfo->dstImage, pResolveImageInfo->dstImageLayout, pResolveImageInfo->regionCount,
4005 pResolveImageInfo->pRegions, CMD_RESOLVEIMAGE2);
Jeff Leger178b1e52020-10-05 12:22:23 -04004006}
4007
4008template <typename RegionType>
4009bool CoreChecks::ValidateCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
4010 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
Tony-LunarG542ae912021-11-04 16:06:44 -06004011 const RegionType *pRegions, VkFilter filter, CMD_TYPE cmd_type) const {
Jeremy Gebbenb68fa022022-01-28 10:08:37 -07004012 auto cb_node = GetRead<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenf4449392022-01-28 10:09:10 -07004013 auto src_image_state = Get<IMAGE_STATE>(srcImage);
4014 auto dst_image_state = Get<IMAGE_STATE>(dstImage);
Tony-LunarG542ae912021-11-04 16:06:44 -06004015 const bool is_2 = (cmd_type == CMD_BLITIMAGE2KHR || cmd_type == CMD_BLITIMAGE2);
sfricke-samsung85584a72021-09-30 21:43:38 -07004016 const char *func_name = CommandTypeString(cmd_type);
Jeff Leger178b1e52020-10-05 12:22:23 -04004017
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07004018 bool skip = false;
John Zulauf5c2750c2018-01-30 15:04:56 -07004019 if (cb_node) {
Jeremy Gebben9f537102021-10-05 16:37:12 -06004020 skip |= ValidateCmd(cb_node.get(), cmd_type);
John Zulauf5c2750c2018-01-30 15:04:56 -07004021 }
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07004022 if (cb_node && src_image_state && dst_image_state) {
Jeff Leger178b1e52020-10-05 12:22:23 -04004023 const char *vuid;
Tony-LunarG542ae912021-11-04 16:06:44 -06004024 std::string loc_head = std::string(func_name);
4025 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcImage-00233" : "VUID-vkCmdBlitImage-srcImage-00233";
4026 const char *location1 = is_2 ? loc_head.append("(): pBlitImageInfo->srcImage").c_str() : "vkCmdBlitImage(): srcImage";
4027 skip |= ValidateImageSampleCount(src_image_state.get(), VK_SAMPLE_COUNT_1_BIT, location1, vuid);
4028 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstImage-00234" : "VUID-vkCmdBlitImage-dstImage-00234";
4029 loc_head = std::string(func_name);
4030 const char *location2 = is_2 ? loc_head.append("(): pBlitImageInfo->dstImage").c_str() : "vkCmdBlitImage(): dstImage";
4031 skip |= ValidateImageSampleCount(dst_image_state.get(), VK_SAMPLE_COUNT_1_BIT, location2, vuid);
4032 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcImage-00220" : "VUID-vkCmdBlitImage-srcImage-00220";
Jeremy Gebben9f537102021-10-05 16:37:12 -06004033 skip |= ValidateMemoryIsBoundToImage(src_image_state.get(), func_name, vuid);
Tony-LunarG542ae912021-11-04 16:06:44 -06004034 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstImage-00225" : "VUID-vkCmdBlitImage-dstImage-00225";
Jeremy Gebben9f537102021-10-05 16:37:12 -06004035 skip |= ValidateMemoryIsBoundToImage(dst_image_state.get(), func_name, vuid);
Tony-LunarG542ae912021-11-04 16:06:44 -06004036 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcImage-00219" : "VUID-vkCmdBlitImage-srcImage-00219";
Jeremy Gebben9f537102021-10-05 16:37:12 -06004037 skip |= ValidateImageUsageFlags(src_image_state.get(), VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, vuid, func_name,
Jeff Leger178b1e52020-10-05 12:22:23 -04004038 "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
Tony-LunarG542ae912021-11-04 16:06:44 -06004039 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstImage-00224" : "VUID-vkCmdBlitImage-dstImage-00224";
Jeremy Gebben9f537102021-10-05 16:37:12 -06004040 skip |= ValidateImageUsageFlags(dst_image_state.get(), VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, vuid, func_name,
Jeff Leger178b1e52020-10-05 12:22:23 -04004041 "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
Jeremy Gebben9f537102021-10-05 16:37:12 -06004042 skip |= ValidateCmd(cb_node.get(), cmd_type);
Tony-LunarG542ae912021-11-04 16:06:44 -06004043 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcImage-01999" : "VUID-vkCmdBlitImage-srcImage-01999";
4044 skip |= ValidateImageFormatFeatureFlags(src_image_state.get(), VK_FORMAT_FEATURE_2_BLIT_SRC_BIT, func_name, vuid);
4045 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstImage-02000" : "VUID-vkCmdBlitImage-dstImage-02000";
4046 skip |= ValidateImageFormatFeatureFlags(dst_image_state.get(), VK_FORMAT_FEATURE_2_BLIT_DST_BIT, func_name, vuid);
4047 vuid = is_2 ? "VUID-vkCmdBlitImage2-commandBuffer-01834" : "VUID-vkCmdBlitImage-commandBuffer-01834";
Jeremy Gebben9f537102021-10-05 16:37:12 -06004048 skip |= ValidateProtectedImage(cb_node.get(), src_image_state.get(), func_name, vuid);
Tony-LunarG542ae912021-11-04 16:06:44 -06004049 vuid = is_2 ? "VUID-vkCmdBlitImage2-commandBuffer-01835" : "VUID-vkCmdBlitImage-commandBuffer-01835";
Jeremy Gebben9f537102021-10-05 16:37:12 -06004050 skip |= ValidateProtectedImage(cb_node.get(), dst_image_state.get(), func_name, vuid);
Tony-LunarG542ae912021-11-04 16:06:44 -06004051 vuid = is_2 ? "VUID-vkCmdBlitImage2-commandBuffer-01836" : "VUID-vkCmdBlitImage-commandBuffer-01836";
Jeremy Gebben9f537102021-10-05 16:37:12 -06004052 skip |= ValidateUnprotectedImage(cb_node.get(), dst_image_state.get(), func_name, vuid);
sfricke-samsung022fa252020-07-24 03:26:16 -07004053
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02004054 // Validation for VK_EXT_fragment_density_map
4055 if (src_image_state->createInfo.flags & VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004056 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstImage-02545" : "VUID-vkCmdBlitImage-dstImage-02545";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004057 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004058 "%s: srcImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT",
4059 func_name);
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02004060 }
4061 if (dst_image_state->createInfo.flags & VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004062 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstImage-02545" : "VUID-vkCmdBlitImage-dstImage-02545";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004063 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004064 "%s: dstImage must not have been created with flags containing VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT",
4065 func_name);
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02004066 }
4067
Tobin Ehlisbb03e5f2017-05-11 08:52:51 -06004068 // TODO: Need to validate image layouts, which will include layout validation for shared presentable images
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07004069
Dave Houlton33c2d252017-06-09 17:08:32 -06004070 VkFormat src_format = src_image_state->createInfo.format;
4071 VkFormat dst_format = dst_image_state->createInfo.format;
4072 VkImageType src_type = src_image_state->createInfo.imageType;
4073 VkImageType dst_type = dst_image_state->createInfo.imageType;
4074
Cort Stratton186b1a22018-05-01 20:18:06 -04004075 if (VK_FILTER_LINEAR == filter) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004076 vuid = is_2 ? "VUID-VkBlitImageInfo2-filter-02001" : "VUID-vkCmdBlitImage-filter-02001";
4077 skip |= ValidateImageFormatFeatureFlags(src_image_state.get(), VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
Jeremy Gebben9f537102021-10-05 16:37:12 -06004078 func_name, vuid);
Cort Stratton186b1a22018-05-01 20:18:06 -04004079 } else if (VK_FILTER_CUBIC_IMG == filter) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004080 vuid = is_2 ? "VUID-VkBlitImageInfo2-filter-02002" : "VUID-vkCmdBlitImage-filter-02002";
4081 skip |= ValidateImageFormatFeatureFlags(src_image_state.get(), VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT,
Jeff Leger178b1e52020-10-05 12:22:23 -04004082 func_name, vuid);
Dave Houlton33c2d252017-06-09 17:08:32 -06004083 }
4084
sfricke-samsung10b35ce2021-09-29 08:50:20 -07004085 if (FormatRequiresYcbcrConversionExplicitly(src_format)) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004086 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcImage-06421" : "VUID-vkCmdBlitImage-srcImage-06421";
Jeff Leger178b1e52020-10-05 12:22:23 -04004087 skip |= LogError(device, vuid,
4088 "%s: srcImage format (%s) must not be one of the formats requiring sampler YCBCR "
Mark Lobodzinski1057e442020-02-13 11:57:15 -07004089 "conversion for VK_IMAGE_ASPECT_COLOR_BIT image views",
Jeff Leger178b1e52020-10-05 12:22:23 -04004090 func_name, string_VkFormat(src_format));
Mark Lobodzinski1057e442020-02-13 11:57:15 -07004091 }
4092
sfricke-samsung10b35ce2021-09-29 08:50:20 -07004093 if (FormatRequiresYcbcrConversionExplicitly(dst_format)) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004094 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstImage-06422" : "VUID-vkCmdBlitImage-dstImage-06422";
Jeff Leger178b1e52020-10-05 12:22:23 -04004095 skip |= LogError(device, vuid,
4096 "%s: dstImage format (%s) must not be one of the formats requiring sampler YCBCR "
Mark Lobodzinski1057e442020-02-13 11:57:15 -07004097 "conversion for VK_IMAGE_ASPECT_COLOR_BIT image views",
Jeff Leger178b1e52020-10-05 12:22:23 -04004098 func_name, string_VkFormat(dst_format));
Mark Lobodzinski1057e442020-02-13 11:57:15 -07004099 }
4100
ziga-lunarg52604a12021-09-09 16:02:05 +02004101 if ((VK_FILTER_CUBIC_IMG == filter) && (VK_IMAGE_TYPE_2D != src_type)) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004102 vuid = is_2 ? "VUID-VkBlitImageInfo2-filter-00237" : "VUID-vkCmdBlitImage-filter-00237";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004103 skip |= LogError(cb_node->commandBuffer(), vuid,
ziga-lunarg52604a12021-09-09 16:02:05 +02004104 "%s: source image type must be VK_IMAGE_TYPE_2D when cubic filtering is specified.", func_name);
Dave Houlton33c2d252017-06-09 17:08:32 -06004105 }
4106
Dave Houlton33c2d252017-06-09 17:08:32 -06004107 // Validate consistency for unsigned formats
sfricke-samsunge3086292021-11-18 23:02:35 -08004108 if (FormatIsUINT(src_format) != FormatIsUINT(dst_format)) {
Dave Houlton33c2d252017-06-09 17:08:32 -06004109 std::stringstream ss;
Jeff Leger178b1e52020-10-05 12:22:23 -04004110 ss << func_name << ": If one of srcImage and dstImage images has unsigned integer format, "
Dave Houlton33c2d252017-06-09 17:08:32 -06004111 << "the other one must also have unsigned integer format. "
4112 << "Source format is " << string_VkFormat(src_format) << " Destination format is " << string_VkFormat(dst_format);
Tony-LunarG542ae912021-11-04 16:06:44 -06004113 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcImage-00230" : "VUID-vkCmdBlitImage-srcImage-00230";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004114 skip |= LogError(cb_node->commandBuffer(), vuid, "%s.", ss.str().c_str());
Dave Houlton33c2d252017-06-09 17:08:32 -06004115 }
4116
4117 // Validate consistency for signed formats
sfricke-samsunge3086292021-11-18 23:02:35 -08004118 if (FormatIsSINT(src_format) != FormatIsSINT(dst_format)) {
Dave Houlton33c2d252017-06-09 17:08:32 -06004119 std::stringstream ss;
Jeff Leger178b1e52020-10-05 12:22:23 -04004120 ss << func_name << ": If one of srcImage and dstImage images has signed integer format, "
Dave Houlton33c2d252017-06-09 17:08:32 -06004121 << "the other one must also have signed integer format. "
4122 << "Source format is " << string_VkFormat(src_format) << " Destination format is " << string_VkFormat(dst_format);
Tony-LunarG542ae912021-11-04 16:06:44 -06004123 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcImage-00229" : "VUID-vkCmdBlitImage-srcImage-00229";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004124 skip |= LogError(cb_node->commandBuffer(), vuid, "%s.", ss.str().c_str());
Dave Houlton33c2d252017-06-09 17:08:32 -06004125 }
4126
4127 // Validate filter for Depth/Stencil formats
4128 if (FormatIsDepthOrStencil(src_format) && (filter != VK_FILTER_NEAREST)) {
4129 std::stringstream ss;
Jeff Leger178b1e52020-10-05 12:22:23 -04004130 ss << func_name << ": If the format of srcImage is a depth, stencil, or depth stencil "
Dave Houlton33c2d252017-06-09 17:08:32 -06004131 << "then filter must be VK_FILTER_NEAREST.";
Tony-LunarG542ae912021-11-04 16:06:44 -06004132 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcImage-00232" : "VUID-vkCmdBlitImage-srcImage-00232";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004133 skip |= LogError(cb_node->commandBuffer(), vuid, "%s.", ss.str().c_str());
Dave Houlton33c2d252017-06-09 17:08:32 -06004134 }
4135
4136 // Validate aspect bits and formats for depth/stencil images
4137 if (FormatIsDepthOrStencil(src_format) || FormatIsDepthOrStencil(dst_format)) {
4138 if (src_format != dst_format) {
4139 std::stringstream ss;
Jeff Leger178b1e52020-10-05 12:22:23 -04004140 ss << func_name << ": If one of srcImage and dstImage images has a format of depth, stencil or depth "
Dave Houlton33c2d252017-06-09 17:08:32 -06004141 << "stencil, the other one must have exactly the same format. "
4142 << "Source format is " << string_VkFormat(src_format) << " Destination format is "
4143 << string_VkFormat(dst_format);
Tony-LunarG542ae912021-11-04 16:06:44 -06004144 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcImage-00231" : "VUID-vkCmdBlitImage-srcImage-00231";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004145 skip |= LogError(cb_node->commandBuffer(), vuid, "%s.", ss.str().c_str());
Dave Houlton33c2d252017-06-09 17:08:32 -06004146 }
Dave Houlton33c2d252017-06-09 17:08:32 -06004147 } // Depth or Stencil
4148
4149 // Do per-region checks
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004150 const char *invalid_src_layout_vuid =
Tony-LunarG542ae912021-11-04 16:06:44 -06004151 is_2 ? ((src_image_state->shared_presentable && IsExtEnabled(device_extensions.vk_khr_shared_presentable_image))
4152 ? "VUID-VkBlitImageInfo2-srcImageLayout-01398"
4153 : "VUID-VkBlitImageInfo2-srcImageLayout-00222")
sfricke-samsung45996a42021-09-16 13:45:27 -07004154 : ((src_image_state->shared_presentable && IsExtEnabled(device_extensions.vk_khr_shared_presentable_image))
Jeff Leger178b1e52020-10-05 12:22:23 -04004155 ? "VUID-vkCmdBlitImage-srcImageLayout-01398"
4156 : "VUID-vkCmdBlitImage-srcImageLayout-00222");
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004157 const char *invalid_dst_layout_vuid =
Tony-LunarG542ae912021-11-04 16:06:44 -06004158 is_2 ? ((dst_image_state->shared_presentable && IsExtEnabled(device_extensions.vk_khr_shared_presentable_image))
4159 ? "VUID-VkBlitImageInfo2-dstImageLayout-01399"
4160 : "VUID-VkBlitImageInfo2-dstImageLayout-00227")
sfricke-samsung45996a42021-09-16 13:45:27 -07004161 : ((dst_image_state->shared_presentable && IsExtEnabled(device_extensions.vk_khr_shared_presentable_image))
Jeff Leger178b1e52020-10-05 12:22:23 -04004162 ? "VUID-vkCmdBlitImage-dstImageLayout-01399"
4163 : "VUID-vkCmdBlitImage-dstImageLayout-00227");
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07004164 for (uint32_t i = 0; i < regionCount; i++) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05004165 const RegionType region = pRegions[i];
Norbert Garnys7bd4c2c2017-11-16 10:58:04 +01004166 bool hit_error = false;
Tony-LunarG542ae912021-11-04 16:06:44 -06004167
4168 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcImageLayout-00221" : "VUID-vkCmdBlitImage-srcImageLayout-00221";
sfricke-samsung71f04e32022-03-16 01:21:21 -05004169 skip |= VerifyImageLayout(cb_node.get(), src_image_state.get(), region.srcSubresource, srcImageLayout,
Jeff Leger178b1e52020-10-05 12:22:23 -04004170 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, func_name, invalid_src_layout_vuid, vuid, &hit_error);
Tony-LunarG542ae912021-11-04 16:06:44 -06004171 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstImageLayout-00226" : "VUID-vkCmdBlitImage-dstImageLayout-00226";
sfricke-samsung71f04e32022-03-16 01:21:21 -05004172 skip |= VerifyImageLayout(cb_node.get(), dst_image_state.get(), region.dstSubresource, dstImageLayout,
Jeff Leger178b1e52020-10-05 12:22:23 -04004173 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, func_name, invalid_dst_layout_vuid, vuid, &hit_error);
sfricke-samsung71f04e32022-03-16 01:21:21 -05004174 skip |= ValidateImageSubresourceLayers(cb_node.get(), &region.srcSubresource, func_name, "srcSubresource", i);
4175 skip |= ValidateImageSubresourceLayers(cb_node.get(), &region.dstSubresource, func_name, "dstSubresource", i);
Tony-LunarG542ae912021-11-04 16:06:44 -06004176 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcSubresource-01705" : "VUID-vkCmdBlitImage-srcSubresource-01705";
sfricke-samsung71f04e32022-03-16 01:21:21 -05004177 skip |= ValidateImageMipLevel(cb_node.get(), src_image_state.get(), region.srcSubresource.mipLevel, i, func_name,
Jeremy Gebben9f537102021-10-05 16:37:12 -06004178 "srcSubresource", vuid);
Tony-LunarG542ae912021-11-04 16:06:44 -06004179 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstSubresource-01706" : "VUID-vkCmdBlitImage-dstSubresource-01706";
sfricke-samsung71f04e32022-03-16 01:21:21 -05004180 skip |= ValidateImageMipLevel(cb_node.get(), dst_image_state.get(), region.dstSubresource.mipLevel, i, func_name,
Jeremy Gebben9f537102021-10-05 16:37:12 -06004181 "dstSubresource", vuid);
Tony-LunarG542ae912021-11-04 16:06:44 -06004182 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcSubresource-01707" : "VUID-vkCmdBlitImage-srcSubresource-01707";
sfricke-samsung71f04e32022-03-16 01:21:21 -05004183 skip |= ValidateImageArrayLayerRange(cb_node.get(), src_image_state.get(), region.srcSubresource.baseArrayLayer,
4184 region.srcSubresource.layerCount, i, func_name, "srcSubresource", vuid);
Tony-LunarG542ae912021-11-04 16:06:44 -06004185 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstSubresource-01708" : "VUID-vkCmdBlitImage-dstSubresource-01708";
sfricke-samsung71f04e32022-03-16 01:21:21 -05004186 skip |= ValidateImageArrayLayerRange(cb_node.get(), dst_image_state.get(), region.dstSubresource.baseArrayLayer,
4187 region.dstSubresource.layerCount, i, func_name, "dstSubresource", vuid);
Mark Lobodzinski23c81142017-02-06 15:04:23 -07004188 // Warn for zero-sized regions
sfricke-samsung71f04e32022-03-16 01:21:21 -05004189 if ((region.srcOffsets[0].x == region.srcOffsets[1].x) || (region.srcOffsets[0].y == region.srcOffsets[1].y) ||
4190 (region.srcOffsets[0].z == region.srcOffsets[1].z)) {
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07004191 std::stringstream ss;
Jeff Leger178b1e52020-10-05 12:22:23 -04004192 ss << func_name << ": pRegions[" << i << "].srcOffsets specify a zero-volume area.";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004193 skip |= LogWarning(cb_node->commandBuffer(), kVUID_Core_DrawState_InvalidExtents, "%s", ss.str().c_str());
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07004194 }
sfricke-samsung71f04e32022-03-16 01:21:21 -05004195 if ((region.dstOffsets[0].x == region.dstOffsets[1].x) || (region.dstOffsets[0].y == region.dstOffsets[1].y) ||
4196 (region.dstOffsets[0].z == region.dstOffsets[1].z)) {
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07004197 std::stringstream ss;
Jeff Leger178b1e52020-10-05 12:22:23 -04004198 ss << func_name << ": pRegions[" << i << "].dstOffsets specify a zero-volume area.";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004199 skip |= LogWarning(cb_node->commandBuffer(), kVUID_Core_DrawState_InvalidExtents, "%s", ss.str().c_str());
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07004200 }
Mark Lobodzinski23c81142017-02-06 15:04:23 -07004201
4202 // Check that src/dst layercounts match
sfricke-samsung71f04e32022-03-16 01:21:21 -05004203 if (region.srcSubresource.layerCount != region.dstSubresource.layerCount) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004204 vuid = is_2 ? "VUID-VkImageBlit2-layerCount-00239" : "VUID-VkImageBlit-layerCount-00239";
Jeff Leger178b1e52020-10-05 12:22:23 -04004205 skip |=
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004206 LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004207 "%s: layerCount in source and destination subresource of pRegions[%d] does not match.", func_name, i);
Mark Lobodzinski23c81142017-02-06 15:04:23 -07004208 }
Mark Lobodzinskie7e85fd2017-02-07 13:44:57 -07004209
sfricke-samsung71f04e32022-03-16 01:21:21 -05004210 if (region.srcSubresource.aspectMask != region.dstSubresource.aspectMask) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004211 vuid = is_2 ? "VUID-VkImageBlit2-aspectMask-00238" : "VUID-VkImageBlit-aspectMask-00238";
Jeff Leger178b1e52020-10-05 12:22:23 -04004212 skip |=
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004213 LogError(cb_node->commandBuffer(), vuid, "%s: aspectMask members for pRegion[%d] do not match.", func_name, i);
Mark Lobodzinskie7e85fd2017-02-07 13:44:57 -07004214 }
Dave Houlton48989f32017-05-26 15:01:46 -06004215
sfricke-samsung71f04e32022-03-16 01:21:21 -05004216 if (!VerifyAspectsPresent(region.srcSubresource.aspectMask, src_format)) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004217 vuid = is_2 ? "VUID-VkBlitImageInfo2-aspectMask-00241" : "VUID-vkCmdBlitImage-aspectMask-00241";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004218 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004219 "%s: region [%d] source aspectMask (0x%x) specifies aspects not present in source "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004220 "image format %s.",
sfricke-samsung71f04e32022-03-16 01:21:21 -05004221 func_name, i, region.srcSubresource.aspectMask, string_VkFormat(src_format));
Dave Houlton33c2d252017-06-09 17:08:32 -06004222 }
4223
sfricke-samsung71f04e32022-03-16 01:21:21 -05004224 if (!VerifyAspectsPresent(region.dstSubresource.aspectMask, dst_format)) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004225 vuid = is_2 ? "VUID-VkBlitImageInfo2-aspectMask-00242" : "VUID-vkCmdBlitImage-aspectMask-00242";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004226 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004227 "%s: region [%d] dest aspectMask (0x%x) specifies aspects not present in dest image format %s.",
sfricke-samsung71f04e32022-03-16 01:21:21 -05004228 func_name, i, region.dstSubresource.aspectMask, string_VkFormat(dst_format));
Dave Houlton33c2d252017-06-09 17:08:32 -06004229 }
4230
Dave Houlton48989f32017-05-26 15:01:46 -06004231 // Validate source image offsets
sfricke-samsung71f04e32022-03-16 01:21:21 -05004232 VkExtent3D src_extent = src_image_state->GetSubresourceExtent(region.srcSubresource);
Dave Houlton33c2d252017-06-09 17:08:32 -06004233 if (VK_IMAGE_TYPE_1D == src_type) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05004234 if ((0 != region.srcOffsets[0].y) || (1 != region.srcOffsets[1].y)) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004235 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcImage-00245" : "VUID-vkCmdBlitImage-srcImage-00245";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004236 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004237 "%s: region [%d], source image of type VK_IMAGE_TYPE_1D with srcOffset[].y values "
4238 "of (%1d, %1d). These must be (0, 1).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05004239 func_name, i, region.srcOffsets[0].y, region.srcOffsets[1].y);
Dave Houlton48989f32017-05-26 15:01:46 -06004240 }
4241 }
4242
Dave Houlton33c2d252017-06-09 17:08:32 -06004243 if ((VK_IMAGE_TYPE_1D == src_type) || (VK_IMAGE_TYPE_2D == src_type)) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05004244 if ((0 != region.srcOffsets[0].z) || (1 != region.srcOffsets[1].z)) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004245 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcImage-00247" : "VUID-vkCmdBlitImage-srcImage-00247";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004246 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004247 "%s: region [%d], source image of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D with "
4248 "srcOffset[].z values of (%1d, %1d). These must be (0, 1).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05004249 func_name, i, region.srcOffsets[0].z, region.srcOffsets[1].z);
Dave Houlton48989f32017-05-26 15:01:46 -06004250 }
4251 }
4252
Dave Houlton33c2d252017-06-09 17:08:32 -06004253 bool oob = false;
sfricke-samsung71f04e32022-03-16 01:21:21 -05004254 if ((region.srcOffsets[0].x < 0) || (region.srcOffsets[0].x > static_cast<int32_t>(src_extent.width)) ||
4255 (region.srcOffsets[1].x < 0) || (region.srcOffsets[1].x > static_cast<int32_t>(src_extent.width))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06004256 oob = true;
Tony-LunarG542ae912021-11-04 16:06:44 -06004257 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcOffset-00243" : "VUID-vkCmdBlitImage-srcOffset-00243";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004258 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004259 "%s: region [%d] srcOffset[].x values (%1d, %1d) exceed srcSubresource width extent (%1d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05004260 func_name, i, region.srcOffsets[0].x, region.srcOffsets[1].x, src_extent.width);
Dave Houlton48989f32017-05-26 15:01:46 -06004261 }
sfricke-samsung71f04e32022-03-16 01:21:21 -05004262 if ((region.srcOffsets[0].y < 0) || (region.srcOffsets[0].y > static_cast<int32_t>(src_extent.height)) ||
4263 (region.srcOffsets[1].y < 0) || (region.srcOffsets[1].y > static_cast<int32_t>(src_extent.height))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06004264 oob = true;
Tony-LunarG542ae912021-11-04 16:06:44 -06004265 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcOffset-00244" : "VUID-vkCmdBlitImage-srcOffset-00244";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004266 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004267 "%s: region [%d] srcOffset[].y values (%1d, %1d) exceed srcSubresource height extent (%1d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05004268 func_name, i, region.srcOffsets[0].y, region.srcOffsets[1].y, src_extent.height);
Dave Houlton48989f32017-05-26 15:01:46 -06004269 }
sfricke-samsung71f04e32022-03-16 01:21:21 -05004270 if ((region.srcOffsets[0].z < 0) || (region.srcOffsets[0].z > static_cast<int32_t>(src_extent.depth)) ||
4271 (region.srcOffsets[1].z < 0) || (region.srcOffsets[1].z > static_cast<int32_t>(src_extent.depth))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06004272 oob = true;
Tony-LunarG542ae912021-11-04 16:06:44 -06004273 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcOffset-00246" : "VUID-vkCmdBlitImage-srcOffset-00246";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004274 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004275 "%s: region [%d] srcOffset[].z values (%1d, %1d) exceed srcSubresource depth extent (%1d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05004276 func_name, i, region.srcOffsets[0].z, region.srcOffsets[1].z, src_extent.depth);
Dave Houlton48989f32017-05-26 15:01:46 -06004277 }
Cort Strattonff1542a2018-05-27 10:49:28 -07004278 if (oob) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004279 vuid = is_2 ? "VUID-VkBlitImageInfo2-pRegions-00215" : "VUID-vkCmdBlitImage-pRegions-00215";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004280 skip |= LogError(cb_node->commandBuffer(), vuid, "%s: region [%d] source image blit region exceeds image dimensions.",
Jeff Leger178b1e52020-10-05 12:22:23 -04004281 func_name, i);
Dave Houlton33c2d252017-06-09 17:08:32 -06004282 }
Dave Houlton48989f32017-05-26 15:01:46 -06004283
4284 // Validate dest image offsets
sfricke-samsung71f04e32022-03-16 01:21:21 -05004285 VkExtent3D dst_extent = dst_image_state->GetSubresourceExtent(region.dstSubresource);
Dave Houlton33c2d252017-06-09 17:08:32 -06004286 if (VK_IMAGE_TYPE_1D == dst_type) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05004287 if ((0 != region.dstOffsets[0].y) || (1 != region.dstOffsets[1].y)) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004288 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstImage-00250" : "VUID-vkCmdBlitImage-dstImage-00250";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004289 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004290 "%s: region [%d], dest image of type VK_IMAGE_TYPE_1D with dstOffset[].y values of "
4291 "(%1d, %1d). These must be (0, 1).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05004292 func_name, i, region.dstOffsets[0].y, region.dstOffsets[1].y);
Dave Houlton48989f32017-05-26 15:01:46 -06004293 }
4294 }
4295
Dave Houlton33c2d252017-06-09 17:08:32 -06004296 if ((VK_IMAGE_TYPE_1D == dst_type) || (VK_IMAGE_TYPE_2D == dst_type)) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05004297 if ((0 != region.dstOffsets[0].z) || (1 != region.dstOffsets[1].z)) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004298 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstImage-00252" : "VUID-vkCmdBlitImage-dstImage-00252";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004299 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004300 "%s: region [%d], dest image of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D with "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004301 "dstOffset[].z values of (%1d, %1d). These must be (0, 1).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05004302 func_name, i, region.dstOffsets[0].z, region.dstOffsets[1].z);
Dave Houlton48989f32017-05-26 15:01:46 -06004303 }
4304 }
4305
Dave Houlton33c2d252017-06-09 17:08:32 -06004306 oob = false;
sfricke-samsung71f04e32022-03-16 01:21:21 -05004307 if ((region.dstOffsets[0].x < 0) || (region.dstOffsets[0].x > static_cast<int32_t>(dst_extent.width)) ||
4308 (region.dstOffsets[1].x < 0) || (region.dstOffsets[1].x > static_cast<int32_t>(dst_extent.width))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06004309 oob = true;
Tony-LunarG542ae912021-11-04 16:06:44 -06004310 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstOffset-00248" : "VUID-vkCmdBlitImage-dstOffset-00248";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004311 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004312 "%s: region [%d] dstOffset[].x values (%1d, %1d) exceed dstSubresource width extent (%1d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05004313 func_name, i, region.dstOffsets[0].x, region.dstOffsets[1].x, dst_extent.width);
Dave Houlton48989f32017-05-26 15:01:46 -06004314 }
sfricke-samsung71f04e32022-03-16 01:21:21 -05004315 if ((region.dstOffsets[0].y < 0) || (region.dstOffsets[0].y > static_cast<int32_t>(dst_extent.height)) ||
4316 (region.dstOffsets[1].y < 0) || (region.dstOffsets[1].y > static_cast<int32_t>(dst_extent.height))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06004317 oob = true;
Tony-LunarG542ae912021-11-04 16:06:44 -06004318 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstOffset-00249" : "VUID-vkCmdBlitImage-dstOffset-00249";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004319 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004320 "%s: region [%d] dstOffset[].y values (%1d, %1d) exceed dstSubresource height extent (%1d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05004321 func_name, i, region.dstOffsets[0].y, region.dstOffsets[1].y, dst_extent.height);
Dave Houlton48989f32017-05-26 15:01:46 -06004322 }
sfricke-samsung71f04e32022-03-16 01:21:21 -05004323 if ((region.dstOffsets[0].z < 0) || (region.dstOffsets[0].z > static_cast<int32_t>(dst_extent.depth)) ||
4324 (region.dstOffsets[1].z < 0) || (region.dstOffsets[1].z > static_cast<int32_t>(dst_extent.depth))) {
Dave Houlton33c2d252017-06-09 17:08:32 -06004325 oob = true;
Tony-LunarG542ae912021-11-04 16:06:44 -06004326 vuid = is_2 ? "VUID-VkBlitImageInfo2-dstOffset-00251" : "VUID-vkCmdBlitImage-dstOffset-00251";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004327 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004328 "%s: region [%d] dstOffset[].z values (%1d, %1d) exceed dstSubresource depth extent (%1d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05004329 func_name, i, region.dstOffsets[0].z, region.dstOffsets[1].z, dst_extent.depth);
Dave Houlton48989f32017-05-26 15:01:46 -06004330 }
Cort Strattonff1542a2018-05-27 10:49:28 -07004331 if (oob) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004332 vuid = is_2 ? "VUID-VkBlitImageInfo2-pRegions-00216" : "VUID-vkCmdBlitImage-pRegions-00216";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004333 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004334 "%s: region [%d] destination image blit region exceeds image dimensions.", func_name, i);
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07004335 }
4336
Dave Houlton33c2d252017-06-09 17:08:32 -06004337 if ((VK_IMAGE_TYPE_3D == src_type) || (VK_IMAGE_TYPE_3D == dst_type)) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05004338 if ((0 != region.srcSubresource.baseArrayLayer) || (1 != region.srcSubresource.layerCount) ||
4339 (0 != region.dstSubresource.baseArrayLayer) || (1 != region.dstSubresource.layerCount)) {
Tony-LunarG542ae912021-11-04 16:06:44 -06004340 vuid = is_2 ? "VUID-VkBlitImageInfo2-srcImage-00240" : "VUID-vkCmdBlitImage-srcImage-00240";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004341 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04004342 "%s: region [%d] blit to/from a 3D image type with a non-zero baseArrayLayer, or a "
4343 "layerCount other than 1.",
4344 func_name, i);
Mark Lobodzinski9ad96582017-02-06 14:01:54 -07004345 }
4346 }
aitor-lunarg607fe732022-03-31 22:00:08 +02004347
4348 // The union of all source regions, and the union of all destination regions, specified by the elements of regions,
4349 // must not overlap in memory
4350 if (srcImage == dstImage) {
4351 for (uint32_t j = 0; j < regionCount; j++) {
4352 if (RegionIntersectsBlit(&region, &pRegions[j], src_image_state->createInfo.imageType,
4353 FormatIsMultiplane(src_format))) {
4354 vuid = is_2 ? "VUID-VkBlitImageInfo2-pRegions-00217" : "VUID-vkCmdBlitImage-pRegions-00217";
4355 skip |= LogError(cb_node->commandBuffer(), vuid,
4356 "%s: pRegion[%" PRIu32 "] src overlaps with pRegions[%" PRIu32 "] dst.", func_name, i, j);
4357 }
4358 }
4359 }
Dave Houlton33c2d252017-06-09 17:08:32 -06004360 } // per-region checks
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07004361 } else {
4362 assert(0);
4363 }
4364 return skip;
4365}
4366
Jeff Leger178b1e52020-10-05 12:22:23 -04004367bool CoreChecks::PreCallValidateCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
4368 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
4369 const VkImageBlit *pRegions, VkFilter filter) const {
4370 return ValidateCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter,
Tony-LunarG542ae912021-11-04 16:06:44 -06004371 CMD_BLITIMAGE);
Jeff Leger178b1e52020-10-05 12:22:23 -04004372}
4373
4374bool CoreChecks::PreCallValidateCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo) const {
4375 return ValidateCmdBlitImage(commandBuffer, pBlitImageInfo->srcImage, pBlitImageInfo->srcImageLayout, pBlitImageInfo->dstImage,
4376 pBlitImageInfo->dstImageLayout, pBlitImageInfo->regionCount, pBlitImageInfo->pRegions,
Tony-LunarG542ae912021-11-04 16:06:44 -06004377 pBlitImageInfo->filter, CMD_BLITIMAGE2KHR);
4378}
4379
4380bool CoreChecks::PreCallValidateCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo) const {
4381 return ValidateCmdBlitImage(commandBuffer, pBlitImageInfo->srcImage, pBlitImageInfo->srcImageLayout, pBlitImageInfo->dstImage,
4382 pBlitImageInfo->dstImageLayout, pBlitImageInfo->regionCount, pBlitImageInfo->pRegions,
4383 pBlitImageInfo->filter, CMD_BLITIMAGE2);
Jeff Leger178b1e52020-10-05 12:22:23 -04004384}
4385
4386template <typename RegionType>
4387void CoreChecks::RecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
4388 VkImageLayout dstImageLayout, uint32_t regionCount, const RegionType *pRegions,
4389 VkFilter filter) {
Jeremy Gebben332d4dd2022-01-01 12:40:02 -07004390 auto cb_node = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06004391 auto src_image_state = Get<IMAGE_STATE>(srcImage);
4392 auto dst_image_state = Get<IMAGE_STATE>(dstImage);
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07004393
Norbert Garnys7bd4c2c2017-11-16 10:58:04 +01004394 // Make sure that all image slices are updated to correct layout
Mark Lobodzinski9a075c22019-01-10 14:30:39 -07004395 for (uint32_t i = 0; i < regionCount; ++i) {
Jeremy Gebben1ec89332021-08-05 13:51:49 -06004396 cb_node->SetImageInitialLayout(*src_image_state, pRegions[i].srcSubresource, srcImageLayout);
4397 cb_node->SetImageInitialLayout(*dst_image_state, pRegions[i].dstSubresource, dstImageLayout);
Norbert Garnys7bd4c2c2017-11-16 10:58:04 +01004398 }
Mark Lobodzinski8e0c0bf2017-02-06 11:06:26 -07004399}
4400
Jeff Leger178b1e52020-10-05 12:22:23 -04004401void CoreChecks::PreCallRecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
4402 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
4403 const VkImageBlit *pRegions, VkFilter filter) {
4404 StateTracker::PreCallRecordCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount,
4405 pRegions, filter);
4406 RecordCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
4407}
4408
4409void CoreChecks::PreCallRecordCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo) {
4410 StateTracker::PreCallRecordCmdBlitImage2KHR(commandBuffer, pBlitImageInfo);
4411 RecordCmdBlitImage(commandBuffer, pBlitImageInfo->srcImage, pBlitImageInfo->srcImageLayout, pBlitImageInfo->dstImage,
4412 pBlitImageInfo->dstImageLayout, pBlitImageInfo->regionCount, pBlitImageInfo->pRegions,
4413 pBlitImageInfo->filter);
4414}
4415
Tony-LunarG542ae912021-11-04 16:06:44 -06004416void CoreChecks::PreCallRecordCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo) {
4417 StateTracker::PreCallRecordCmdBlitImage2(commandBuffer, pBlitImageInfo);
4418 RecordCmdBlitImage(commandBuffer, pBlitImageInfo->srcImage, pBlitImageInfo->srcImageLayout, pBlitImageInfo->dstImage,
4419 pBlitImageInfo->dstImageLayout, pBlitImageInfo->regionCount, pBlitImageInfo->pRegions,
4420 pBlitImageInfo->filter);
4421}
4422
Jeremy Gebbenb6c18132021-03-17 17:00:20 -06004423GlobalImageLayoutRangeMap *GetLayoutRangeMap(GlobalImageLayoutMap &map, const IMAGE_STATE &image_state) {
John Zulauf2076e812020-01-08 14:55:54 -07004424 // This approach allows for a single hash lookup or/create new
Jeremy Gebben6335df62021-11-01 10:50:13 -06004425 auto &layout_map = map[&image_state];
John Zulauf17708d02021-02-22 11:20:58 -07004426 if (!layout_map) {
4427 layout_map.emplace(image_state.subresource_encoder.SubresourceCount());
John Zulauf2076e812020-01-08 14:55:54 -07004428 }
John Zulauf17708d02021-02-22 11:20:58 -07004429 return &layout_map;
John Zulauf2076e812020-01-08 14:55:54 -07004430}
4431
Jeremy Gebben6335df62021-11-01 10:50:13 -06004432const GlobalImageLayoutRangeMap *GetLayoutRangeMap(const GlobalImageLayoutMap &map, const IMAGE_STATE &image_state) {
4433 auto it = map.find(&image_state);
John Zulauf2076e812020-01-08 14:55:54 -07004434 if (it != map.end()) {
John Zulauf17708d02021-02-22 11:20:58 -07004435 return &it->second;
John Zulauf2076e812020-01-08 14:55:54 -07004436 }
4437 return nullptr;
4438}
4439
Jeremy Gebben53631302021-04-13 16:46:37 -06004440// Helper to update the Global or Overlay layout map
4441struct GlobalLayoutUpdater {
4442 bool update(VkImageLayout &dst, const image_layout_map::ImageSubresourceLayoutMap::LayoutEntry &src) const {
4443 if (src.current_layout != image_layout_map::kInvalidLayout && dst != src.current_layout) {
4444 dst = src.current_layout;
4445 return true;
4446 }
4447 return false;
4448 }
4449
4450 layer_data::optional<VkImageLayout> insert(const image_layout_map::ImageSubresourceLayoutMap::LayoutEntry &src) const {
4451 layer_data::optional<VkImageLayout> result;
4452 if (src.current_layout != image_layout_map::kInvalidLayout) {
4453 result.emplace(src.current_layout);
4454 }
4455 return result;
4456 }
4457};
4458
Shannon McPherson449fa9c2018-10-25 11:51:07 -06004459// This validates that the initial layout specified in the command buffer for the IMAGE is the same as the global IMAGE layout
sfricke-samsung6b447aa2021-07-26 09:42:26 -07004460bool CoreChecks::ValidateCmdBufImageLayouts(const Location &loc, const CMD_BUFFER_STATE *pCB,
Jeremy Gebbenb6c18132021-03-17 17:00:20 -06004461 GlobalImageLayoutMap &overlayLayoutMap) const {
Mark Lobodzinski90eea5b2020-05-15 12:54:00 -06004462 if (disabled[image_layout_validation]) return false;
Mark Lobodzinskib0dd9472017-02-07 16:38:17 -07004463 bool skip = false;
John Zulauff660ad62019-03-23 07:16:05 -06004464 // Iterate over the layout maps for each referenced image
John Zulauf2076e812020-01-08 14:55:54 -07004465 GlobalImageLayoutRangeMap empty_map(1);
John Zulauff660ad62019-03-23 07:16:05 -06004466 for (const auto &layout_map_entry : pCB->image_layout_map) {
Jeremy Gebben6335df62021-11-01 10:50:13 -06004467 const auto *image_state = layout_map_entry.first;
unknown089cdb82019-07-11 12:58:43 -06004468 const auto &subres_map = layout_map_entry.second;
Jeremy Gebben53631302021-04-13 16:46:37 -06004469 const auto &layout_map = subres_map->GetLayoutMap();
John Zulauff660ad62019-03-23 07:16:05 -06004470 // Validate the initial_uses for each subresource referenced
Jeremy Gebben53631302021-04-13 16:46:37 -06004471 if (layout_map.empty()) continue;
John Zulauf2076e812020-01-08 14:55:54 -07004472
Jeremy Gebbenb6c18132021-03-17 17:00:20 -06004473 auto *overlay_map = GetLayoutRangeMap(overlayLayoutMap, *image_state);
Jeremy Gebben4a8881f2022-01-10 17:04:30 -07004474 const auto *global_map = image_state->layout_range_map.get();
4475 assert(global_map);
4476 auto global_map_guard = global_map->ReadLock();
John Zulauf2076e812020-01-08 14:55:54 -07004477
4478 // Note: don't know if it would matter
4479 // if (global_map->empty() && overlay_map->empty()) // skip this next loop...;
4480
Jeremy Gebben53631302021-04-13 16:46:37 -06004481 auto pos = layout_map.begin();
4482 const auto end = layout_map.end();
4483 sparse_container::parallel_iterator<const GlobalImageLayoutRangeMap> current_layout(*overlay_map, *global_map,
4484 pos->first.begin);
John Zulauf2076e812020-01-08 14:55:54 -07004485 while (pos != end) {
Jeremy Gebben53631302021-04-13 16:46:37 -06004486 VkImageLayout initial_layout = pos->second.initial_layout;
4487 assert(initial_layout != image_layout_map::kInvalidLayout);
4488 if (initial_layout == image_layout_map::kInvalidLayout) {
4489 continue;
4490 }
4491
John Zulauf2076e812020-01-08 14:55:54 -07004492 VkImageLayout image_layout = kInvalidLayout;
Jeremy Gebben53631302021-04-13 16:46:37 -06004493
John Zulauf2076e812020-01-08 14:55:54 -07004494 if (current_layout->range.empty()) break; // When we are past the end of data in overlay and global... stop looking
locke-lunargf155ccf2020-02-18 11:34:15 -07004495 if (current_layout->pos_A->valid) { // pos_A denotes the overlay map in the parallel iterator
John Zulauf2076e812020-01-08 14:55:54 -07004496 image_layout = current_layout->pos_A->lower_bound->second;
locke-lunargf155ccf2020-02-18 11:34:15 -07004497 } else if (current_layout->pos_B->valid) { // pos_B denotes the global map in the parallel iterator
John Zulauf2076e812020-01-08 14:55:54 -07004498 image_layout = current_layout->pos_B->lower_bound->second;
4499 }
4500 const auto intersected_range = pos->first & current_layout->range;
4501 if (initial_layout == VK_IMAGE_LAYOUT_UNDEFINED) {
4502 // TODO: Set memory invalid which is in mem_tracker currently
4503 } else if (image_layout != initial_layout) {
Hans-Kristian Arntzen6cb03492021-07-05 16:57:31 +02004504 const auto aspect_mask = image_state->subresource_encoder.Decode(intersected_range.begin).aspectMask;
4505 bool matches = ImageLayoutMatches(aspect_mask, image_layout, initial_layout);
John Zulauf2076e812020-01-08 14:55:54 -07004506 if (!matches) {
John Zulauf2076e812020-01-08 14:55:54 -07004507 // We can report all the errors for the intersected range directly
4508 for (auto index : sparse_container::range_view<decltype(intersected_range)>(intersected_range)) {
locke-lunarg296a3c92020-03-25 01:04:29 -06004509 const auto subresource = image_state->subresource_encoder.Decode(index);
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004510 skip |= LogError(
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004511 pCB->commandBuffer(), kVUID_Core_DrawState_InvalidImageLayout,
sfricke-samsung6b447aa2021-07-26 09:42:26 -07004512 "%s command buffer %s expects %s (subresource: aspectMask 0x%X array layer %u, mip level %u) "
Mark Lobodzinski23e395e2020-04-09 10:17:31 -06004513 "to be in layout %s--instead, current layout is %s.",
sfricke-samsung6b447aa2021-07-26 09:42:26 -07004514 loc.Message().c_str(), report_data->FormatHandle(pCB->commandBuffer()).c_str(),
Jeremy Gebben6335df62021-11-01 10:50:13 -06004515 report_data->FormatHandle(image_state->Handle()).c_str(), subresource.aspectMask, subresource.arrayLayer,
Mark Lobodzinski23e395e2020-04-09 10:17:31 -06004516 subresource.mipLevel, string_VkImageLayout(initial_layout), string_VkImageLayout(image_layout));
John Zulaufb61ed972019-04-09 16:12:35 -06004517 }
Mark Lobodzinski4a3065e2017-02-07 16:36:03 -07004518 }
4519 }
John Zulauf2076e812020-01-08 14:55:54 -07004520 if (pos->first.includes(intersected_range.end)) {
4521 current_layout.seek(intersected_range.end);
4522 } else {
4523 ++pos;
4524 if (pos != end) {
4525 current_layout.seek(pos->first.begin);
4526 }
4527 }
John Zulauff660ad62019-03-23 07:16:05 -06004528 }
locke-lunargf155ccf2020-02-18 11:34:15 -07004529 // Update all layout set operations (which will be a subset of the initial_layouts)
Jeremy Gebben53631302021-04-13 16:46:37 -06004530 sparse_container::splice(*overlay_map, subres_map->GetLayoutMap(), GlobalLayoutUpdater());
Mark Lobodzinski4a3065e2017-02-07 16:36:03 -07004531 }
John Zulauff660ad62019-03-23 07:16:05 -06004532
Mark Lobodzinskib0dd9472017-02-07 16:38:17 -07004533 return skip;
Mark Lobodzinski4a3065e2017-02-07 16:36:03 -07004534}
Mark Lobodzinskib3829a52017-02-07 16:55:53 -07004535
Mark Lobodzinski33a34b82019-04-25 11:38:36 -06004536void CoreChecks::UpdateCmdBufImageLayouts(CMD_BUFFER_STATE *pCB) {
John Zulauff660ad62019-03-23 07:16:05 -06004537 for (const auto &layout_map_entry : pCB->image_layout_map) {
Jeremy Gebben6335df62021-11-01 10:50:13 -06004538 const auto *image_state = layout_map_entry.first;
John Zulauf2076e812020-01-08 14:55:54 -07004539 const auto &subres_map = layout_map_entry.second;
Jeremy Gebben4a8881f2022-01-10 17:04:30 -07004540 auto guard = image_state->layout_range_map->WriteLock();
4541 sparse_container::splice(*image_state->layout_range_map, subres_map->GetLayoutMap(), GlobalLayoutUpdater());
Tony Barbourdf013b92017-01-25 12:53:48 -07004542 }
4543}
4544
Mark Lobodzinskic679b032017-02-07 17:11:55 -07004545// ValidateLayoutVsAttachmentDescription is a general function where we can validate various state associated with the
Mark Lobodzinski552e4402017-02-07 17:14:53 -07004546// VkAttachmentDescription structs that are used by the sub-passes of a renderpass. Initial check is to make sure that READ_ONLY
4547// layout attachments don't have CLEAR as their loadOp.
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004548bool CoreChecks::ValidateLayoutVsAttachmentDescription(const debug_report_data *report_data, RenderPassCreateVersion rp_version,
4549 const VkImageLayout first_layout, const uint32_t attachment,
Mike Schuchardt2df08912020-12-15 16:28:09 -08004550 const VkAttachmentDescription2 &attachment_description) const {
Mark Lobodzinski552e4402017-02-07 17:14:53 -07004551 bool skip = false;
Tobias Hectorbbb12282018-10-22 15:17:59 +01004552 const bool use_rp2 = (rp_version == RENDER_PASS_VERSION_2);
4553
Mark Lobodzinskic679b032017-02-07 17:11:55 -07004554 // Verify that initial loadOp on READ_ONLY attachments is not CLEAR
sfricke-samsung55f01952020-03-24 08:16:41 -07004555 // for both loadOp and stencilLoaOp rp2 has it in 1 VU while rp1 has it in 2 VU with half behind Maintenance2 extension
4556 // Each is VUID is below in following order: rp2 -> rp1 with Maintenance2 -> rp1 with no extenstion
Mark Lobodzinskic679b032017-02-07 17:11:55 -07004557 if (attachment_description.loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) {
Shannon McPherson3ea65132018-12-05 10:37:39 -07004558 if (use_rp2 && ((first_layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL) ||
4559 (first_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) ||
4560 (first_layout == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL))) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004561 skip |= LogError(device, "VUID-VkRenderPassCreateInfo2-pAttachments-02522",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004562 "vkCreateRenderPass2(): Cannot clear attachment %d with invalid first layout %s.", attachment,
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004563 string_VkImageLayout(first_layout));
sfricke-samsung45996a42021-09-16 13:45:27 -07004564 } else if ((use_rp2 == false) && IsExtEnabled(device_extensions.vk_khr_maintenance2) &&
sfricke-samsung55f01952020-03-24 08:16:41 -07004565 (first_layout == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)) {
4566 skip |= LogError(device, "VUID-VkRenderPassCreateInfo-pAttachments-01566",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004567 "vkCreateRenderPass(): Cannot clear attachment %d with invalid first layout %s.", attachment,
sfricke-samsung55f01952020-03-24 08:16:41 -07004568 string_VkImageLayout(first_layout));
4569 } else if ((use_rp2 == false) && ((first_layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL) ||
4570 (first_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL))) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004571 skip |= LogError(device, "VUID-VkRenderPassCreateInfo-pAttachments-00836",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004572 "vkCreateRenderPass(): Cannot clear attachment %d with invalid first layout %s.", attachment,
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004573 string_VkImageLayout(first_layout));
Mark Lobodzinskic679b032017-02-07 17:11:55 -07004574 }
4575 }
sfricke-samsung55f01952020-03-24 08:16:41 -07004576
4577 // Same as above for loadOp, but for stencilLoadOp
4578 if (attachment_description.stencilLoadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) {
4579 if (use_rp2 && ((first_layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL) ||
4580 (first_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) ||
4581 (first_layout == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL))) {
4582 skip |= LogError(device, "VUID-VkRenderPassCreateInfo2-pAttachments-02523",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004583 "vkCreateRenderPass2(): Cannot clear attachment %d with invalid first layout %s.", attachment,
sfricke-samsung55f01952020-03-24 08:16:41 -07004584 string_VkImageLayout(first_layout));
sfricke-samsung45996a42021-09-16 13:45:27 -07004585 } else if ((use_rp2 == false) && IsExtEnabled(device_extensions.vk_khr_maintenance2) &&
sfricke-samsung55f01952020-03-24 08:16:41 -07004586 (first_layout == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)) {
4587 skip |= LogError(device, "VUID-VkRenderPassCreateInfo-pAttachments-01567",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004588 "vkCreateRenderPass(): Cannot clear attachment %d with invalid first layout %s.", attachment,
sfricke-samsung55f01952020-03-24 08:16:41 -07004589 string_VkImageLayout(first_layout));
4590 } else if ((use_rp2 == false) && ((first_layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL) ||
4591 (first_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL))) {
4592 skip |= LogError(device, "VUID-VkRenderPassCreateInfo-pAttachments-02511",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004593 "vkCreateRenderPass(): Cannot clear attachment %d with invalid first layout %s.", attachment,
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004594 string_VkImageLayout(first_layout));
Slawomir Cyganadf2b552018-04-24 17:18:26 +02004595 }
4596 }
4597
Mark Lobodzinski552e4402017-02-07 17:14:53 -07004598 return skip;
Mark Lobodzinskic679b032017-02-07 17:11:55 -07004599}
4600
Mark Lobodzinski96210742017-02-09 10:33:46 -07004601// Helper function to validate correct usage bits set for buffers or images. Verify that (actual & desired) flags != 0 or, if strict
4602// is true, verify that (actual & desired) flags == desired
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004603template <typename T1>
4604bool CoreChecks::ValidateUsageFlags(VkFlags actual, VkFlags desired, VkBool32 strict, const T1 object,
4605 const VulkanTypedHandle &typed_handle, const char *msgCode, char const *func_name,
4606 char const *usage_str) const {
Mark Lobodzinski96210742017-02-09 10:33:46 -07004607 bool correct_usage = false;
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07004608 bool skip = false;
John Zulauf4fea6622019-04-01 11:38:18 -06004609 const char *type_str = object_string[typed_handle.type];
Mark Lobodzinski96210742017-02-09 10:33:46 -07004610 if (strict) {
4611 correct_usage = ((actual & desired) == desired);
4612 } else {
4613 correct_usage = ((actual & desired) != 0);
4614 }
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004615
Mark Lobodzinski96210742017-02-09 10:33:46 -07004616 if (!correct_usage) {
sfricke-samsungbb971942020-09-10 22:11:56 -07004617 // All callers should have a valid VUID
4618 assert(msgCode != kVUIDUndefined);
4619 skip =
4620 LogError(object, msgCode, "Invalid usage flag for %s used by %s. In this case, %s should have %s set during creation.",
4621 report_data->FormatHandle(typed_handle).c_str(), func_name, type_str, usage_str);
Mark Lobodzinski96210742017-02-09 10:33:46 -07004622 }
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07004623 return skip;
Mark Lobodzinski96210742017-02-09 10:33:46 -07004624}
4625
4626// Helper function to validate usage flags for buffers. For given buffer_state send actual vs. desired usage off to helper above
4627// where an error will be flagged if usage is not correct
Mark Lobodzinskifbeb0ca2019-03-09 11:48:22 -07004628bool CoreChecks::ValidateImageUsageFlags(IMAGE_STATE const *image_state, VkFlags desired, bool strict, const char *msgCode,
John Zulaufe2b7bcb2019-07-05 16:08:39 -06004629 char const *func_name, char const *usage_string) const {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004630 return ValidateUsageFlags(image_state->createInfo.usage, desired, strict, image_state->image(),
Jeremy Gebben9efe1cf2021-05-15 20:05:09 -06004631 image_state->Handle(), msgCode, func_name, usage_string);
Mark Lobodzinski96210742017-02-09 10:33:46 -07004632}
4633
Lionel Landwerlin21719f62021-12-09 11:40:09 +02004634bool CoreChecks::ValidateImageFormatFeatureFlags(IMAGE_STATE const *image_state, VkFormatFeatureFlags2KHR desired,
Spencer Fricke6bba8c72020-04-06 07:41:21 -07004635 char const *func_name, const char *vuid) const {
Cort Stratton186b1a22018-05-01 20:18:06 -04004636 bool skip = false;
Lionel Landwerlin21719f62021-12-09 11:40:09 +02004637 const VkFormatFeatureFlags2KHR image_format_features = image_state->format_features;
Spencer Fricke6bba8c72020-04-06 07:41:21 -07004638 if ((image_format_features & desired) != desired) {
4639 // Same error, but more details if it was an AHB external format
Jeremy Gebbenb4d17012021-07-08 13:18:15 -06004640 if (image_state->HasAHBFormat()) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004641 skip |= LogError(image_state->image(), vuid,
Lionel Landwerlin21719f62021-12-09 11:40:09 +02004642 "In %s, VkFormatFeatureFlags (0x%" PRIxLEAST64 ") does not support required feature %s for the external format "
Spencer Fricke6bba8c72020-04-06 07:41:21 -07004643 "found in VkAndroidHardwareBufferFormatPropertiesANDROID::formatFeatures used by %s.",
Lionel Landwerlin21719f62021-12-09 11:40:09 +02004644 func_name, image_format_features, string_VkFormatFeatureFlags2KHR(desired).c_str(),
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004645 report_data->FormatHandle(image_state->image()).c_str());
Spencer Fricke6bba8c72020-04-06 07:41:21 -07004646 } else {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004647 skip |= LogError(image_state->image(), vuid,
Lionel Landwerlin21719f62021-12-09 11:40:09 +02004648 "In %s, VkFormatFeatureFlags (0x%" PRIxLEAST64 ") does not support required feature %s for format %u used by %s "
Spencer Fricke6bba8c72020-04-06 07:41:21 -07004649 "with tiling %s.",
Lionel Landwerlin21719f62021-12-09 11:40:09 +02004650 func_name, image_format_features, string_VkFormatFeatureFlags2KHR(desired).c_str(),
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004651 image_state->createInfo.format, report_data->FormatHandle(image_state->image()).c_str(),
Spencer Fricke6bba8c72020-04-06 07:41:21 -07004652 string_VkImageTiling(image_state->createInfo.tiling));
Cort Stratton186b1a22018-05-01 20:18:06 -04004653 }
4654 }
4655 return skip;
4656}
4657
Mark Lobodzinski33a34b82019-04-25 11:38:36 -06004658bool CoreChecks::ValidateImageSubresourceLayers(const CMD_BUFFER_STATE *cb_node, const VkImageSubresourceLayers *subresource_layers,
John Zulaufe2b7bcb2019-07-05 16:08:39 -06004659 char const *func_name, char const *member, uint32_t i) const {
Cort Strattond619a302018-05-17 19:46:32 -07004660 bool skip = false;
sfricke-samsungfdf91c82020-10-26 03:31:28 -07004661 const VkImageAspectFlags apsect_mask = subresource_layers->aspectMask;
Cort Strattond619a302018-05-17 19:46:32 -07004662 // layerCount must not be zero
4663 if (subresource_layers->layerCount == 0) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004664 skip |= LogError(cb_node->commandBuffer(), "VUID-VkImageSubresourceLayers-layerCount-01700",
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004665 "In %s, pRegions[%u].%s.layerCount must not be zero.", func_name, i, member);
Cort Strattond619a302018-05-17 19:46:32 -07004666 }
4667 // aspectMask must not contain VK_IMAGE_ASPECT_METADATA_BIT
sfricke-samsungfdf91c82020-10-26 03:31:28 -07004668 if (apsect_mask & VK_IMAGE_ASPECT_METADATA_BIT) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004669 skip |= LogError(cb_node->commandBuffer(), "VUID-VkImageSubresourceLayers-aspectMask-00168",
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004670 "In %s, pRegions[%u].%s.aspectMask has VK_IMAGE_ASPECT_METADATA_BIT set.", func_name, i, member);
Cort Strattond619a302018-05-17 19:46:32 -07004671 }
4672 // if aspectMask contains COLOR, it must not contain either DEPTH or STENCIL
sfricke-samsungfdf91c82020-10-26 03:31:28 -07004673 if ((apsect_mask & VK_IMAGE_ASPECT_COLOR_BIT) && (apsect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004674 skip |= LogError(cb_node->commandBuffer(), "VUID-VkImageSubresourceLayers-aspectMask-00167",
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004675 "In %s, pRegions[%u].%s.aspectMask has VK_IMAGE_ASPECT_COLOR_BIT and either VK_IMAGE_ASPECT_DEPTH_BIT or "
4676 "VK_IMAGE_ASPECT_STENCIL_BIT set.",
4677 func_name, i, member);
Cort Strattond619a302018-05-17 19:46:32 -07004678 }
sfricke-samsungfdf91c82020-10-26 03:31:28 -07004679 // aspectMask must not contain VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT
4680 if (apsect_mask & (VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT | VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT |
4681 VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT | VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004682 skip |= LogError(cb_node->commandBuffer(), "VUID-VkImageSubresourceLayers-aspectMask-02247",
sfricke-samsungfdf91c82020-10-26 03:31:28 -07004683 "In %s, pRegions[%u].%s.aspectMask has a VK_IMAGE_ASPECT_MEMORY_PLANE_*_BIT_EXT bit set.", func_name, i,
4684 member);
4685 }
Cort Strattond619a302018-05-17 19:46:32 -07004686 return skip;
4687}
4688
Mark Lobodzinski96210742017-02-09 10:33:46 -07004689// Helper function to validate usage flags for buffers. For given buffer_state send actual vs. desired usage off to helper above
4690// where an error will be flagged if usage is not correct
Mark Lobodzinskifbeb0ca2019-03-09 11:48:22 -07004691bool CoreChecks::ValidateBufferUsageFlags(BUFFER_STATE const *buffer_state, VkFlags desired, bool strict, const char *msgCode,
John Zulauf005c5012019-07-10 17:15:47 -06004692 char const *func_name, char const *usage_string) const {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004693 return ValidateUsageFlags(buffer_state->createInfo.usage, desired, strict, buffer_state->buffer(),
Jeremy Gebben9efe1cf2021-05-15 20:05:09 -06004694 buffer_state->Handle(), msgCode, func_name, usage_string);
Mark Lobodzinski96210742017-02-09 10:33:46 -07004695}
4696
Mark Lobodzinskifbeb0ca2019-03-09 11:48:22 -07004697bool CoreChecks::ValidateBufferViewRange(const BUFFER_STATE *buffer_state, const VkBufferViewCreateInfo *pCreateInfo,
Jeff Bolz46c0ea02019-10-09 13:06:29 -05004698 const VkPhysicalDeviceLimits *device_limits) const {
Shannon McPherson4c9505b2018-06-19 15:18:55 -06004699 bool skip = false;
Shannon McPherson4c9505b2018-06-19 15:18:55 -06004700
4701 const VkDeviceSize &range = pCreateInfo->range;
4702 if (range != VK_WHOLE_SIZE) {
4703 // Range must be greater than 0
4704 if (range <= 0) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004705 skip |= LogError(buffer_state->buffer(), "VUID-VkBufferViewCreateInfo-range-00928",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004706 "vkCreateBufferView(): If VkBufferViewCreateInfo range (%" PRIuLEAST64
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004707 ") does not equal VK_WHOLE_SIZE, range must be greater than 0.",
4708 range);
Shannon McPherson4c9505b2018-06-19 15:18:55 -06004709 }
4710 // Range must be a multiple of the element size of format
Petr Kraus5a01b472019-08-10 01:40:28 +02004711 const uint32_t format_size = FormatElementSize(pCreateInfo->format);
4712 if (SafeModulo(range, format_size) != 0) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004713 skip |= LogError(buffer_state->buffer(), "VUID-VkBufferViewCreateInfo-range-00929",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004714 "vkCreateBufferView(): If VkBufferViewCreateInfo range (%" PRIuLEAST64
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004715 ") does not equal VK_WHOLE_SIZE, range must be a multiple of the element size of the format "
4716 "(%" PRIu32 ").",
4717 range, format_size);
Shannon McPherson4c9505b2018-06-19 15:18:55 -06004718 }
4719 // Range divided by the element size of format must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements
Petr Kraus5a01b472019-08-10 01:40:28 +02004720 if (SafeDivision(range, format_size) > device_limits->maxTexelBufferElements) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004721 skip |= LogError(buffer_state->buffer(), "VUID-VkBufferViewCreateInfo-range-00930",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004722 "vkCreateBufferView(): If VkBufferViewCreateInfo range (%" PRIuLEAST64
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004723 ") does not equal VK_WHOLE_SIZE, range divided by the element size of the format (%" PRIu32
4724 ") must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements (%" PRIuLEAST32 ").",
4725 range, format_size, device_limits->maxTexelBufferElements);
Shannon McPherson4c9505b2018-06-19 15:18:55 -06004726 }
4727 // The sum of range and offset must be less than or equal to the size of buffer
4728 if (range + pCreateInfo->offset > buffer_state->createInfo.size) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004729 skip |= LogError(buffer_state->buffer(), "VUID-VkBufferViewCreateInfo-offset-00931",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004730 "vkCreateBufferView(): If VkBufferViewCreateInfo range (%" PRIuLEAST64
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004731 ") does not equal VK_WHOLE_SIZE, the sum of offset (%" PRIuLEAST64
4732 ") and range must be less than or equal to the size of the buffer (%" PRIuLEAST64 ").",
4733 range, pCreateInfo->offset, buffer_state->createInfo.size);
Shannon McPherson4c9505b2018-06-19 15:18:55 -06004734 }
janharaldfredriksen-armde71d202020-07-08 12:11:53 +02004735 } else {
4736 const uint32_t format_size = FormatElementSize(pCreateInfo->format);
4737
4738 // Size of buffer - offset, divided by the element size of format must be less than or equal to
4739 // VkPhysicalDeviceLimits::maxTexelBufferElements
4740 if (SafeDivision(buffer_state->createInfo.size - pCreateInfo->offset, format_size) >
4741 device_limits->maxTexelBufferElements) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004742 skip |= LogError(buffer_state->buffer(), "VUID-VkBufferViewCreateInfo-range-04059",
janharaldfredriksen-armde71d202020-07-08 12:11:53 +02004743 "vkCreateBufferView(): If VkBufferViewCreateInfo range (%" PRIuLEAST64
4744 ") equals VK_WHOLE_SIZE, the buffer's size (%" PRIuLEAST64 ") minus the offset (%" PRIuLEAST64
4745 "), divided by the element size of the format (%" PRIu32
4746 ") must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements (%" PRIuLEAST32 ").",
4747 range, buffer_state->createInfo.size, pCreateInfo->offset, format_size,
4748 device_limits->maxTexelBufferElements);
4749 }
Shannon McPherson4c9505b2018-06-19 15:18:55 -06004750 }
4751 return skip;
4752}
4753
Jeff Bolz46c0ea02019-10-09 13:06:29 -05004754bool CoreChecks::ValidateBufferViewBuffer(const BUFFER_STATE *buffer_state, const VkBufferViewCreateInfo *pCreateInfo) const {
Shannon McPherson265383a2018-06-21 15:37:52 -06004755 bool skip = false;
Lionel Landwerlin21719f62021-12-09 11:40:09 +02004756 const VkFormatProperties3KHR format_properties = GetPDFormatProperties(pCreateInfo->format);
Shannon McPherson265383a2018-06-21 15:37:52 -06004757 if ((buffer_state->createInfo.usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) &&
Lionel Landwerlin21719f62021-12-09 11:40:09 +02004758 !(format_properties.bufferFeatures & VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004759 skip |= LogError(buffer_state->buffer(), "VUID-VkBufferViewCreateInfo-buffer-00933",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004760 "vkCreateBufferView(): If buffer was created with `usage` containing "
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08004761 "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, format (%s) must "
4762 "be supported for uniform texel buffers",
4763 string_VkFormat(pCreateInfo->format));
Shannon McPherson265383a2018-06-21 15:37:52 -06004764 }
4765 if ((buffer_state->createInfo.usage & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT) &&
Lionel Landwerlin21719f62021-12-09 11:40:09 +02004766 !(format_properties.bufferFeatures & VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004767 skip |= LogError(buffer_state->buffer(), "VUID-VkBufferViewCreateInfo-buffer-00934",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004768 "vkCreateBufferView(): If buffer was created with `usage` containing "
sfricke-samsungf3a9b5b2021-01-13 13:05:52 -08004769 "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, format (%s) must "
4770 "be supported for storage texel buffers",
4771 string_VkFormat(pCreateInfo->format));
Shannon McPherson265383a2018-06-21 15:37:52 -06004772 }
4773 return skip;
4774}
4775
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004776bool CoreChecks::PreCallValidateCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
Jeff Bolz5c801d12019-10-09 10:38:45 -05004777 const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) const {
Mark Lobodzinski96210742017-02-09 10:33:46 -07004778 bool skip = false;
Mark Lobodzinski847b60c2017-03-13 09:32:45 -06004779
Dave Houltond8ed0212018-05-16 17:18:24 -06004780 // TODO: Add check for "VUID-vkCreateBuffer-flags-00911" (sparse address space accounting)
Mark Lobodzinski847b60c2017-03-13 09:32:45 -06004781
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07004782 auto chained_devaddr_struct = LvlFindInChain<VkBufferDeviceAddressCreateInfoEXT>(pCreateInfo->pNext);
Jeff Bolz87697532019-01-11 22:54:00 -06004783 if (chained_devaddr_struct) {
Mike Schuchardt2df08912020-12-15 16:28:09 -08004784 if (!(pCreateInfo->flags & VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT) &&
Jeff Bolz87697532019-01-11 22:54:00 -06004785 chained_devaddr_struct->deviceAddress != 0) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004786 skip |= LogError(device, "VUID-VkBufferCreateInfo-deviceAddress-02604",
4787 "vkCreateBuffer(): Non-zero VkBufferDeviceAddressCreateInfoEXT::deviceAddress "
Mike Schuchardt2df08912020-12-15 16:28:09 -08004788 "requires VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT.");
Jeff Bolz87697532019-01-11 22:54:00 -06004789 }
4790 }
4791
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07004792 auto chained_opaqueaddr_struct = LvlFindInChain<VkBufferOpaqueCaptureAddressCreateInfo>(pCreateInfo->pNext);
Jeff Bolz4563f2a2019-12-10 13:30:30 -06004793 if (chained_opaqueaddr_struct) {
Mike Schuchardt2df08912020-12-15 16:28:09 -08004794 if (!(pCreateInfo->flags & VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT) &&
Jeff Bolz4563f2a2019-12-10 13:30:30 -06004795 chained_opaqueaddr_struct->opaqueCaptureAddress != 0) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004796 skip |= LogError(device, "VUID-VkBufferCreateInfo-opaqueCaptureAddress-03337",
Mike Schuchardt2df08912020-12-15 16:28:09 -08004797 "vkCreateBuffer(): Non-zero VkBufferOpaqueCaptureAddressCreateInfo::opaqueCaptureAddress"
4798 "requires VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT.");
Jeff Bolz4563f2a2019-12-10 13:30:30 -06004799 }
4800 }
4801
ziga-lunarg2e2be1e2021-07-18 23:09:15 +02004802 auto dedicated_allocation_buffer = LvlFindInChain<VkDedicatedAllocationBufferCreateInfoNV>(pCreateInfo->pNext);
4803 if (dedicated_allocation_buffer && dedicated_allocation_buffer->dedicatedAllocation == VK_TRUE) {
4804 if (pCreateInfo->flags &
4805 (VK_BUFFER_CREATE_SPARSE_BINDING_BIT | VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT | VK_BUFFER_CREATE_SPARSE_ALIASED_BIT)) {
4806 skip |= LogError(device, "VUID-VkBufferCreateInfo-pNext-01571",
4807 "vkCreateBuffer(): pCreateInfos->flags must not include VK_BUFFER_CREATE_SPARSE_BINDING_BIT, "
4808 "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT when "
4809 "VkDedicatedAllocationBufferCreateInfoNV is in pNext chain with dedicatedAllocation VK_TRUE.");
4810 }
4811 }
4812
Mike Schuchardt2df08912020-12-15 16:28:09 -08004813 if ((pCreateInfo->flags & VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT) &&
Jeff Bolz33fc6722020-03-31 12:58:16 -05004814 !enabled_features.core12.bufferDeviceAddressCaptureReplay &&
sfricke-samsung828e59d2021-08-22 23:20:49 -07004815 !enabled_features.buffer_device_address_ext_features.bufferDeviceAddressCaptureReplay) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004816 skip |= LogError(
4817 device, "VUID-VkBufferCreateInfo-flags-03338",
Jeff Bolz87697532019-01-11 22:54:00 -06004818 "vkCreateBuffer(): the bufferDeviceAddressCaptureReplay device feature is disabled: Buffers cannot be created with "
Mike Schuchardt2df08912020-12-15 16:28:09 -08004819 "the VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT set.");
Jeff Bolz87697532019-01-11 22:54:00 -06004820 }
4821
Mark Lobodzinski08ee03c2019-02-04 10:57:47 -07004822 if (pCreateInfo->sharingMode == VK_SHARING_MODE_CONCURRENT && pCreateInfo->pQueueFamilyIndices) {
sfricke-samsung45996a42021-09-16 13:45:27 -07004823 const char *vuid = IsExtEnabled(device_extensions.vk_khr_get_physical_device_properties2)
4824 ? "VUID-VkBufferCreateInfo-sharingMode-01419"
4825 : "VUID-VkBufferCreateInfo-sharingMode-01391";
Mark Lobodzinski314b9162020-07-16 15:33:08 -06004826 skip |= ValidatePhysicalDeviceQueueFamilies(pCreateInfo->queueFamilyIndexCount, pCreateInfo->pQueueFamilyIndices,
ziga-lunarga0b4f8a2021-07-28 13:23:02 +02004827 "vkCreateBuffer", "pCreateInfo->pQueueFamilyIndices", vuid);
Mark Lobodzinski08ee03c2019-02-04 10:57:47 -07004828 }
4829
sfricke-samsungedce77a2020-07-03 22:35:13 -07004830 if ((pCreateInfo->flags & VK_BUFFER_CREATE_PROTECTED_BIT) != 0) {
4831 if (enabled_features.core11.protectedMemory == VK_FALSE) {
4832 skip |= LogError(device, "VUID-VkBufferCreateInfo-flags-01887",
4833 "vkCreateBuffer(): the protectedMemory device feature is disabled: Buffers cannot be created with the "
4834 "VK_BUFFER_CREATE_PROTECTED_BIT set.");
4835 }
4836 const VkBufferCreateFlags invalid_flags =
4837 VK_BUFFER_CREATE_SPARSE_BINDING_BIT | VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT | VK_BUFFER_CREATE_SPARSE_ALIASED_BIT;
4838 if ((pCreateInfo->flags & invalid_flags) != 0) {
4839 skip |= LogError(device, "VUID-VkBufferCreateInfo-None-01888",
4840 "vkCreateBuffer(): VK_BUFFER_CREATE_PROTECTED_BIT is set so no sparse create flags can be used at "
4841 "same time (VK_BUFFER_CREATE_SPARSE_BINDING_BIT | VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT | "
4842 "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT).");
4843 }
4844 }
4845
ziga-lunargfe74b8d2022-04-18 17:37:46 +02004846 if ((pCreateInfo->usage & (VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR | VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR)) > 0) {
4847 bool has_decode_codec_operation = false;
4848 const auto* video_profiles = LvlFindInChain<VkVideoProfilesKHR>(pCreateInfo->pNext);
4849 if (video_profiles) {
4850 for (uint32_t i = 0; i < video_profiles->profileCount; ++i) {
4851 if (video_profiles->pProfiles[i].videoCodecOperation &
4852 (VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT | VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT)) {
4853 has_decode_codec_operation = true;
4854 break;
4855 }
4856 }
4857 }
4858 if (!has_decode_codec_operation) {
4859 skip |= LogError(device, "VUID-VkBufferCreateInfo-usage-04813",
4860 "vkCreateBuffer(): pCreateInfo->usage is %s, but pNext chain does not include VkVideoProfilesKHR with "
4861 "a decode codec-operation.",
4862 string_VkBufferUsageFlags(pCreateInfo->usage).c_str());
4863 }
4864 }
4865 if ((pCreateInfo->usage & (VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR | VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR)) > 0) {
4866 bool has_encode_codec_operation = false;
4867 const auto *video_profiles = LvlFindInChain<VkVideoProfilesKHR>(pCreateInfo->pNext);
4868 if (video_profiles) {
4869 for (uint32_t i = 0; i < video_profiles->profileCount; ++i) {
4870 if (video_profiles->pProfiles[i].videoCodecOperation &
4871 (VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT | VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT)) {
4872 has_encode_codec_operation = true;
4873 break;
4874 }
4875 }
4876 }
4877 if (!has_encode_codec_operation) {
4878 skip |= LogError(device, "VUID-VkBufferCreateInfo-usage-04814",
4879 "vkCreateBuffer(): pCreateInfo->usage is %s, but pNext chain does not include VkVideoProfilesKHR with "
4880 "an encode codec-operation.",
4881 string_VkBufferUsageFlags(pCreateInfo->usage).c_str());
4882 }
4883 }
4884
Mark Lobodzinski96210742017-02-09 10:33:46 -07004885 return skip;
4886}
4887
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07004888bool CoreChecks::PreCallValidateCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
Jeff Bolz5c801d12019-10-09 10:38:45 -05004889 const VkAllocationCallbacks *pAllocator, VkBufferView *pView) const {
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07004890 bool skip = false;
Jeremy Gebbenf4449392022-01-28 10:09:10 -07004891 auto buffer_state = Get<BUFFER_STATE>(pCreateInfo->buffer);
sfricke-samsung2e827212021-09-28 07:52:08 -07004892
4893 if (FormatIsDepthOrStencil(pCreateInfo->format)) {
4894 // Should never hopefully get here, but there are known driver advertising the wrong feature flags
4895 // see https://gitlab.khronos.org/vulkan/vulkan/-/merge_requests/4849
4896 skip |= LogError(device, kVUID_Core_invalidDepthStencilFormat,
4897 "vkCreateBufferView(): format is a depth/stencil format (%s) but depth/stencil formats do not have a "
4898 "defined sizes for alignment, replace with a color format.",
4899 string_VkFormat(pCreateInfo->format));
4900 }
4901
Mark Lobodzinski96210742017-02-09 10:33:46 -07004902 // If this isn't a sparse buffer, it needs to have memory backing it at CreateBufferView time
4903 if (buffer_state) {
Jeremy Gebben9f537102021-10-05 16:37:12 -06004904 skip |=
4905 ValidateMemoryIsBoundToBuffer(buffer_state.get(), "vkCreateBufferView()", "VUID-VkBufferViewCreateInfo-buffer-00935");
Mark Lobodzinski96210742017-02-09 10:33:46 -07004906 // In order to create a valid buffer view, the buffer must have been created with at least one of the following flags:
4907 // UNIFORM_TEXEL_BUFFER_BIT or STORAGE_TEXEL_BUFFER_BIT
Jeremy Gebben9f537102021-10-05 16:37:12 -06004908 skip |= ValidateBufferUsageFlags(buffer_state.get(),
Dave Houltond8ed0212018-05-16 17:18:24 -06004909 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, false,
4910 "VUID-VkBufferViewCreateInfo-buffer-00932", "vkCreateBufferView()",
4911 "VK_BUFFER_USAGE_[STORAGE|UNIFORM]_TEXEL_BUFFER_BIT");
Shannon McPherson883f6092018-06-14 13:15:25 -06004912
Shannon McPherson0eb84f62018-06-18 16:32:40 -06004913 // Buffer view offset must be less than the size of buffer
4914 if (pCreateInfo->offset >= buffer_state->createInfo.size) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004915 skip |= LogError(buffer_state->buffer(), "VUID-VkBufferViewCreateInfo-offset-00925",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004916 "vkCreateBufferView(): VkBufferViewCreateInfo offset (%" PRIuLEAST64
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004917 ") must be less than the size of the buffer (%" PRIuLEAST64 ").",
4918 pCreateInfo->offset, buffer_state->createInfo.size);
Shannon McPherson0eb84f62018-06-18 16:32:40 -06004919 }
4920
Mark Lobodzinski79b5d5b2019-04-19 12:27:10 -06004921 const VkPhysicalDeviceLimits *device_limits = &phys_dev_props.limits;
Jeff Bolzd5554e62019-07-19 13:23:52 -05004922 // Buffer view offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment
4923 if ((pCreateInfo->offset % device_limits->minTexelBufferOffsetAlignment) != 0 &&
4924 !enabled_features.texel_buffer_alignment_features.texelBufferAlignment) {
sfricke-samsung45996a42021-09-16 13:45:27 -07004925 const char *vuid = IsExtEnabled(device_extensions.vk_ext_texel_buffer_alignment)
4926 ? "VUID-VkBufferViewCreateInfo-offset-02749"
4927 : "VUID-VkBufferViewCreateInfo-offset-00926";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004928 skip |= LogError(buffer_state->buffer(), vuid,
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004929 "vkCreateBufferView(): VkBufferViewCreateInfo offset (%" PRIuLEAST64
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004930 ") must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment (%" PRIuLEAST64 ").",
4931 pCreateInfo->offset, device_limits->minTexelBufferOffsetAlignment);
Jeff Bolzd5554e62019-07-19 13:23:52 -05004932 }
4933
4934 if (enabled_features.texel_buffer_alignment_features.texelBufferAlignment) {
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07004935 VkDeviceSize element_size = FormatElementSize(pCreateInfo->format);
4936 if ((element_size % 3) == 0) {
4937 element_size /= 3;
Jeff Bolzd5554e62019-07-19 13:23:52 -05004938 }
4939 if (buffer_state->createInfo.usage & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT) {
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07004940 VkDeviceSize alignment_requirement =
Jeff Bolzd5554e62019-07-19 13:23:52 -05004941 phys_dev_ext_props.texel_buffer_alignment_props.storageTexelBufferOffsetAlignmentBytes;
4942 if (phys_dev_ext_props.texel_buffer_alignment_props.storageTexelBufferOffsetSingleTexelAlignment) {
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07004943 alignment_requirement = std::min(alignment_requirement, element_size);
Jeff Bolzd5554e62019-07-19 13:23:52 -05004944 }
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07004945 if (SafeModulo(pCreateInfo->offset, alignment_requirement) != 0) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004946 skip |= LogError(
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004947 buffer_state->buffer(), "VUID-VkBufferViewCreateInfo-buffer-02750",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004948 "vkCreateBufferView(): If buffer was created with usage containing "
4949 "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, "
Jeff Bolzd5554e62019-07-19 13:23:52 -05004950 "VkBufferViewCreateInfo offset (%" PRIuLEAST64
4951 ") must be a multiple of the lesser of "
4952 "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::storageTexelBufferOffsetAlignmentBytes (%" PRIuLEAST64
4953 ") or, if VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::storageTexelBufferOffsetSingleTexelAlignment "
4954 "(%" PRId32
4955 ") is VK_TRUE, the size of a texel of the requested format. "
4956 "If the size of a texel is a multiple of three bytes, then the size of a "
4957 "single component of format is used instead",
4958 pCreateInfo->offset, phys_dev_ext_props.texel_buffer_alignment_props.storageTexelBufferOffsetAlignmentBytes,
4959 phys_dev_ext_props.texel_buffer_alignment_props.storageTexelBufferOffsetSingleTexelAlignment);
4960 }
4961 }
4962 if (buffer_state->createInfo.usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) {
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07004963 VkDeviceSize alignment_requirement =
Jeff Bolzd5554e62019-07-19 13:23:52 -05004964 phys_dev_ext_props.texel_buffer_alignment_props.uniformTexelBufferOffsetAlignmentBytes;
4965 if (phys_dev_ext_props.texel_buffer_alignment_props.uniformTexelBufferOffsetSingleTexelAlignment) {
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07004966 alignment_requirement = std::min(alignment_requirement, element_size);
Jeff Bolzd5554e62019-07-19 13:23:52 -05004967 }
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07004968 if (SafeModulo(pCreateInfo->offset, alignment_requirement) != 0) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07004969 skip |= LogError(
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06004970 buffer_state->buffer(), "VUID-VkBufferViewCreateInfo-buffer-02751",
sfricke-samsungf8a3a9b2020-06-12 23:51:51 -07004971 "vkCreateBufferView(): If buffer was created with usage containing "
4972 "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, "
Jeff Bolzd5554e62019-07-19 13:23:52 -05004973 "VkBufferViewCreateInfo offset (%" PRIuLEAST64
4974 ") must be a multiple of the lesser of "
4975 "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::uniformTexelBufferOffsetAlignmentBytes (%" PRIuLEAST64
4976 ") or, if VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::uniformTexelBufferOffsetSingleTexelAlignment "
4977 "(%" PRId32
4978 ") is VK_TRUE, the size of a texel of the requested format. "
4979 "If the size of a texel is a multiple of three bytes, then the size of a "
4980 "single component of format is used instead",
4981 pCreateInfo->offset, phys_dev_ext_props.texel_buffer_alignment_props.uniformTexelBufferOffsetAlignmentBytes,
4982 phys_dev_ext_props.texel_buffer_alignment_props.uniformTexelBufferOffsetSingleTexelAlignment);
4983 }
4984 }
4985 }
Shannon McPherson4c9505b2018-06-19 15:18:55 -06004986
Jeremy Gebben9f537102021-10-05 16:37:12 -06004987 skip |= ValidateBufferViewRange(buffer_state.get(), pCreateInfo, device_limits);
Shannon McPherson265383a2018-06-21 15:37:52 -06004988
Jeremy Gebben9f537102021-10-05 16:37:12 -06004989 skip |= ValidateBufferViewBuffer(buffer_state.get(), pCreateInfo);
Mark Lobodzinski96210742017-02-09 10:33:46 -07004990 }
Mark Lobodzinski95dbbe52017-02-09 10:40:41 -07004991 return skip;
Mark Lobodzinski96210742017-02-09 10:33:46 -07004992}
4993
Mark Lobodzinski602de982017-02-09 11:01:33 -07004994// For the given format verify that the aspect masks make sense
Mark Lobodzinski9ddb7182019-03-08 17:31:09 -07004995bool CoreChecks::ValidateImageAspectMask(VkImage image, VkFormat format, VkImageAspectFlags aspect_mask, const char *func_name,
John Zulauf9d2b6382019-07-25 15:21:36 -06004996 const char *vuid) const {
Mark Lobodzinski602de982017-02-09 11:01:33 -07004997 bool skip = false;
Jeremy Gebbenf4449392022-01-28 10:09:10 -07004998 auto image_state = Get<IMAGE_STATE>(image);
sfricke-samsung79b00482020-04-01 21:15:50 -07004999 // checks color format and (single-plane or non-disjoint)
5000 // if ycbcr extension is not supported then single-plane and non-disjoint are always both true
sfricke-samsung71bc6572020-04-29 15:49:43 -07005001 if ((FormatIsColor(format)) && ((FormatIsMultiplane(format) == false) || (image_state->disjoint == false))) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07005002 if ((aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != VK_IMAGE_ASPECT_COLOR_BIT) {
sfricke-samsung7687a482021-01-29 23:19:22 -08005003 skip |= LogError(
5004 image, vuid,
5005 "%s: Using format (%s) with aspect flags (%s) but color image formats must have the VK_IMAGE_ASPECT_COLOR_BIT set.",
5006 func_name, string_VkFormat(format), string_VkImageAspectFlags(aspect_mask).c_str());
Mark Lobodzinski602de982017-02-09 11:01:33 -07005007 } else if ((aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != aspect_mask) {
sfricke-samsung7687a482021-01-29 23:19:22 -08005008 skip |= LogError(image, vuid,
5009 "%s: Using format (%s) with aspect flags (%s) but color image formats must have ONLY the "
5010 "VK_IMAGE_ASPECT_COLOR_BIT set.",
5011 func_name, string_VkFormat(format), string_VkImageAspectFlags(aspect_mask).c_str());
Mark Lobodzinski602de982017-02-09 11:01:33 -07005012 }
Dave Houlton1d2022c2017-03-29 11:43:58 -06005013 } else if (FormatIsDepthAndStencil(format)) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07005014 if ((aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) == 0) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005015 skip |= LogError(image, vuid,
sfricke-samsung7687a482021-01-29 23:19:22 -08005016 "%s: Using format (%s) with aspect flags (%s) but depth/stencil image formats must have at least one "
5017 "of VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT set.",
5018 func_name, string_VkFormat(format), string_VkImageAspectFlags(aspect_mask).c_str());
Mark Lobodzinski602de982017-02-09 11:01:33 -07005019 } else if ((aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) != aspect_mask) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005020 skip |= LogError(image, vuid,
sfricke-samsung7687a482021-01-29 23:19:22 -08005021 "%s: Using format (%s) with aspect flags (%s) but combination depth/stencil image formats can have "
5022 "only the VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT set.",
5023 func_name, string_VkFormat(format), string_VkImageAspectFlags(aspect_mask).c_str());
Mark Lobodzinski602de982017-02-09 11:01:33 -07005024 }
Dave Houlton1d2022c2017-03-29 11:43:58 -06005025 } else if (FormatIsDepthOnly(format)) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07005026 if ((aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) {
sfricke-samsung7687a482021-01-29 23:19:22 -08005027 skip |= LogError(image, vuid,
5028 "%s: Using format (%s) with aspect flags (%s) but depth-only image formats must have the "
5029 "VK_IMAGE_ASPECT_DEPTH_BIT set.",
5030 func_name, string_VkFormat(format), string_VkImageAspectFlags(aspect_mask).c_str());
Mark Lobodzinski602de982017-02-09 11:01:33 -07005031 } else if ((aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) != aspect_mask) {
sfricke-samsung7687a482021-01-29 23:19:22 -08005032 skip |= LogError(image, vuid,
5033 "%s: Using format (%s) with aspect flags (%s) but depth-only image formats can have only the "
5034 "VK_IMAGE_ASPECT_DEPTH_BIT set.",
5035 func_name, string_VkFormat(format), string_VkImageAspectFlags(aspect_mask).c_str());
Mark Lobodzinski602de982017-02-09 11:01:33 -07005036 }
Dave Houlton1d2022c2017-03-29 11:43:58 -06005037 } else if (FormatIsStencilOnly(format)) {
Mark Lobodzinski602de982017-02-09 11:01:33 -07005038 if ((aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT) {
sfricke-samsung7687a482021-01-29 23:19:22 -08005039 skip |= LogError(image, vuid,
5040 "%s: Using format (%s) with aspect flags (%s) but stencil-only image formats must have the "
5041 "VK_IMAGE_ASPECT_STENCIL_BIT set.",
5042 func_name, string_VkFormat(format), string_VkImageAspectFlags(aspect_mask).c_str());
Mark Lobodzinski602de982017-02-09 11:01:33 -07005043 } else if ((aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) != aspect_mask) {
sfricke-samsung7687a482021-01-29 23:19:22 -08005044 skip |= LogError(image, vuid,
5045 "%s: Using format (%s) with aspect flags (%s) but stencil-only image formats can have only the "
5046 "VK_IMAGE_ASPECT_STENCIL_BIT set.",
5047 func_name, string_VkFormat(format), string_VkImageAspectFlags(aspect_mask).c_str());
Mark Lobodzinski602de982017-02-09 11:01:33 -07005048 }
Dave Houlton501b15b2018-03-30 15:07:41 -06005049 } else if (FormatIsMultiplane(format)) {
5050 VkImageAspectFlags valid_flags = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT;
5051 if (3 == FormatPlaneCount(format)) {
5052 valid_flags = valid_flags | VK_IMAGE_ASPECT_PLANE_2_BIT;
5053 }
5054 if ((aspect_mask & valid_flags) != aspect_mask) {
sfricke-samsung7687a482021-01-29 23:19:22 -08005055 skip |= LogError(image, vuid,
5056 "%s: Using format (%s) with aspect flags (%s) but multi-plane image formats may have only "
5057 "VK_IMAGE_ASPECT_COLOR_BIT or VK_IMAGE_ASPECT_PLANE_n_BITs set, where n = [0, 1, 2].",
5058 func_name, string_VkFormat(format), string_VkImageAspectFlags(aspect_mask).c_str());
Dave Houlton501b15b2018-03-30 15:07:41 -06005059 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07005060 }
5061 return skip;
5062}
5063
ziga-lunarg69aa72f2022-03-29 15:24:35 +02005064bool CoreChecks::ValidateImageAcquired(IMAGE_STATE const &image_state, const char *func_name) const {
ziga-lunarg04e94b32021-10-03 01:42:37 +02005065 bool skip = false;
5066
ziga-lunarg04e94b32021-10-03 01:42:37 +02005067 return skip;
5068}
5069
Mark Lobodzinski9ddb7182019-03-08 17:31:09 -07005070bool CoreChecks::ValidateImageSubresourceRange(const uint32_t image_mip_count, const uint32_t image_layer_count,
5071 const VkImageSubresourceRange &subresourceRange, const char *cmd_name,
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005072 const char *param_name, const char *image_layer_count_var_name, const VkImage image,
Jeremy Gebben5573a8c2021-06-04 08:55:10 -06005073 const SubresourceRangeErrorCodes &errorCodes) const {
Mark Lobodzinski602de982017-02-09 11:01:33 -07005074 bool skip = false;
Petr Kraus4d718682017-05-18 03:38:41 +02005075
5076 // Validate mip levels
Petr Krausffa94af2017-08-08 21:46:02 +02005077 if (subresourceRange.baseMipLevel >= image_mip_count) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005078 skip |= LogError(image, errorCodes.base_mip_err,
5079 "%s: %s.baseMipLevel (= %" PRIu32
5080 ") is greater or equal to the mip level count of the image (i.e. greater or equal to %" PRIu32 ").",
5081 cmd_name, param_name, subresourceRange.baseMipLevel, image_mip_count);
Petr Krausffa94af2017-08-08 21:46:02 +02005082 }
Petr Kraus4d718682017-05-18 03:38:41 +02005083
Petr Krausffa94af2017-08-08 21:46:02 +02005084 if (subresourceRange.levelCount != VK_REMAINING_MIP_LEVELS) {
5085 if (subresourceRange.levelCount == 0) {
sfricke-samsung40b79e32020-05-24 00:27:26 -07005086 skip |=
5087 LogError(image, "VUID-VkImageSubresourceRange-levelCount-01720", "%s: %s.levelCount is 0.", cmd_name, param_name);
Petr Krausffa94af2017-08-08 21:46:02 +02005088 } else {
5089 const uint64_t necessary_mip_count = uint64_t{subresourceRange.baseMipLevel} + uint64_t{subresourceRange.levelCount};
Petr Kraus4d718682017-05-18 03:38:41 +02005090
Petr Krausffa94af2017-08-08 21:46:02 +02005091 if (necessary_mip_count > image_mip_count) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005092 skip |= LogError(image, errorCodes.mip_count_err,
5093 "%s: %s.baseMipLevel + .levelCount (= %" PRIu32 " + %" PRIu32 " = %" PRIu64
5094 ") is greater than the mip level count of the image (i.e. greater than %" PRIu32 ").",
5095 cmd_name, param_name, subresourceRange.baseMipLevel, subresourceRange.levelCount,
5096 necessary_mip_count, image_mip_count);
Petr Krausffa94af2017-08-08 21:46:02 +02005097 }
Petr Kraus4d718682017-05-18 03:38:41 +02005098 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07005099 }
Petr Kraus4d718682017-05-18 03:38:41 +02005100
5101 // Validate array layers
Petr Krausffa94af2017-08-08 21:46:02 +02005102 if (subresourceRange.baseArrayLayer >= image_layer_count) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005103 skip |= LogError(image, errorCodes.base_layer_err,
5104 "%s: %s.baseArrayLayer (= %" PRIu32
5105 ") is greater or equal to the %s of the image when it was created (i.e. greater or equal to %" PRIu32 ").",
5106 cmd_name, param_name, subresourceRange.baseArrayLayer, image_layer_count_var_name, image_layer_count);
Petr Krausffa94af2017-08-08 21:46:02 +02005107 }
Petr Kraus4d718682017-05-18 03:38:41 +02005108
Petr Krausffa94af2017-08-08 21:46:02 +02005109 if (subresourceRange.layerCount != VK_REMAINING_ARRAY_LAYERS) {
5110 if (subresourceRange.layerCount == 0) {
sfricke-samsung40b79e32020-05-24 00:27:26 -07005111 skip |=
5112 LogError(image, "VUID-VkImageSubresourceRange-layerCount-01721", "%s: %s.layerCount is 0.", cmd_name, param_name);
Petr Krausffa94af2017-08-08 21:46:02 +02005113 } else {
5114 const uint64_t necessary_layer_count =
5115 uint64_t{subresourceRange.baseArrayLayer} + uint64_t{subresourceRange.layerCount};
Petr Kraus8423f152017-05-26 01:20:04 +02005116
Petr Krausffa94af2017-08-08 21:46:02 +02005117 if (necessary_layer_count > image_layer_count) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005118 skip |= LogError(image, errorCodes.layer_count_err,
5119 "%s: %s.baseArrayLayer + .layerCount (= %" PRIu32 " + %" PRIu32 " = %" PRIu64
5120 ") is greater than the %s of the image when it was created (i.e. greater than %" PRIu32 ").",
5121 cmd_name, param_name, subresourceRange.baseArrayLayer, subresourceRange.layerCount,
5122 necessary_layer_count, image_layer_count_var_name, image_layer_count);
Petr Krausffa94af2017-08-08 21:46:02 +02005123 }
Petr Kraus4d718682017-05-18 03:38:41 +02005124 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07005125 }
Petr Kraus4d718682017-05-18 03:38:41 +02005126
ziga-lunargb4e90752021-08-02 13:58:29 +02005127 if (subresourceRange.aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) {
5128 if (subresourceRange.aspectMask &
5129 (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT | VK_IMAGE_ASPECT_PLANE_2_BIT)) {
5130 skip |= LogError(image, "VUID-VkImageSubresourceRange-aspectMask-01670",
5131 "%s: aspectMask includes both VK_IMAGE_ASPECT_COLOR_BIT and one of VK_IMAGE_ASPECT_PLANE_0_BIT, "
5132 "VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT.",
5133 cmd_name);
5134 }
5135 }
5136
Mark Lobodzinski602de982017-02-09 11:01:33 -07005137 return skip;
5138}
5139
Mark Lobodzinski9ddb7182019-03-08 17:31:09 -07005140bool CoreChecks::ValidateCreateImageViewSubresourceRange(const IMAGE_STATE *image_state, bool is_imageview_2d_type,
Jeff Bolz46c0ea02019-10-09 13:06:29 -05005141 const VkImageSubresourceRange &subresourceRange) const {
Tony-LunarG2ec96bb2019-11-26 13:43:02 -07005142 bool is_khr_maintenance1 = IsExtEnabled(device_extensions.vk_khr_maintenance1);
Tony-LunarGbe956362022-04-05 13:34:31 -06005143 bool is_2d_compatible = (image_state->createInfo.flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT) ? true : false;
5144 if (device_extensions.vk_ext_image_2d_view_of_3d)
5145 is_2d_compatible |= (image_state->createInfo.flags & VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT) ? true : false;
5146 bool is_image_slicable =
5147 (image_state->createInfo.imageType == VK_IMAGE_TYPE_3D) && is_2d_compatible;
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07005148 bool is_3_d_to_2_d_map = is_khr_maintenance1 && is_image_slicable && is_imageview_2d_type;
Petr Krausffa94af2017-08-08 21:46:02 +02005149
David McFarland2853f2f2020-11-30 15:50:39 -04005150 uint32_t image_layer_count;
5151
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07005152 if (is_3_d_to_2_d_map) {
David McFarland2853f2f2020-11-30 15:50:39 -04005153 const auto layers = LayersFromRange(subresourceRange);
Jeremy Gebben1dfbd172021-05-19 14:00:58 -06005154 const auto extent = image_state->GetSubresourceExtent(layers);
David McFarland2853f2f2020-11-30 15:50:39 -04005155 image_layer_count = extent.depth;
5156 } else {
5157 image_layer_count = image_state->createInfo.arrayLayers;
5158 }
5159
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07005160 const auto image_layer_count_var_name = is_3_d_to_2_d_map ? "extent.depth" : "arrayLayers";
Petr Krausffa94af2017-08-08 21:46:02 +02005161
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07005162 SubresourceRangeErrorCodes subresource_range_error_codes = {};
5163 subresource_range_error_codes.base_mip_err = "VUID-VkImageViewCreateInfo-subresourceRange-01478";
5164 subresource_range_error_codes.mip_count_err = "VUID-VkImageViewCreateInfo-subresourceRange-01718";
5165 subresource_range_error_codes.base_layer_err =
5166 is_khr_maintenance1
Tony-LunarGbe956362022-04-05 13:34:31 -06005167 ? (is_3_d_to_2_d_map ? "VUID-VkImageViewCreateInfo-image-02724"
5168 : (device_extensions.vk_ext_image_2d_view_of_3d ? "VUID-VkImageViewCreateInfo-image-06724"
5169 : "VUID-VkImageViewCreateInfo-image-01482"))
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07005170 : "VUID-VkImageViewCreateInfo-subresourceRange-01480";
Tony-LunarGbe956362022-04-05 13:34:31 -06005171 subresource_range_error_codes.layer_count_err =
5172 is_khr_maintenance1
5173 ? (is_3_d_to_2_d_map ? "VUID-VkImageViewCreateInfo-subresourceRange-02725"
5174 : (device_extensions.vk_ext_image_2d_view_of_3d ? "VUID-VkImageViewCreateInfo-subresourceRange-06725"
5175 : "VUID-VkImageViewCreateInfo-subresourceRange-01483"))
5176 : "VUID-VkImageViewCreateInfo-subresourceRange-01719";
Petr Krausffa94af2017-08-08 21:46:02 +02005177
Mark Lobodzinski9ddb7182019-03-08 17:31:09 -07005178 return ValidateImageSubresourceRange(image_state->createInfo.mipLevels, image_layer_count, subresourceRange,
Petr Krausffa94af2017-08-08 21:46:02 +02005179 "vkCreateImageView", "pCreateInfo->subresourceRange", image_layer_count_var_name,
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005180 image_state->image(), subresource_range_error_codes);
Petr Krausffa94af2017-08-08 21:46:02 +02005181}
5182
Mark Lobodzinski9ddb7182019-03-08 17:31:09 -07005183bool CoreChecks::ValidateCmdClearColorSubresourceRange(const IMAGE_STATE *image_state,
John Zulauf07288512019-07-05 11:09:50 -06005184 const VkImageSubresourceRange &subresourceRange,
5185 const char *param_name) const {
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07005186 SubresourceRangeErrorCodes subresource_range_error_codes = {};
5187 subresource_range_error_codes.base_mip_err = "VUID-vkCmdClearColorImage-baseMipLevel-01470";
5188 subresource_range_error_codes.mip_count_err = "VUID-vkCmdClearColorImage-pRanges-01692";
5189 subresource_range_error_codes.base_layer_err = "VUID-vkCmdClearColorImage-baseArrayLayer-01472";
5190 subresource_range_error_codes.layer_count_err = "VUID-vkCmdClearColorImage-pRanges-01693";
Petr Krausffa94af2017-08-08 21:46:02 +02005191
Mark Lobodzinski9ddb7182019-03-08 17:31:09 -07005192 return ValidateImageSubresourceRange(image_state->createInfo.mipLevels, image_state->createInfo.arrayLayers, subresourceRange,
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005193 "vkCmdClearColorImage", param_name, "arrayLayers", image_state->image(),
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07005194 subresource_range_error_codes);
Petr Krausffa94af2017-08-08 21:46:02 +02005195}
5196
Mark Lobodzinski9ddb7182019-03-08 17:31:09 -07005197bool CoreChecks::ValidateCmdClearDepthSubresourceRange(const IMAGE_STATE *image_state,
John Zulaufeabb4462019-07-05 14:13:03 -06005198 const VkImageSubresourceRange &subresourceRange,
5199 const char *param_name) const {
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07005200 SubresourceRangeErrorCodes subresource_range_error_codes = {};
5201 subresource_range_error_codes.base_mip_err = "VUID-vkCmdClearDepthStencilImage-baseMipLevel-01474";
5202 subresource_range_error_codes.mip_count_err = "VUID-vkCmdClearDepthStencilImage-pRanges-01694";
5203 subresource_range_error_codes.base_layer_err = "VUID-vkCmdClearDepthStencilImage-baseArrayLayer-01476";
5204 subresource_range_error_codes.layer_count_err = "VUID-vkCmdClearDepthStencilImage-pRanges-01695";
Petr Krausffa94af2017-08-08 21:46:02 +02005205
Mark Lobodzinski9ddb7182019-03-08 17:31:09 -07005206 return ValidateImageSubresourceRange(image_state->createInfo.mipLevels, image_state->createInfo.arrayLayers, subresourceRange,
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005207 "vkCmdClearDepthStencilImage", param_name, "arrayLayers", image_state->image(),
Nathaniel Cesarioce9b4812020-12-17 08:55:28 -07005208 subresource_range_error_codes);
Petr Krausffa94af2017-08-08 21:46:02 +02005209}
5210
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07005211bool CoreChecks::ValidateImageBarrierSubresourceRange(const Location &loc, const IMAGE_STATE *image_state,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005212 const VkImageSubresourceRange &subresourceRange) const {
Mark Lobodzinski9ddb7182019-03-08 17:31:09 -07005213 return ValidateImageSubresourceRange(image_state->createInfo.mipLevels, image_state->createInfo.arrayLayers, subresourceRange,
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005214 loc.StringFunc().c_str(), loc.StringField().c_str(), "arrayLayers", image_state->image(),
Jeremy Gebbenbb845612021-02-18 18:16:05 -07005215 sync_vuid_maps::GetSubResourceVUIDs(loc));
Petr Krausffa94af2017-08-08 21:46:02 +02005216}
5217
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005218namespace barrier_queue_families {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005219using sync_vuid_maps::GetBarrierQueueVUID;
5220using sync_vuid_maps::kQueueErrorSummary;
5221using sync_vuid_maps::QueueError;
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005222
5223class ValidatorState {
5224 public:
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07005225 ValidatorState(const ValidationStateTracker *device_data, LogObjectList &&obj, const core_error::Location &location,
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005226 const VulkanTypedHandle &barrier_handle, const VkSharingMode sharing_mode)
5227 : device_data_(device_data),
John Zulaufbea70432021-02-23 07:03:12 -07005228 objects_(std::move(obj)),
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005229 loc_(location),
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005230 barrier_handle_(barrier_handle),
5231 sharing_mode_(sharing_mode),
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005232 limit_(static_cast<uint32_t>(device_data->physical_device_state->queue_family_properties.size())),
5233 mem_ext_(IsExtEnabled(device_data->device_extensions.vk_khr_external_memory)) {}
5234
5235 // Log the messages using boilerplate from object state, and Vu specific information from the template arg
5236 // One and two family versions, in the single family version, Vu holds the name of the passed parameter
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005237 bool LogMsg(QueueError vu_index, uint32_t family, const char *param_name) const {
5238 const std::string val_code = GetBarrierQueueVUID(loc_, vu_index);
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005239 const char *annotation = GetFamilyAnnotation(family);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005240 return device_data_->LogError(objects_, val_code, "%s Barrier using %s %s created with sharingMode %s, has %s %u%s. %s",
5241 loc_.Message().c_str(), GetTypeString(),
5242 device_data_->report_data->FormatHandle(barrier_handle_).c_str(), GetModeString(), param_name,
5243 family, annotation, kQueueErrorSummary.at(vu_index).c_str());
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005244 }
5245
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005246 bool LogMsg(QueueError vu_index, uint32_t src_family, uint32_t dst_family) const {
5247 const std::string val_code = GetBarrierQueueVUID(loc_, vu_index);
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005248 const char *src_annotation = GetFamilyAnnotation(src_family);
5249 const char *dst_annotation = GetFamilyAnnotation(dst_family);
5250 return device_data_->LogError(
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005251 objects_, val_code,
5252 "%s Barrier using %s %s created with sharingMode %s, has srcQueueFamilyIndex %u%s and dstQueueFamilyIndex %u%s. %s",
5253 loc_.Message().c_str(), GetTypeString(), device_data_->report_data->FormatHandle(barrier_handle_).c_str(),
5254 GetModeString(), src_family, src_annotation, dst_family, dst_annotation, kQueueErrorSummary.at(vu_index).c_str());
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005255 }
5256
5257 // This abstract Vu can only be tested at submit time, thus we need a callback from the closure containing the needed
5258 // data. Note that the mem_barrier is copied to the closure as the lambda lifespan exceed the guarantees of validity for
5259 // application input.
5260 static bool ValidateAtQueueSubmit(const QUEUE_STATE *queue_state, const ValidationStateTracker *device_data,
5261 uint32_t src_family, uint32_t dst_family, const ValidatorState &val) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005262 auto error_code = QueueError::kSubmitQueueMustMatchSrcOrDst;
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005263 uint32_t queue_family = queue_state->queueFamilyIndex;
5264 if ((src_family != queue_family) && (dst_family != queue_family)) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005265 const std::string val_code = GetBarrierQueueVUID(val.loc_, error_code);
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005266 const char *src_annotation = val.GetFamilyAnnotation(src_family);
5267 const char *dst_annotation = val.GetFamilyAnnotation(dst_family);
5268 return device_data->LogError(
Jeremy Gebben63f3cb02021-09-07 15:16:32 -06005269 queue_state->Handle(), val_code,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005270 "%s Barrier submitted to queue with family index %u, using %s %s created with sharingMode %s, has "
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005271 "srcQueueFamilyIndex %u%s and dstQueueFamilyIndex %u%s. %s",
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005272 val.loc_.Message().c_str(), queue_family, val.GetTypeString(),
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005273 device_data->report_data->FormatHandle(val.barrier_handle_).c_str(), val.GetModeString(), src_family,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005274 src_annotation, dst_family, dst_annotation, kQueueErrorSummary.at(error_code).c_str());
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005275 }
5276 return false;
5277 }
5278 // Logical helpers for semantic clarity
5279 inline bool KhrExternalMem() const { return mem_ext_; }
5280 inline bool IsValid(uint32_t queue_family) const { return (queue_family < limit_); }
5281 inline bool IsValidOrSpecial(uint32_t queue_family) const {
5282 return IsValid(queue_family) || (mem_ext_ && QueueFamilyIsExternal(queue_family));
5283 }
5284
5285 // Helpers for LogMsg
5286 const char *GetModeString() const { return string_VkSharingMode(sharing_mode_); }
5287
5288 // Descriptive text for the various types of queue family index
5289 const char *GetFamilyAnnotation(uint32_t family) const {
5290 const char *external = " (VK_QUEUE_FAMILY_EXTERNAL)";
5291 const char *foreign = " (VK_QUEUE_FAMILY_FOREIGN_EXT)";
5292 const char *ignored = " (VK_QUEUE_FAMILY_IGNORED)";
5293 const char *valid = " (VALID)";
5294 const char *invalid = " (INVALID)";
5295 switch (family) {
5296 case VK_QUEUE_FAMILY_EXTERNAL:
5297 return external;
5298 case VK_QUEUE_FAMILY_FOREIGN_EXT:
5299 return foreign;
5300 case VK_QUEUE_FAMILY_IGNORED:
5301 return ignored;
5302 default:
5303 if (IsValid(family)) {
5304 return valid;
5305 }
5306 return invalid;
5307 };
5308 }
5309 const char *GetTypeString() const { return object_string[barrier_handle_.type]; }
5310 VkSharingMode GetSharingMode() const { return sharing_mode_; }
5311
5312 protected:
5313 const ValidationStateTracker *device_data_;
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005314 const LogObjectList objects_;
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07005315 const core_error::Location loc_;
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005316 const VulkanTypedHandle barrier_handle_;
5317 const VkSharingMode sharing_mode_;
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005318 const uint32_t limit_;
5319 const bool mem_ext_;
5320};
5321
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005322bool Validate(const CoreChecks *device_data, const CMD_BUFFER_STATE *cb_state, const ValidatorState &val,
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005323 const uint32_t src_queue_family, const uint32_t dst_queue_family) {
5324 bool skip = false;
5325
5326 const bool mode_concurrent = val.GetSharingMode() == VK_SHARING_MODE_CONCURRENT;
5327 const bool src_ignored = QueueFamilyIsIgnored(src_queue_family);
5328 const bool dst_ignored = QueueFamilyIsIgnored(dst_queue_family);
5329 if (val.KhrExternalMem()) {
5330 if (mode_concurrent) {
Tony-LunarG273f32f2021-09-28 08:56:30 -06005331 bool sync2 = device_data->enabled_features.core13.synchronization2 != 0;
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005332 // this requirement is removed by VK_KHR_synchronization2
5333 if (!(src_ignored || dst_ignored) && !sync2) {
5334 skip |= val.LogMsg(QueueError::kSrcOrDstMustBeIgnore, src_queue_family, dst_queue_family);
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005335 }
5336 if ((src_ignored && !(dst_ignored || QueueFamilyIsExternal(dst_queue_family))) ||
5337 (dst_ignored && !(src_ignored || QueueFamilyIsExternal(src_queue_family)))) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005338 skip |= val.LogMsg(QueueError::kSpecialOrIgnoreOnly, src_queue_family, dst_queue_family);
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005339 }
5340 } else {
5341 // VK_SHARING_MODE_EXCLUSIVE
5342 if (src_queue_family != dst_queue_family) {
5343 if (!val.IsValidOrSpecial(dst_queue_family)) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005344 skip |= val.LogMsg(QueueError::kSrcAndDstValidOrSpecial, dst_queue_family, "dstQueueFamilyIndex");
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005345 }
5346 if (!val.IsValidOrSpecial(src_queue_family)) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005347 skip |= val.LogMsg(QueueError::kSrcAndDstValidOrSpecial, src_queue_family, "srcQueueFamilyIndex");
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005348 }
5349 }
5350 }
5351 } else {
5352 // No memory extension
5353 if (mode_concurrent) {
Tony-LunarG273f32f2021-09-28 08:56:30 -06005354 bool sync2 = device_data->enabled_features.core13.synchronization2 != 0;
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005355 // this requirement is removed by VK_KHR_synchronization2
5356 if ((!src_ignored || !dst_ignored) && !sync2) {
5357 skip |= val.LogMsg(QueueError::kSrcAndDestMustBeIgnore, src_queue_family, dst_queue_family);
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005358 }
5359 } else {
5360 // VK_SHARING_MODE_EXCLUSIVE
5361 if ((src_queue_family != dst_queue_family) && !(val.IsValid(src_queue_family) && val.IsValid(dst_queue_family))) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005362 skip |= val.LogMsg(QueueError::kSrcAndDstBothValid, src_queue_family, dst_queue_family);
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005363 }
5364 }
5365 }
5366 return skip;
5367}
5368} // namespace barrier_queue_families
5369
Jeremy Gebbene5361dd2021-11-18 14:23:56 -07005370bool CoreChecks::ValidateConcurrentBarrierAtSubmit(const Location &loc, const ValidationStateTracker &state_data,
5371 const QUEUE_STATE &queue_state, const CMD_BUFFER_STATE &cb_state,
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005372 const VulkanTypedHandle &typed_handle, uint32_t src_queue_family,
5373 uint32_t dst_queue_family) {
5374 using barrier_queue_families::ValidatorState;
Jeremy Gebbene5361dd2021-11-18 14:23:56 -07005375 ValidatorState val(&state_data, LogObjectList(cb_state.Handle()), loc, typed_handle, VK_SHARING_MODE_CONCURRENT);
5376 return ValidatorState::ValidateAtQueueSubmit(&queue_state, &state_data, src_queue_family, dst_queue_family, val);
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005377}
5378
5379// Type specific wrapper for image barriers
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005380template <typename ImgBarrier>
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07005381bool CoreChecks::ValidateBarrierQueueFamilies(const Location &loc, const CMD_BUFFER_STATE *cb_state, const ImgBarrier &barrier,
5382 const IMAGE_STATE *state_data) const {
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005383 // State data is required
5384 if (!state_data) {
5385 return false;
5386 }
5387
5388 // Create the validator state from the image state
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005389 barrier_queue_families::ValidatorState val(this, LogObjectList(cb_state->commandBuffer()), loc,
Jeremy Gebben9efe1cf2021-05-15 20:05:09 -06005390 state_data->Handle(), state_data->createInfo.sharingMode);
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005391 const uint32_t src_queue_family = barrier.srcQueueFamilyIndex;
5392 const uint32_t dst_queue_family = barrier.dstQueueFamilyIndex;
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005393 return barrier_queue_families::Validate(this, cb_state, val, src_queue_family, dst_queue_family);
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005394}
5395
5396// Type specific wrapper for buffer barriers
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005397template <typename BufBarrier>
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07005398bool CoreChecks::ValidateBarrierQueueFamilies(const Location &loc, const CMD_BUFFER_STATE *cb_state, const BufBarrier &barrier,
5399 const BUFFER_STATE *state_data) const {
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005400 // State data is required
5401 if (!state_data) {
5402 return false;
5403 }
5404
5405 // Create the validator state from the buffer state
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005406 barrier_queue_families::ValidatorState val(this, LogObjectList(cb_state->commandBuffer()), loc,
Jeremy Gebben9efe1cf2021-05-15 20:05:09 -06005407 state_data->Handle(), state_data->createInfo.sharingMode);
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005408 const uint32_t src_queue_family = barrier.srcQueueFamilyIndex;
5409 const uint32_t dst_queue_family = barrier.dstQueueFamilyIndex;
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005410 return barrier_queue_families::Validate(this, cb_state, val, src_queue_family, dst_queue_family);
5411}
5412
5413template <typename Barrier>
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07005414bool CoreChecks::ValidateBufferBarrier(const LogObjectList &objects, const Location &loc, const CMD_BUFFER_STATE *cb_state,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005415 const Barrier &mem_barrier) const {
5416 using sync_vuid_maps::BufferError;
5417 using sync_vuid_maps::GetBufferBarrierVUID;
5418
5419 bool skip = false;
5420
5421 skip |= ValidateQFOTransferBarrierUniqueness(loc, cb_state, mem_barrier, cb_state->qfo_transfer_buffer_barriers);
5422
5423 // Validate buffer barrier queue family indices
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06005424 auto buffer_state = Get<BUFFER_STATE>(mem_barrier.buffer);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005425 if (buffer_state) {
5426 auto buf_loc = loc.dot(Field::buffer);
5427 const auto &mem_vuid = GetBufferBarrierVUID(buf_loc, BufferError::kNoMemory);
Jeremy Gebben9f537102021-10-05 16:37:12 -06005428 skip |= ValidateMemoryIsBoundToBuffer(buffer_state.get(), loc.StringFunc().c_str(), mem_vuid.c_str());
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005429
Jeremy Gebben9f537102021-10-05 16:37:12 -06005430 skip |= ValidateBarrierQueueFamilies(buf_loc, cb_state, mem_barrier, buffer_state.get());
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005431
5432 auto buffer_size = buffer_state->createInfo.size;
5433 if (mem_barrier.offset >= buffer_size) {
5434 auto offset_loc = loc.dot(Field::offset);
5435 const auto &vuid = GetBufferBarrierVUID(offset_loc, BufferError::kOffsetTooBig);
5436
5437 skip |= LogError(objects, vuid, "%s %s has offset 0x%" PRIx64 " which is not less than total size 0x%" PRIx64 ".",
5438 offset_loc.Message().c_str(), report_data->FormatHandle(mem_barrier.buffer).c_str(),
5439 HandleToUint64(mem_barrier.offset), HandleToUint64(buffer_size));
5440 } else if (mem_barrier.size != VK_WHOLE_SIZE && (mem_barrier.offset + mem_barrier.size > buffer_size)) {
5441 auto size_loc = loc.dot(Field::size);
5442 const auto &vuid = GetBufferBarrierVUID(size_loc, BufferError::kSizeOutOfRange);
5443 skip |= LogError(objects, vuid,
5444 "%s %s has offset 0x%" PRIx64 " and size 0x%" PRIx64 " whose sum is greater than total size 0x%" PRIx64
5445 ".",
5446 size_loc.Message().c_str(), report_data->FormatHandle(mem_barrier.buffer).c_str(),
5447 HandleToUint64(mem_barrier.offset), HandleToUint64(mem_barrier.size), HandleToUint64(buffer_size));
5448 }
5449 if (mem_barrier.size == 0) {
5450 auto size_loc = loc.dot(Field::size);
5451 const auto &vuid = GetBufferBarrierVUID(size_loc, BufferError::kSizeZero);
5452 skip |= LogError(objects, vuid, "%s %s has a size of 0.", loc.Message().c_str(),
5453 report_data->FormatHandle(mem_barrier.buffer).c_str());
5454 }
5455 }
ziga-lunarg8e2506c2022-04-18 20:06:00 +02005456
5457 if (mem_barrier.srcQueueFamilyIndex == VK_QUEUE_FAMILY_EXTERNAL &&
5458 mem_barrier.dstQueueFamilyIndex == VK_QUEUE_FAMILY_EXTERNAL) {
5459 auto size_loc = loc.dot(Field::srcQueueFamilyIndex);
5460 const auto &vuid = GetBufferBarrierVUID(size_loc, BufferError::kQueueFamilyExternal);
5461 skip |= LogError(objects, vuid, "Both srcQueueFamilyIndex and dstQueueFamilyIndex are VK_QUEUE_FAMILY_EXTERNAL.");
5462 }
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005463 return skip;
5464}
5465
5466template <typename Barrier>
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07005467bool CoreChecks::ValidateImageBarrier(const LogObjectList &objects, const Location &loc, const CMD_BUFFER_STATE *cb_state,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005468 const Barrier &mem_barrier) const {
5469 bool skip = false;
5470
5471 skip |= ValidateQFOTransferBarrierUniqueness(loc, cb_state, mem_barrier, cb_state->qfo_transfer_image_barriers);
5472
Jeremy Gebben579aaca2021-02-15 13:36:18 -07005473 bool is_ilt = true;
Tony-LunarG273f32f2021-09-28 08:56:30 -06005474 if (enabled_features.core13.synchronization2) {
Jeremy Gebben579aaca2021-02-15 13:36:18 -07005475 is_ilt = mem_barrier.oldLayout != mem_barrier.newLayout;
5476 }
5477
5478 if (is_ilt) {
5479 if (mem_barrier.newLayout == VK_IMAGE_LAYOUT_UNDEFINED || mem_barrier.newLayout == VK_IMAGE_LAYOUT_PREINITIALIZED) {
5480 auto layout_loc = loc.dot(Field::newLayout);
5481 const auto &vuid = sync_vuid_maps::GetImageBarrierVUID(loc, sync_vuid_maps::ImageError::kBadLayout);
5482 skip |=
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005483 LogError(cb_state->commandBuffer(), vuid, "%s Image Layout cannot be transitioned to UNDEFINED or PREINITIALIZED.",
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005484 layout_loc.Message().c_str());
Jeremy Gebben579aaca2021-02-15 13:36:18 -07005485 }
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005486 }
5487
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06005488 auto image_data = Get<IMAGE_STATE>(mem_barrier.image);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005489 if (image_data) {
5490 auto image_loc = loc.dot(Field::image);
5491
Jeremy Gebben9f537102021-10-05 16:37:12 -06005492 skip |= ValidateMemoryIsBoundToImage(image_data.get(), loc);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005493
Jeremy Gebben9f537102021-10-05 16:37:12 -06005494 skip |= ValidateBarrierQueueFamilies(image_loc, cb_state, mem_barrier, image_data.get());
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005495
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005496 skip |= ValidateImageAspectMask(image_data->image(), image_data->createInfo.format, mem_barrier.subresourceRange.aspectMask,
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07005497 loc.StringFunc().c_str());
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005498
Jeremy Gebben9f537102021-10-05 16:37:12 -06005499 skip |=
5500 ValidateImageBarrierSubresourceRange(loc.dot(Field::subresourceRange), image_data.get(), mem_barrier.subresourceRange);
ziga-lunarg69aa72f2022-03-29 15:24:35 +02005501 skip |= ValidateImageAcquired(*image_data, loc.StringFunc().c_str());
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005502 }
5503 return skip;
5504}
5505
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07005506bool CoreChecks::ValidateBarriers(const Location &outer_loc, const CMD_BUFFER_STATE *cb_state, VkPipelineStageFlags src_stage_mask,
5507 VkPipelineStageFlags dst_stage_mask, uint32_t memBarrierCount,
5508 const VkMemoryBarrier *pMemBarriers, uint32_t bufferBarrierCount,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005509 const VkBufferMemoryBarrier *pBufferMemBarriers, uint32_t imageMemBarrierCount,
5510 const VkImageMemoryBarrier *pImageMemBarriers) const {
5511 bool skip = false;
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005512 LogObjectList objects(cb_state->commandBuffer());
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005513
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005514 for (uint32_t i = 0; i < memBarrierCount; ++i) {
5515 const auto &mem_barrier = pMemBarriers[i];
Jeremy Gebbend5bf0be2021-03-02 14:37:48 -07005516 auto loc = outer_loc.dot(Struct::VkMemoryBarrier, Field::pMemoryBarriers, i);
Jeremy Gebben7ba56152021-06-18 10:40:10 -06005517 skip |= ValidateMemoryBarrier(objects, loc, cb_state, mem_barrier, src_stage_mask, dst_stage_mask);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005518 }
5519 for (uint32_t i = 0; i < imageMemBarrierCount; ++i) {
5520 const auto &mem_barrier = pImageMemBarriers[i];
Jeremy Gebbend5bf0be2021-03-02 14:37:48 -07005521 auto loc = outer_loc.dot(Struct::VkImageMemoryBarrier, Field::pImageMemoryBarriers, i);
Jeremy Gebben7ba56152021-06-18 10:40:10 -06005522 skip |= ValidateMemoryBarrier(objects, loc, cb_state, mem_barrier, src_stage_mask, dst_stage_mask);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005523 skip |= ValidateImageBarrier(objects, loc, cb_state, mem_barrier);
5524 }
5525 {
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07005526 Location loc(outer_loc.function, Struct::VkImageMemoryBarrier);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005527 skip |= ValidateBarriersToImages(loc, cb_state, imageMemBarrierCount, pImageMemBarriers);
5528 }
5529 for (uint32_t i = 0; i < bufferBarrierCount; ++i) {
5530 const auto &mem_barrier = pBufferMemBarriers[i];
Jeremy Gebbend5bf0be2021-03-02 14:37:48 -07005531 auto loc = outer_loc.dot(Struct::VkBufferMemoryBarrier, Field::pMemoryBarriers, i);
Jeremy Gebben7ba56152021-06-18 10:40:10 -06005532 skip |= ValidateMemoryBarrier(objects, loc, cb_state, mem_barrier, src_stage_mask, dst_stage_mask);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005533 skip |= ValidateBufferBarrier(objects, loc, cb_state, mem_barrier);
5534 }
5535 return skip;
5536}
5537
Jeremy Gebbenbe60dd22021-03-02 16:36:47 -07005538bool CoreChecks::ValidateDependencyInfo(const LogObjectList &objects, const Location &outer_loc, const CMD_BUFFER_STATE *cb_state,
Jeremy Gebbenefead332021-06-18 08:22:44 -06005539 const VkDependencyInfoKHR *dep_info) const {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005540 bool skip = false;
5541
5542 if (cb_state->activeRenderPass) {
5543 skip |= ValidateRenderPassPipelineBarriers(outer_loc, cb_state, dep_info);
5544 if (skip) return true; // Early return to avoid redundant errors from below calls
5545 }
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005546 for (uint32_t i = 0; i < dep_info->memoryBarrierCount; ++i) {
5547 const auto &mem_barrier = dep_info->pMemoryBarriers[i];
Tony-LunarG279601c2021-11-16 10:50:51 -07005548 auto loc = outer_loc.dot(Struct::VkMemoryBarrier2, Field::pMemoryBarriers, i);
Jeremy Gebben7ba56152021-06-18 10:40:10 -06005549 skip |= ValidateMemoryBarrier(objects, loc, cb_state, mem_barrier);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005550 }
5551 for (uint32_t i = 0; i < dep_info->imageMemoryBarrierCount; ++i) {
5552 const auto &mem_barrier = dep_info->pImageMemoryBarriers[i];
Tony-LunarG279601c2021-11-16 10:50:51 -07005553 auto loc = outer_loc.dot(Struct::VkImageMemoryBarrier2, Field::pImageMemoryBarriers, i);
Jeremy Gebben7ba56152021-06-18 10:40:10 -06005554 skip |= ValidateMemoryBarrier(objects, loc, cb_state, mem_barrier);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005555 skip |= ValidateImageBarrier(objects, loc, cb_state, mem_barrier);
5556 }
5557 {
Tony-LunarG279601c2021-11-16 10:50:51 -07005558 Location loc(outer_loc.function, Struct::VkImageMemoryBarrier2);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005559 skip |= ValidateBarriersToImages(loc, cb_state, dep_info->imageMemoryBarrierCount, dep_info->pImageMemoryBarriers);
5560 }
5561
5562 for (uint32_t i = 0; i < dep_info->bufferMemoryBarrierCount; ++i) {
5563 const auto &mem_barrier = dep_info->pBufferMemoryBarriers[i];
Tony-LunarG279601c2021-11-16 10:50:51 -07005564 auto loc = outer_loc.dot(Struct::VkBufferMemoryBarrier2, Field::pBufferMemoryBarriers, i);
Jeremy Gebben7ba56152021-06-18 10:40:10 -06005565 skip |= ValidateMemoryBarrier(objects, loc, cb_state, mem_barrier);
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005566 skip |= ValidateBufferBarrier(objects, loc, cb_state, mem_barrier);
5567 }
5568
5569 return skip;
5570}
5571
Jeremy Gebben7ba56152021-06-18 10:40:10 -06005572// template to check all original barrier structures
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005573template <typename Barrier>
Jeremy Gebben7ba56152021-06-18 10:40:10 -06005574bool CoreChecks::ValidateMemoryBarrier(const LogObjectList &objects, const Location &loc, const CMD_BUFFER_STATE *cb_state,
5575 const Barrier &barrier, VkPipelineStageFlags src_stage_mask,
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005576 VkPipelineStageFlags dst_stage_mask) const {
5577 bool skip = false;
Jeremy Gebben7ba56152021-06-18 10:40:10 -06005578 assert(cb_state);
5579 auto queue_flags = cb_state->GetQueueFlags();
5580
5581 if (!cb_state->IsAcquireOp(barrier)) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005582 skip |= ValidateAccessMask(objects, loc.dot(Field::srcAccessMask), queue_flags, barrier.srcAccessMask, src_stage_mask);
5583 }
Jeremy Gebben7ba56152021-06-18 10:40:10 -06005584 if (!cb_state->IsReleaseOp(barrier)) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005585 skip |= ValidateAccessMask(objects, loc.dot(Field::dstAccessMask), queue_flags, barrier.dstAccessMask, dst_stage_mask);
5586 }
5587 return skip;
5588}
5589
Jeremy Gebbenbd7c9952021-06-23 10:14:06 -06005590// template to check all synchronization2 barrier structures
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005591template <typename Barrier>
Jeremy Gebben7ba56152021-06-18 10:40:10 -06005592bool CoreChecks::ValidateMemoryBarrier(const LogObjectList &objects, const Location &loc, const CMD_BUFFER_STATE *cb_state,
5593 const Barrier &barrier) const {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005594 bool skip = false;
Jeremy Gebbenbd7c9952021-06-23 10:14:06 -06005595 assert(cb_state);
5596 auto queue_flags = cb_state->GetQueueFlags();
Jeremy Gebben7ba56152021-06-18 10:40:10 -06005597
Jeremy Gebbenefead332021-06-18 08:22:44 -06005598 skip |= ValidatePipelineStage(objects, loc.dot(Field::srcStageMask), queue_flags, barrier.srcStageMask);
Jeremy Gebbenbd7c9952021-06-23 10:14:06 -06005599 if (!cb_state->IsAcquireOp(barrier)) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005600 skip |=
5601 ValidateAccessMask(objects, loc.dot(Field::srcAccessMask), queue_flags, barrier.srcAccessMask, barrier.srcStageMask);
5602 }
Jeremy Gebbenefead332021-06-18 08:22:44 -06005603
Jeremy Gebben7ba56152021-06-18 10:40:10 -06005604 skip |= ValidatePipelineStage(objects, loc.dot(Field::dstStageMask), queue_flags, barrier.dstStageMask);
Jeremy Gebbenbd7c9952021-06-23 10:14:06 -06005605 if (!cb_state->IsReleaseOp(barrier)) {
Jeremy Gebbene60d4172021-02-02 15:42:15 -07005606 skip |=
5607 ValidateAccessMask(objects, loc.dot(Field::dstAccessMask), queue_flags, barrier.dstAccessMask, barrier.dstStageMask);
5608 }
5609 return skip;
5610}
5611
Jeremy Gebbenbd7c9952021-06-23 10:14:06 -06005612// VkSubpassDependency validation happens when vkCreateRenderPass() is called.
5613// Dependencies between subpasses can only use pipeline stages compatible with VK_QUEUE_GRAPHICS_BIT,
5614// for external subpasses we don't have a yet command buffer so we have to assume all of them are valid.
5615static inline VkQueueFlags SubpassToQueueFlags(uint32_t subpass) {
5616 return subpass == VK_SUBPASS_EXTERNAL ? sync_utils::kAllQueueTypes : static_cast<VkQueueFlags>(VK_QUEUE_GRAPHICS_BIT);
5617}
Jeremy Gebbenec9ee972021-02-17 14:09:00 -07005618
Jeremy Gebbenbd7c9952021-06-23 10:14:06 -06005619bool CoreChecks::ValidateSubpassDependency(const LogObjectList &objects, const Location &in_loc,
5620 const VkSubpassDependency2 &dependency) const {
5621 bool skip = false;
5622 Location loc = in_loc;
5623 VkMemoryBarrier2KHR converted_barrier;
5624 const auto *mem_barrier = LvlFindInChain<VkMemoryBarrier2KHR>(dependency.pNext);
5625
Tony-LunarG273f32f2021-09-28 08:56:30 -06005626 if (mem_barrier && enabled_features.core13.synchronization2) {
Jeremy Gebbenbd7c9952021-06-23 10:14:06 -06005627 if (dependency.srcAccessMask != 0) {
5628 skip |= LogError(objects, "UNASSIGNED-CoreChecks-VkSubpassDependency2-srcAccessMask",
5629 "%s is non-zero when a VkMemoryBarrier2KHR is present in pNext.",
5630 loc.dot(Field::srcAccessMask).Message().c_str());
5631 }
5632 if (dependency.dstAccessMask != 0) {
5633 skip |= LogError(objects, "UNASSIGNED-CoreChecks-VkSubpassDependency2-dstAccessMask",
5634 "%s dstAccessMask is non-zero when a VkMemoryBarrier2KHR is present in pNext.",
5635 loc.dot(Field::dstAccessMask).Message().c_str());
5636 }
5637 if (dependency.srcStageMask != 0) {
5638 skip |= LogError(objects, "UNASSIGNED-CoreChecks-VkSubpassDependency2-srcStageMask",
5639 "%s srcStageMask is non-zero when a VkMemoryBarrier2KHR is present in pNext.",
5640 loc.dot(Field::srcStageMask).Message().c_str());
5641 }
5642 if (dependency.dstStageMask != 0) {
5643 skip |= LogError(objects, "UNASSIGNED-CoreChecks-VkSubpassDependency2-dstStageMask",
5644 "%s dstStageMask is non-zero when a VkMemoryBarrier2KHR is present in pNext.",
5645 loc.dot(Field::dstStageMask).Message().c_str());
5646 }
5647 loc = in_loc.dot(Field::pNext);
5648 converted_barrier = *mem_barrier;
5649 } else {
5650 if (mem_barrier) {
Jeremy Gebbenec9ee972021-02-17 14:09:00 -07005651 skip |= LogError(objects, "UNASSIGNED-CoreChecks-VkSubpassDependency2-pNext",
5652 "%s a VkMemoryBarrier2KHR is present in pNext but synchronization2 is not enabled.",
5653 loc.Message().c_str());
5654 }
Jeremy Gebbenbd7c9952021-06-23 10:14:06 -06005655 // use the subpass dependency flags, upconverted into wider synchronization2 fields.
5656 converted_barrier.srcStageMask = dependency.srcStageMask;
5657 converted_barrier.dstStageMask = dependency.dstStageMask;
5658 converted_barrier.srcAccessMask = dependency.srcAccessMask;
5659 converted_barrier.dstAccessMask = dependency.dstAccessMask;
Jeremy Gebbenec9ee972021-02-17 14:09:00 -07005660 }
Jeremy Gebbenbd7c9952021-06-23 10:14:06 -06005661 auto src_queue_flags = SubpassToQueueFlags(dependency.srcSubpass);
5662 skip |= ValidatePipelineStage(objects, loc.dot(Field::srcStageMask), src_queue_flags, converted_barrier.srcStageMask);
5663 skip |= ValidateAccessMask(objects, loc.dot(Field::srcAccessMask), src_queue_flags, converted_barrier.srcAccessMask,
5664 converted_barrier.srcStageMask);
5665
5666 auto dst_queue_flags = SubpassToQueueFlags(dependency.dstSubpass);
5667 skip |= ValidatePipelineStage(objects, loc.dot(Field::dstStageMask), dst_queue_flags, converted_barrier.dstStageMask);
5668 skip |= ValidateAccessMask(objects, loc.dot(Field::dstAccessMask), dst_queue_flags, converted_barrier.dstAccessMask,
5669 converted_barrier.dstStageMask);
Jeremy Gebbenec9ee972021-02-17 14:09:00 -07005670 return skip;
Jeremy Gebben50e0b412021-02-18 10:39:41 -07005671}
5672
Spencer Fricke6bba8c72020-04-06 07:41:21 -07005673bool CoreChecks::ValidateImageViewFormatFeatures(const IMAGE_STATE *image_state, const VkFormat view_format,
5674 const VkImageUsageFlags image_usage) const {
5675 // Pass in image_usage here instead of extracting it from image_state in case there's a chained VkImageViewUsageCreateInfo
5676 bool skip = false;
5677
Lionel Landwerlin21719f62021-12-09 11:40:09 +02005678 VkFormatFeatureFlags2KHR tiling_features = 0;
Spencer Fricke6bba8c72020-04-06 07:41:21 -07005679 const VkImageTiling image_tiling = image_state->createInfo.tiling;
5680
Jeremy Gebbenb4d17012021-07-08 13:18:15 -06005681 if (image_state->HasAHBFormat()) {
Spencer Fricke6bba8c72020-04-06 07:41:21 -07005682 // AHB image view and image share same feature sets
5683 tiling_features = image_state->format_features;
5684 } else if (image_tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT) {
5685 // Parameter validation should catch if this is used without VK_EXT_image_drm_format_modifier
sfricke-samsung45996a42021-09-16 13:45:27 -07005686 assert(IsExtEnabled(device_extensions.vk_ext_image_drm_format_modifier));
sjfrickee9b39372022-05-22 13:02:17 +09005687 VkImageDrmFormatModifierPropertiesEXT drm_format_properties = LvlInitStruct<VkImageDrmFormatModifierPropertiesEXT>();
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005688 DispatchGetImageDrmFormatModifierPropertiesEXT(device, image_state->image(), &drm_format_properties);
Spencer Fricke6bba8c72020-04-06 07:41:21 -07005689
Lionel Landwerlin1da35792021-12-14 16:54:13 +02005690 auto fmt_drm_props = LvlInitStruct<VkDrmFormatModifierPropertiesListEXT>();
5691 auto fmt_props_2 = LvlInitStruct<VkFormatProperties2>(&fmt_drm_props);
5692 DispatchGetPhysicalDeviceFormatProperties2(physical_device, view_format, &fmt_props_2);
Spencer Fricke6bba8c72020-04-06 07:41:21 -07005693
nyorain38a9d232021-03-06 13:06:12 +01005694 std::vector<VkDrmFormatModifierPropertiesEXT> drm_properties;
Lionel Landwerlin1da35792021-12-14 16:54:13 +02005695 drm_properties.resize(fmt_drm_props.drmFormatModifierCount);
5696 fmt_drm_props.pDrmFormatModifierProperties = drm_properties.data();
nyorain38a9d232021-03-06 13:06:12 +01005697
Lionel Landwerlin1da35792021-12-14 16:54:13 +02005698 DispatchGetPhysicalDeviceFormatProperties2(physical_device, view_format, &fmt_props_2);
nyorain38a9d232021-03-06 13:06:12 +01005699
Lionel Landwerlin1da35792021-12-14 16:54:13 +02005700 for (uint32_t i = 0; i < fmt_drm_props.drmFormatModifierCount; i++) {
5701 if (fmt_drm_props.pDrmFormatModifierProperties[i].drmFormatModifier == drm_format_properties.drmFormatModifier) {
5702 tiling_features = fmt_drm_props.pDrmFormatModifierProperties[i].drmFormatModifierTilingFeatures;
5703 break;
Spencer Fricke6bba8c72020-04-06 07:41:21 -07005704 }
5705 }
5706 } else {
Lionel Landwerlin21719f62021-12-09 11:40:09 +02005707 VkFormatProperties3KHR format_properties = GetPDFormatProperties(view_format);
Spencer Fricke6bba8c72020-04-06 07:41:21 -07005708 tiling_features = (image_tiling == VK_IMAGE_TILING_LINEAR) ? format_properties.linearTilingFeatures
5709 : format_properties.optimalTilingFeatures;
5710 }
5711
5712 if (tiling_features == 0) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005713 skip |= LogError(image_state->image(), "VUID-VkImageViewCreateInfo-None-02273",
Spencer Fricke6bba8c72020-04-06 07:41:21 -07005714 "vkCreateImageView(): pCreateInfo->format %s with tiling %s has no supported format features on this "
5715 "physical device.",
5716 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
5717 } else if ((image_usage & VK_IMAGE_USAGE_SAMPLED_BIT) && !(tiling_features & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005718 skip |= LogError(image_state->image(), "VUID-VkImageViewCreateInfo-usage-02274",
Spencer Fricke6bba8c72020-04-06 07:41:21 -07005719 "vkCreateImageView(): pCreateInfo->format %s with tiling %s does not support usage that includes "
5720 "VK_IMAGE_USAGE_SAMPLED_BIT.",
5721 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
5722 } else if ((image_usage & VK_IMAGE_USAGE_STORAGE_BIT) && !(tiling_features & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005723 skip |= LogError(image_state->image(), "VUID-VkImageViewCreateInfo-usage-02275",
Spencer Fricke6bba8c72020-04-06 07:41:21 -07005724 "vkCreateImageView(): pCreateInfo->format %s with tiling %s does not support usage that includes "
5725 "VK_IMAGE_USAGE_STORAGE_BIT.",
5726 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
5727 } else if ((image_usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) && !(tiling_features & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005728 skip |= LogError(image_state->image(), "VUID-VkImageViewCreateInfo-usage-02276",
Spencer Fricke6bba8c72020-04-06 07:41:21 -07005729 "vkCreateImageView(): pCreateInfo->format %s with tiling %s does not support usage that includes "
5730 "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT.",
5731 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
5732 } else if ((image_usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) &&
5733 !(tiling_features & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005734 skip |= LogError(image_state->image(), "VUID-VkImageViewCreateInfo-usage-02277",
Spencer Fricke6bba8c72020-04-06 07:41:21 -07005735 "vkCreateImageView(): pCreateInfo->format %s with tiling %s does not support usage that includes "
5736 "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT.",
5737 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
5738 } else if ((image_usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) &&
5739 !(tiling_features & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005740 skip |= LogError(image_state->image(), "VUID-VkImageViewCreateInfo-usage-02652",
Spencer Fricke6bba8c72020-04-06 07:41:21 -07005741 "vkCreateImageView(): pCreateInfo->format %s with tiling %s does not support usage that includes "
5742 "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT or VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT.",
5743 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
Tobias Hector6663c9b2020-11-05 10:18:02 +00005744 } else if ((image_usage & VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) &&
5745 !(tiling_features & VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR)) {
5746 if (enabled_features.fragment_shading_rate_features.attachmentFragmentShadingRate) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005747 skip |= LogError(image_state->image(), "VUID-VkImageViewCreateInfo-usage-04550",
Tobias Hector6663c9b2020-11-05 10:18:02 +00005748 "vkCreateImageView(): pCreateInfo->format %s with tiling %s does not support usage that includes "
5749 "VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR.",
5750 string_VkFormat(view_format), string_VkImageTiling(image_tiling));
5751 }
Spencer Fricke6bba8c72020-04-06 07:41:21 -07005752 }
5753
5754 return skip;
5755}
5756
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07005757bool CoreChecks::PreCallValidateCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
Jeff Bolz5c801d12019-10-09 10:38:45 -05005758 const VkAllocationCallbacks *pAllocator, VkImageView *pView) const {
Mark Lobodzinski602de982017-02-09 11:01:33 -07005759 bool skip = false;
Jeremy Gebbenf4449392022-01-28 10:09:10 -07005760 auto image_state = Get<IMAGE_STATE>(pCreateInfo->image);
Mark Lobodzinski602de982017-02-09 11:01:33 -07005761 if (image_state) {
ByumjinConffx1c74abf2019-08-14 15:16:40 -07005762 skip |=
Jeremy Gebben9f537102021-10-05 16:37:12 -06005763 ValidateImageUsageFlags(image_state.get(),
ByumjinConffx1c74abf2019-08-14 15:16:40 -07005764 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT |
5765 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
sfricke-samsungbb971942020-09-10 22:11:56 -07005766 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV |
5767 VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT,
5768 false, "VUID-VkImageViewCreateInfo-image-04441", "vkCreateImageView()",
ByumjinConffx1c74abf2019-08-14 15:16:40 -07005769 "VK_IMAGE_USAGE_[SAMPLED|STORAGE|COLOR_ATTACHMENT|DEPTH_STENCIL_ATTACHMENT|INPUT_ATTACHMENT|"
sfricke-samsungbb971942020-09-10 22:11:56 -07005770 "TRANSIENT_ATTACHMENT|SHADING_RATE_IMAGE|FRAGMENT_DENSITY_MAP]_BIT");
Mark Lobodzinski602de982017-02-09 11:01:33 -07005771 // If this isn't a sparse image, it needs to have memory backing it at CreateImageView time
Jeremy Gebben9f537102021-10-05 16:37:12 -06005772 skip |= ValidateMemoryIsBoundToImage(image_state.get(), "vkCreateImageView()", "VUID-VkImageViewCreateInfo-image-01020");
Mark Lobodzinski602de982017-02-09 11:01:33 -07005773 // Checks imported from image layer
Petr Krausffa94af2017-08-08 21:46:02 +02005774 skip |= ValidateCreateImageViewSubresourceRange(
Jeremy Gebben9f537102021-10-05 16:37:12 -06005775 image_state.get(),
5776 pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_2D || pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_2D_ARRAY,
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07005777 pCreateInfo->subresourceRange);
Mark Lobodzinski602de982017-02-09 11:01:33 -07005778
5779 VkImageCreateFlags image_flags = image_state->createInfo.flags;
5780 VkFormat image_format = image_state->createInfo.format;
Jeremy Kniagercef491c2017-07-18 11:10:28 -06005781 VkImageUsageFlags image_usage = image_state->createInfo.usage;
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07005782 VkFormat view_format = pCreateInfo->format;
5783 VkImageAspectFlags aspect_mask = pCreateInfo->subresourceRange.aspectMask;
Jeremy Kniager846ab732017-07-10 13:12:04 -06005784 VkImageType image_type = image_state->createInfo.imageType;
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07005785 VkImageViewType view_type = pCreateInfo->viewType;
sfricke-samsung20a8a372021-07-14 06:12:17 -07005786 uint32_t layer_count = pCreateInfo->subresourceRange.layerCount;
Mark Lobodzinski602de982017-02-09 11:01:33 -07005787
Dave Houltonbd2e2622018-04-10 16:41:14 -06005788 // If there's a chained VkImageViewUsageCreateInfo struct, modify image_usage to match
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07005789 auto chained_ivuci_struct = LvlFindInChain<VkImageViewUsageCreateInfo>(pCreateInfo->pNext);
Dave Houltonbd2e2622018-04-10 16:41:14 -06005790 if (chained_ivuci_struct) {
sfricke-samsung45996a42021-09-16 13:45:27 -07005791 if (IsExtEnabled(device_extensions.vk_khr_maintenance2)) {
5792 if (!IsExtEnabled(device_extensions.vk_ext_separate_stencil_usage)) {
Andrew Fobel3abeb992020-01-20 16:33:22 -05005793 if ((image_usage | chained_ivuci_struct->usage) != image_usage) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005794 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-pNext-02661",
5795 "vkCreateImageView(): pNext chain includes VkImageViewUsageCreateInfo, usage must not "
5796 "include any bits that were not set in VkImageCreateInfo::usage used to create image");
Andrew Fobel3abeb992020-01-20 16:33:22 -05005797 }
5798 } else {
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07005799 const auto image_stencil_struct = LvlFindInChain<VkImageStencilUsageCreateInfo>(image_state->createInfo.pNext);
Andrew Fobel3abeb992020-01-20 16:33:22 -05005800 if (image_stencil_struct == nullptr) {
5801 if ((image_usage | chained_ivuci_struct->usage) != image_usage) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005802 skip |= LogError(
5803 pCreateInfo->image, "VUID-VkImageViewCreateInfo-pNext-02662",
Andrew Fobel3abeb992020-01-20 16:33:22 -05005804 "vkCreateImageView(): pNext chain includes VkImageViewUsageCreateInfo and image was not created "
5805 "with a VkImageStencilUsageCreateInfo in pNext of vkImageCreateInfo, usage must not include "
5806 "any bits that were not set in VkImageCreateInfo::usage used to create image");
5807 }
5808 } else {
5809 if ((aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) == VK_IMAGE_ASPECT_STENCIL_BIT &&
5810 (image_stencil_struct->stencilUsage | chained_ivuci_struct->usage) !=
5811 image_stencil_struct->stencilUsage) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005812 skip |= LogError(
5813 pCreateInfo->image, "VUID-VkImageViewCreateInfo-pNext-02663",
Andrew Fobel3abeb992020-01-20 16:33:22 -05005814 "vkCreateImageView(): pNext chain includes VkImageViewUsageCreateInfo, image was created with a "
5815 "VkImageStencilUsageCreateInfo in pNext of vkImageCreateInfo, and subResourceRange.aspectMask "
5816 "includes VK_IMAGE_ASPECT_STENCIL_BIT, VkImageViewUsageCreateInfo::usage must not include any "
5817 "bits that were not set in VkImageStencilUsageCreateInfo::stencilUsage used to create image");
5818 }
5819 if ((aspect_mask & ~VK_IMAGE_ASPECT_STENCIL_BIT) != 0 &&
5820 (image_usage | chained_ivuci_struct->usage) != image_usage) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005821 skip |= LogError(
5822 pCreateInfo->image, "VUID-VkImageViewCreateInfo-pNext-02664",
Andrew Fobel3abeb992020-01-20 16:33:22 -05005823 "vkCreateImageView(): pNext chain includes VkImageViewUsageCreateInfo, image was created with a "
5824 "VkImageStencilUsageCreateInfo in pNext of vkImageCreateInfo, and subResourceRange.aspectMask "
5825 "includes bits other than VK_IMAGE_ASPECT_STENCIL_BIT, VkImageViewUsageCreateInfo::usage must not "
5826 "include any bits that were not set in VkImageCreateInfo::usage used to create image");
5827 }
5828 }
5829 }
5830 }
5831
Dave Houltonbd2e2622018-04-10 16:41:14 -06005832 image_usage = chained_ivuci_struct->usage;
5833 }
5834
sfricke-samsungf60b6c82021-04-05 22:59:20 -07005835 // If image used VkImageFormatListCreateInfo need to make sure a format from list is used
5836 const auto format_list_info = LvlFindInChain<VkImageFormatListCreateInfo>(image_state->createInfo.pNext);
5837 if (format_list_info && (format_list_info->viewFormatCount > 0)) {
5838 bool foundFormat = false;
5839 for (uint32_t i = 0; i < format_list_info->viewFormatCount; i++) {
5840 if (format_list_info->pViewFormats[i] == view_format) {
5841 foundFormat = true;
5842 break;
5843 }
5844 }
5845 if (foundFormat == false) {
5846 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-pNext-01585",
5847 "vkCreateImageView(): image was created with a VkImageFormatListCreateInfo in pNext of "
5848 "vkImageCreateInfo, but none of the formats match the VkImageViewCreateInfo::format (%s).",
5849 string_VkFormat(view_format));
5850 }
5851 }
5852
Dave Houlton6f5f20a2018-05-04 12:37:44 -06005853 // Validate VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT state, if view/image formats differ
5854 if ((image_flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) && (image_format != view_format)) {
Dave Houltonc7988072018-04-16 11:46:56 -06005855 if (FormatIsMultiplane(image_format)) {
Graeme Leese605ca512019-05-08 12:59:44 +01005856 VkFormat compat_format = FindMultiplaneCompatibleFormat(image_format, aspect_mask);
Dave Houltonc7988072018-04-16 11:46:56 -06005857 if (view_format != compat_format) {
Graeme Leese605ca512019-05-08 12:59:44 +01005858 // View format must match the multiplane compatible format
Lenny Komowb79f04a2017-09-18 17:07:00 -06005859 std::stringstream ss;
5860 ss << "vkCreateImageView(): ImageView format " << string_VkFormat(view_format)
Graeme Leesed8572aa2019-05-15 14:58:19 +01005861 << " is not compatible with plane " << GetPlaneIndex(aspect_mask) << " of underlying image format "
Dave Houltonc7988072018-04-16 11:46:56 -06005862 << string_VkFormat(image_format) << ", must be " << string_VkFormat(compat_format) << ".";
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005863 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-01586", "%s", ss.str().c_str());
Dave Houltonc7988072018-04-16 11:46:56 -06005864 }
5865 } else {
Mike Schuchardt2df08912020-12-15 16:28:09 -08005866 if (!(image_flags & VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT)) {
Dave Houltonc7988072018-04-16 11:46:56 -06005867 // Format MUST be compatible (in the same format compatibility class) as the format the image was created with
sfricke-samsung965e5f82021-11-24 00:17:47 -06005868 auto image_class = FormatCompatibilityClass(image_format);
5869 auto view_class = FormatCompatibilityClass(view_format);
5870 // Need to only check if one is NONE to handle edge case both are NONE
5871 if ((image_class != view_class) || (image_class == FORMAT_COMPATIBILITY_CLASS::NONE)) {
sfricke-samsung2ff8b6a2020-03-09 21:54:35 -07005872 const char *error_vuid;
sfricke-samsung45996a42021-09-16 13:45:27 -07005873 if ((!IsExtEnabled(device_extensions.vk_khr_maintenance2)) &&
5874 (!IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion))) {
sfricke-samsung2ff8b6a2020-03-09 21:54:35 -07005875 error_vuid = "VUID-VkImageViewCreateInfo-image-01018";
sfricke-samsung45996a42021-09-16 13:45:27 -07005876 } else if ((IsExtEnabled(device_extensions.vk_khr_maintenance2)) &&
5877 (!IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion))) {
sfricke-samsung2ff8b6a2020-03-09 21:54:35 -07005878 error_vuid = "VUID-VkImageViewCreateInfo-image-01759";
sfricke-samsung45996a42021-09-16 13:45:27 -07005879 } else if ((!IsExtEnabled(device_extensions.vk_khr_maintenance2)) &&
5880 (IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion))) {
sfricke-samsung2ff8b6a2020-03-09 21:54:35 -07005881 error_vuid = "VUID-VkImageViewCreateInfo-image-01760";
5882 } else {
5883 // both enabled
5884 error_vuid = "VUID-VkImageViewCreateInfo-image-01761";
5885 }
Dave Houltonc7988072018-04-16 11:46:56 -06005886 std::stringstream ss;
5887 ss << "vkCreateImageView(): ImageView format " << string_VkFormat(view_format)
locke-lunarg9edc2812019-06-17 23:18:52 -06005888 << " is not in the same format compatibility class as "
5889 << report_data->FormatHandle(pCreateInfo->image).c_str() << " format " << string_VkFormat(image_format)
Dave Houltonc7988072018-04-16 11:46:56 -06005890 << ". Images created with the VK_IMAGE_CREATE_MUTABLE_FORMAT BIT "
5891 << "can support ImageViews with differing formats but they must be in the same compatibility class.";
sfricke-samsung2ff8b6a2020-03-09 21:54:35 -07005892 skip |= LogError(pCreateInfo->image, error_vuid, "%s", ss.str().c_str());
Dave Houltonc7988072018-04-16 11:46:56 -06005893 }
Lenny Komowb79f04a2017-09-18 17:07:00 -06005894 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07005895 }
5896 } else {
5897 // Format MUST be IDENTICAL to the format the image was created with
Spencer Frickeff160582020-03-16 17:28:14 -07005898 // Unless it is a multi-planar color bit aspect
5899 if ((image_format != view_format) &&
5900 ((FormatIsMultiplane(image_format) == false) || (aspect_mask != VK_IMAGE_ASPECT_COLOR_BIT))) {
sfricke-samsung45996a42021-09-16 13:45:27 -07005901 const char *vuid = IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion)
5902 ? "VUID-VkImageViewCreateInfo-image-01762"
5903 : "VUID-VkImageViewCreateInfo-image-01019";
Mark Lobodzinski602de982017-02-09 11:01:33 -07005904 std::stringstream ss;
locke-lunarg9edc2812019-06-17 23:18:52 -06005905 ss << "vkCreateImageView() format " << string_VkFormat(view_format) << " differs from "
Lockee9aeebf2019-03-03 23:50:08 -07005906 << report_data->FormatHandle(pCreateInfo->image).c_str() << " format " << string_VkFormat(image_format)
Mark Lobodzinski602de982017-02-09 11:01:33 -07005907 << ". Formats MUST be IDENTICAL unless VK_IMAGE_CREATE_MUTABLE_FORMAT BIT was set on image creation.";
Spencer Frickeff160582020-03-16 17:28:14 -07005908 skip |= LogError(pCreateInfo->image, vuid, "%s", ss.str().c_str());
Mark Lobodzinski602de982017-02-09 11:01:33 -07005909 }
5910 }
5911
ziga-lunargebb32de2021-08-29 21:24:30 +02005912 if (image_state->createInfo.samples != VK_SAMPLE_COUNT_1_BIT && view_type != VK_IMAGE_VIEW_TYPE_2D &&
5913 view_type != VK_IMAGE_VIEW_TYPE_2D_ARRAY) {
5914 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-04972",
5915 "vkCreateImageView(): image was created with sample count %s, but pCreateInfo->viewType is %s.",
5916 string_VkSampleCountFlagBits(image_state->createInfo.samples), string_VkImageViewType(view_type));
5917 }
5918
Mark Lobodzinski602de982017-02-09 11:01:33 -07005919 // Validate correct image aspect bits for desired formats and format consistency
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06005920 skip |= ValidateImageAspectMask(image_state->image(), image_format, aspect_mask, "vkCreateImageView()");
Jeremy Kniager846ab732017-07-10 13:12:04 -06005921
sfricke-samsung20a8a372021-07-14 06:12:17 -07005922 // Valdiate Image/ImageView type compatibility #resources-image-views-compatibility
Jeremy Kniager846ab732017-07-10 13:12:04 -06005923 switch (image_type) {
5924 case VK_IMAGE_TYPE_1D:
5925 if (view_type != VK_IMAGE_VIEW_TYPE_1D && view_type != VK_IMAGE_VIEW_TYPE_1D_ARRAY) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005926 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-subResourceRange-01021",
5927 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
5928 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06005929 }
5930 break;
5931 case VK_IMAGE_TYPE_2D:
5932 if (view_type != VK_IMAGE_VIEW_TYPE_2D && view_type != VK_IMAGE_VIEW_TYPE_2D_ARRAY) {
5933 if ((view_type == VK_IMAGE_VIEW_TYPE_CUBE || view_type == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) &&
5934 !(image_flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005935 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-01003",
5936 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
5937 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06005938 } else if (view_type != VK_IMAGE_VIEW_TYPE_CUBE && view_type != VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005939 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-subResourceRange-01021",
5940 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
5941 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06005942 }
5943 }
5944 break;
5945 case VK_IMAGE_TYPE_3D:
sfricke-samsung45996a42021-09-16 13:45:27 -07005946 if (IsExtEnabled(device_extensions.vk_khr_maintenance1)) {
Jeremy Kniager846ab732017-07-10 13:12:04 -06005947 if (view_type != VK_IMAGE_VIEW_TYPE_3D) {
5948 if ((view_type == VK_IMAGE_VIEW_TYPE_2D || view_type == VK_IMAGE_VIEW_TYPE_2D_ARRAY)) {
Tony-LunarGbe956362022-04-05 13:34:31 -06005949 if (device_extensions.vk_ext_image_2d_view_of_3d) {
5950 if (!(image_flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT)) {
5951 if (view_type == VK_IMAGE_VIEW_TYPE_2D_ARRAY) {
5952 skip |= LogError(
5953 pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-06723",
5954 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type "
5955 "%s since the image doesn't have VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT flag set.",
5956 string_VkImageViewType(view_type), string_VkImageType(image_type));
5957 } else if (view_type == VK_IMAGE_VIEW_TYPE_2D &&
5958 !(image_flags & VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT)) {
5959 skip |= LogError(
5960 pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-06728",
5961 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type "
5962 "%s since the image doesn't have VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT or "
5963 "VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT flag set.",
5964 string_VkImageViewType(view_type), string_VkImageType(image_type));
5965 }
5966 }
5967 } else if (!(image_flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT) &&
5968 (view_type == VK_IMAGE_VIEW_TYPE_2D)) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06005969 skip |=
Tony-LunarGbe956362022-04-05 13:34:31 -06005970 LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-06727",
5971 "vkCreateImageView(): pCreateInfo->viewType VK_IMAGE_VIEW_TYPE_2D is not compatible "
5972 "with image type "
sfricke-samsungd9b3e122021-07-15 22:50:00 -07005973 "%s since the image doesn't have VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT flag set.",
Tony-LunarGbe956362022-04-05 13:34:31 -06005974 string_VkImageType(image_type));
5975 }
5976 if ((image_flags & (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT |
Jeremy Kniager846ab732017-07-10 13:12:04 -06005977 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT))) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005978 skip |= LogError(
sfricke-samsungd9b3e122021-07-15 22:50:00 -07005979 pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-04971",
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005980 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s "
5981 "when the VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or "
5982 "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT flags are enabled.",
5983 string_VkImageViewType(view_type), string_VkImageType(image_type));
sfricke-samsungd9b3e122021-07-15 22:50:00 -07005984 } else if (pCreateInfo->subresourceRange.levelCount != 1) {
5985 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-04970",
5986 "vkCreateImageView(): pCreateInfo->viewType %s is with image type %s must have a "
5987 "levelCount of 1 but it is %u.",
5988 string_VkImageViewType(view_type), string_VkImageType(image_type),
5989 pCreateInfo->subresourceRange.levelCount);
Jeremy Kniager846ab732017-07-10 13:12:04 -06005990 }
5991 } else {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07005992 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-subResourceRange-01021",
5993 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
5994 string_VkImageViewType(view_type), string_VkImageType(image_type));
Jeremy Kniager846ab732017-07-10 13:12:04 -06005995 }
5996 }
5997 } else {
5998 if (view_type != VK_IMAGE_VIEW_TYPE_3D) {
sfricke-samsungd9b3e122021-07-15 22:50:00 -07005999 // Help point to VK_KHR_maintenance1
6000 if ((view_type == VK_IMAGE_VIEW_TYPE_2D || view_type == VK_IMAGE_VIEW_TYPE_2D_ARRAY)) {
6001 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-subResourceRange-01021",
6002 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s "
6003 "without VK_KHR_maintenance1 enabled which was promoted in Vulkan 1.0.",
6004 string_VkImageViewType(view_type), string_VkImageType(image_type));
6005 } else {
6006 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-subResourceRange-01021",
6007 "vkCreateImageView(): pCreateInfo->viewType %s is not compatible with image type %s.",
6008 string_VkImageViewType(view_type), string_VkImageType(image_type));
6009 }
Jeremy Kniager846ab732017-07-10 13:12:04 -06006010 }
6011 }
6012 break;
6013 default:
6014 break;
6015 }
Jeremy Kniagercef491c2017-07-18 11:10:28 -06006016
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06006017 // External format checks needed when VK_ANDROID_external_memory_android_hardware_buffer enabled
sfricke-samsung45996a42021-09-16 13:45:27 -07006018 if (IsExtEnabled(device_extensions.vk_android_external_memory_android_hardware_buffer)) {
Mark Lobodzinskie9b99792019-03-07 16:34:29 -07006019 skip |= ValidateCreateImageViewANDROID(pCreateInfo);
Jeremy Kniagercef491c2017-07-18 11:10:28 -06006020 }
6021
Jeremy Gebben9f537102021-10-05 16:37:12 -06006022 skip |= ValidateImageViewFormatFeatures(image_state.get(), view_format, image_usage);
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06006023
sfricke-samsung828e59d2021-08-22 23:20:49 -07006024 if (enabled_features.shading_rate_image_features.shadingRateImage) {
Tobias Hector6663c9b2020-11-05 10:18:02 +00006025 if (image_usage & VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV) {
6026 if (view_format != VK_FORMAT_R8_UINT) {
6027 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-02087",
6028 "vkCreateImageView() If image was created with usage containing "
6029 "VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, format must be VK_FORMAT_R8_UINT.");
6030 }
Jeff Bolz9af91c52018-09-01 21:53:57 -05006031 }
Tobias Hector6663c9b2020-11-05 10:18:02 +00006032 }
6033
sfricke-samsung828e59d2021-08-22 23:20:49 -07006034 if (enabled_features.shading_rate_image_features.shadingRateImage ||
Tobias Hector6663c9b2020-11-05 10:18:02 +00006035 enabled_features.fragment_shading_rate_features.attachmentFragmentShadingRate) {
6036 if (image_usage & VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) {
6037 if (view_type != VK_IMAGE_VIEW_TYPE_2D && view_type != VK_IMAGE_VIEW_TYPE_2D_ARRAY) {
6038 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-02086",
6039 "vkCreateImageView() If image was created with usage containing "
6040 "VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, viewType must be "
6041 "VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY.");
6042 }
Jeff Bolz9af91c52018-09-01 21:53:57 -05006043 }
6044 }
Jeff Bolz99e3f632020-03-24 22:59:22 -05006045
Tobias Hector6663c9b2020-11-05 10:18:02 +00006046 if (enabled_features.fragment_shading_rate_features.attachmentFragmentShadingRate &&
6047 !phys_dev_ext_props.fragment_shading_rate_props.layeredShadingRateAttachments &&
sfricke-samsung20a8a372021-07-14 06:12:17 -07006048 image_usage & VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR && layer_count != 1) {
Tobias Hector6663c9b2020-11-05 10:18:02 +00006049 skip |= LogError(device, "VUID-VkImageViewCreateInfo-usage-04551",
6050 "vkCreateImageView(): subresourceRange.layerCount is %u for a shading rate attachment image view.",
sfricke-samsung20a8a372021-07-14 06:12:17 -07006051 layer_count);
Tobias Hector6663c9b2020-11-05 10:18:02 +00006052 }
6053
sfricke-samsung20a8a372021-07-14 06:12:17 -07006054 if (layer_count == VK_REMAINING_ARRAY_LAYERS) {
6055 const uint32_t remaining_layers = image_state->createInfo.arrayLayers - pCreateInfo->subresourceRange.baseArrayLayer;
6056 if (view_type == VK_IMAGE_VIEW_TYPE_CUBE && remaining_layers != 6) {
Jeff Bolz99e3f632020-03-24 22:59:22 -05006057 skip |= LogError(device, "VUID-VkImageViewCreateInfo-viewType-02962",
6058 "vkCreateImageView(): subresourceRange.layerCount VK_REMAINING_ARRAY_LAYERS=(%d) must be 6",
sfricke-samsung20a8a372021-07-14 06:12:17 -07006059 remaining_layers);
Jeff Bolz99e3f632020-03-24 22:59:22 -05006060 }
sfricke-samsung20a8a372021-07-14 06:12:17 -07006061 if (view_type == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY && ((remaining_layers) % 6) != 0) {
Jeff Bolz99e3f632020-03-24 22:59:22 -05006062 skip |= LogError(
6063 device, "VUID-VkImageViewCreateInfo-viewType-02963",
6064 "vkCreateImageView(): subresourceRange.layerCount VK_REMAINING_ARRAY_LAYERS=(%d) must be a multiple of 6",
sfricke-samsung20a8a372021-07-14 06:12:17 -07006065 remaining_layers);
6066 }
6067 if ((remaining_layers != 1) && ((view_type == VK_IMAGE_VIEW_TYPE_1D) || (view_type == VK_IMAGE_VIEW_TYPE_2D) ||
6068 (view_type == VK_IMAGE_VIEW_TYPE_3D))) {
6069 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-imageViewType-04974",
6070 "vkCreateImageView(): Using pCreateInfo->viewType %s and the subresourceRange.layerCount "
6071 "VK_REMAINING_ARRAY_LAYERS=(%d) and must 1 (try looking into VK_IMAGE_VIEW_TYPE_*_ARRAY).",
6072 string_VkImageViewType(view_type), remaining_layers);
6073 }
6074 } else {
6075 if ((layer_count != 1) && ((view_type == VK_IMAGE_VIEW_TYPE_1D) || (view_type == VK_IMAGE_VIEW_TYPE_2D) ||
6076 (view_type == VK_IMAGE_VIEW_TYPE_3D))) {
6077 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-imageViewType-04973",
ziga-lunargc9d29f72022-05-15 19:55:08 +02006078 "vkCreateImageView(): subresourceRange.layerCount (%" PRIu32
6079 ") must be 1 when using viewType %s (try looking into VK_IMAGE_VIEW_TYPE_*_ARRAY).",
6080 layer_count, string_VkImageViewType(view_type));
Jeff Bolz99e3f632020-03-24 22:59:22 -05006081 }
6082 }
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02006083
6084 if (image_usage & VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT) {
ziga-lunarga77a2832022-05-03 11:12:00 +02006085 const auto normalized_subresource_range = image_state->NormalizeSubresourceRange(pCreateInfo->subresourceRange);
6086 if (normalized_subresource_range.levelCount != 1) {
Shannon McPhersonafe55122020-05-25 16:20:19 -06006087 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-02571",
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02006088 "vkCreateImageView(): If image was created with usage containing "
6089 "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, subresourceRange.levelCount (%d) must: be 1",
6090 pCreateInfo->subresourceRange.levelCount);
6091 }
6092 }
6093 if (pCreateInfo->flags & VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT) {
6094 if (!enabled_features.fragment_density_map_features.fragmentDensityMapDynamic) {
Shannon McPhersonafe55122020-05-25 16:20:19 -06006095 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-flags-02572",
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02006096 "vkCreateImageView(): If the fragmentDensityMapDynamic feature is not enabled, "
6097 "flags must not contain VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT");
6098 }
6099 } else {
6100 if (image_usage & VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT) {
6101 if (image_flags & (VK_IMAGE_CREATE_PROTECTED_BIT | VK_IMAGE_CREATE_SPARSE_BINDING_BIT |
6102 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | VK_IMAGE_CREATE_SPARSE_ALIASED_BIT)) {
Shannon McPherson8d0d1f92020-07-06 11:58:21 -06006103 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-flags-04116",
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02006104 "vkCreateImageView(): If image was created with usage containing "
6105 "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT flags must not contain any of "
6106 "VK_IMAGE_CREATE_PROTECTED_BIT, VK_IMAGE_CREATE_SPARSE_BINDING_BIT, "
6107 "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT");
6108 }
6109 }
6110 }
sfricke-samsung0c4a06f2020-06-27 01:24:32 -07006111
ziga-lunarg966ac0e2021-07-18 11:51:44 +02006112 if (image_flags & VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT) {
6113 if (pCreateInfo->subresourceRange.levelCount != 1) {
6114 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-01584",
6115 "vkCreateImageView(): Image was created with VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT bit, "
6116 "but subresourcesRange.levelCount (%" PRIu32 ") is not 1.",
6117 pCreateInfo->subresourceRange.levelCount);
6118 }
6119 if (pCreateInfo->subresourceRange.layerCount != 1) {
6120 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-01584",
6121 "vkCreateImageView(): Image was created with VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT bit, "
6122 "but subresourcesRange.layerCount (%" PRIu32 ") is not 1.",
6123 pCreateInfo->subresourceRange.layerCount);
6124 }
ziga-lunarg966ac0e2021-07-18 11:51:44 +02006125
sfricke-samsungd750f812022-02-04 10:23:34 -08006126 if (!FormatIsCompressed(view_format) && pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_3D) {
6127 skip |=
6128 LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-04739",
ziga-lunargc290c7f2021-07-31 22:01:46 +02006129 "vkCreateImageView(): Image was created with VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT bit and "
6130 "non-compressed format (%s), but pCreateInfo->viewType is VK_IMAGE_VIEW_TYPE_3D.",
6131 string_VkFormat(image_format));
sfricke-samsungd750f812022-02-04 10:23:34 -08006132 }
6133
6134 const bool class_compatible = FormatCompatibilityClass(view_format) == FormatCompatibilityClass(image_format);
6135 // "uncompressed format that is size-compatible" so if compressed, same as not being compatible
6136 const bool size_compatible =
6137 FormatIsCompressed(view_format) ? false : FormatElementSize(view_format) == FormatElementSize(image_format);
6138 if (!class_compatible && !size_compatible) {
6139 skip |=
6140 LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-01583",
6141 "vkCreateImageView(): Image was created with VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT bit and "
6142 "format (%s), but pCreateInfo->format (%s) are not compatible.",
6143 string_VkFormat(image_format), string_VkFormat(view_format));
6144 }
ziga-lunargc290c7f2021-07-31 22:01:46 +02006145 }
6146
janharaldfredriksen-arm36e17572020-07-07 13:59:28 +02006147 if (pCreateInfo->flags & VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT) {
6148 if (!enabled_features.fragment_density_map2_features.fragmentDensityMapDeferred) {
6149 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-flags-03567",
6150 "vkCreateImageView(): If the fragmentDensityMapDeferred feature is not enabled, "
6151 "flags must not contain VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT");
6152 }
6153 if (pCreateInfo->flags & VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT) {
6154 skip |=
6155 LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-flags-03568",
6156 "vkCreateImageView(): If flags contains VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT, "
6157 "flags must not contain VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT");
6158 }
6159 }
sfricke-samsung45996a42021-09-16 13:45:27 -07006160 if (IsExtEnabled(device_extensions.vk_ext_fragment_density_map2)) {
janharaldfredriksen-arm36e17572020-07-07 13:59:28 +02006161 if ((image_flags & VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT) && (image_usage & VK_IMAGE_USAGE_SAMPLED_BIT) &&
sfricke-samsung20a8a372021-07-14 06:12:17 -07006162 (layer_count > phys_dev_ext_props.fragment_density_map2_props.maxSubsampledArrayLayers)) {
janharaldfredriksen-arm36e17572020-07-07 13:59:28 +02006163 skip |= LogError(pCreateInfo->image, "VUID-VkImageViewCreateInfo-image-03569",
6164 "vkCreateImageView(): If image was created with flags containing "
6165 "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT and usage containing VK_IMAGE_USAGE_SAMPLED_BIT "
6166 "subresourceRange.layerCount (%d) must: be less than or equal to maxSubsampledArrayLayers (%d)",
sfricke-samsung20a8a372021-07-14 06:12:17 -07006167 layer_count, phys_dev_ext_props.fragment_density_map2_props.maxSubsampledArrayLayers);
janharaldfredriksen-arm36e17572020-07-07 13:59:28 +02006168 }
6169 }
6170
Mark Lobodzinski1f887d32020-12-30 15:31:33 -07006171 auto astc_decode_mode = LvlFindInChain<VkImageViewASTCDecodeModeEXT>(pCreateInfo->pNext);
sfricke-samsung45996a42021-09-16 13:45:27 -07006172 if (IsExtEnabled(device_extensions.vk_ext_astc_decode_mode) && (astc_decode_mode != nullptr)) {
sfricke-samsung0c4a06f2020-06-27 01:24:32 -07006173 if ((enabled_features.astc_decode_features.decodeModeSharedExponent == VK_FALSE) &&
6174 (astc_decode_mode->decodeMode == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32)) {
6175 skip |= LogError(device, "VUID-VkImageViewASTCDecodeModeEXT-decodeMode-02231",
6176 "vkCreateImageView(): decodeModeSharedExponent is not enabled but "
6177 "VkImageViewASTCDecodeModeEXT::decodeMode is VK_FORMAT_E5B9G9R9_UFLOAT_PACK32.");
6178 }
6179 }
Nathaniel Cesariofe1d5832020-11-13 12:05:55 -07006180
sfricke-samsung45996a42021-09-16 13:45:27 -07006181 if (IsExtEnabled(device_extensions.vk_khr_portability_subset)) {
Nathaniel Cesariofe1d5832020-11-13 12:05:55 -07006182 // If swizzling is disabled, make sure it isn't used
Nathaniel Cesario17d057e2021-06-21 22:58:45 -06006183 // NOTE: as of spec version 1.2.183, VUID 04465 states: "all elements of components _must_ be
6184 // VK_COMPONENT_SWIZZLE_IDENTITY."
6185 // However, issue https://github.com/KhronosGroup/Vulkan-Portability/issues/27 points out that the identity can
6186 // also be defined via R, G, B, A enums in the correct order.
6187 // Spec change is at https://gitlab.khronos.org/vulkan/vulkan/-/merge_requests/4600
Nathaniel Cesariofe1d5832020-11-13 12:05:55 -07006188 if ((VK_FALSE == enabled_features.portability_subset_features.imageViewFormatSwizzle) &&
Nathaniel Cesario17d057e2021-06-21 22:58:45 -06006189 !IsIdentitySwizzle(pCreateInfo->components)) {
Nathaniel Cesariofe1d5832020-11-13 12:05:55 -07006190 skip |= LogError(device, "VUID-VkImageViewCreateInfo-imageViewFormatSwizzle-04465",
6191 "vkCreateImageView (portability error): swizzle is disabled for this device.");
6192 }
6193
6194 // Ensure ImageView's format has the same number of bits and components as Image's format if format reinterpretation is
6195 // disabled
6196 // TODO (ncesario): This is not correct for some cases (e.g., VK_FORMAT_B10G11R11_UFLOAT_PACK32 and
6197 // VK_FORMAT_E5B9G9R9_UFLOAT_PACK32), but requires additional information that should probably be generated from the
6198 // spec. See Github issue #2361.
6199 if ((VK_FALSE == enabled_features.portability_subset_features.imageViewFormatReinterpretation) &&
6200 ((FormatElementSize(pCreateInfo->format, VK_IMAGE_ASPECT_COLOR_BIT) !=
6201 FormatElementSize(image_state->createInfo.format, VK_IMAGE_ASPECT_COLOR_BIT)) ||
sfricke-samsunged028b02021-09-06 23:14:51 -07006202 (FormatComponentCount(pCreateInfo->format) != FormatComponentCount(image_state->createInfo.format)))) {
Nathaniel Cesariofe1d5832020-11-13 12:05:55 -07006203 skip |= LogError(device, "VUID-VkImageViewCreateInfo-imageViewFormatReinterpretation-04466",
6204 "vkCreateImageView (portability error): ImageView format must have"
6205 " the same number of components and bits per component as the Image's format");
6206 }
6207 }
Tony-LunarG69604c42021-11-22 16:00:12 -07006208
6209 auto image_view_min_lod = LvlFindInChain<VkImageViewMinLodCreateInfoEXT>(pCreateInfo->pNext);
6210 if (image_view_min_lod) {
6211 if ((!enabled_features.image_view_min_lod_features.minLod) && (image_view_min_lod->minLod != 0)) {
6212 skip |= LogError(device, "VUID-VkImageViewMinLodCreateInfoEXT-minLod-06455",
6213 "vkCreateImageView(): VkImageViewMinLodCreateInfoEXT::minLod = %f, but the minLod feature is not "
6214 "enabled. If the minLod feature is not enabled, minLod must be 0.0",
6215 image_view_min_lod->minLod);
6216 }
6217 auto max_level = (pCreateInfo->subresourceRange.baseMipLevel + (pCreateInfo->subresourceRange.levelCount - 1));
6218 if (image_view_min_lod->minLod > max_level) {
6219 skip |= LogError(device, "VUID-VkImageViewMinLodCreateInfoEXT-minLod-06456",
6220 "vkCreateImageView(): minLod (%f) must be less or equal to the index of the last mipmap level "
6221 "accessible to the view (%" PRIu32 ")",
6222 image_view_min_lod->minLod, max_level);
6223 }
6224 }
sfricke-samsung0dae8952022-03-03 20:34:23 -06006225
6226 if (FormatRequiresYcbcrConversionExplicitly(view_format)) {
6227 const auto ycbcr_conversion = LvlFindInChain<VkSamplerYcbcrConversionInfo>(pCreateInfo->pNext);
6228 if (!ycbcr_conversion || ycbcr_conversion->conversion == VK_NULL_HANDLE) {
6229 skip |= LogError(
6230 device, "VUID-VkImageViewCreateInfo-format-06415",
6231 "vkCreateImageView(): Format %s requires a VkSamplerYcbcrConversion but one was not passed in the pNext chain.",
6232 string_VkFormat(view_format));
6233 }
6234 }
Mark Lobodzinski602de982017-02-09 11:01:33 -07006235 }
6236 return skip;
6237}
6238
Jeff Leger178b1e52020-10-05 12:22:23 -04006239template <typename RegionType>
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07006240bool CoreChecks::ValidateCmdCopyBufferBounds(const BUFFER_STATE *src_buffer_state, const BUFFER_STATE *dst_buffer_state,
Tony-LunarGef035472021-11-02 10:23:33 -06006241 uint32_t regionCount, const RegionType *pRegions, CMD_TYPE cmd_type) const {
Mark Lobodzinski3438ab62019-09-02 14:19:40 -06006242 bool skip = false;
Tony-LunarGef035472021-11-02 10:23:33 -06006243 const bool is_2 = (cmd_type == CMD_COPYBUFFER2KHR || cmd_type == CMD_COPYBUFFER2);
6244 const char *func_name = CommandTypeString(cmd_type);
Jeff Leger178b1e52020-10-05 12:22:23 -04006245 const char *vuid;
Mark Lobodzinski3438ab62019-09-02 14:19:40 -06006246
6247 VkDeviceSize src_buffer_size = src_buffer_state->createInfo.size;
6248 VkDeviceSize dst_buffer_size = dst_buffer_state->createInfo.size;
Mark Lobodzinski3438ab62019-09-02 14:19:40 -06006249
6250 for (uint32_t i = 0; i < regionCount; i++) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05006251 const RegionType region = pRegions[i];
Mark Lobodzinski3438ab62019-09-02 14:19:40 -06006252
6253 // The srcOffset member of each element of pRegions must be less than the size of srcBuffer
sfricke-samsung71f04e32022-03-16 01:21:21 -05006254 if (region.srcOffset >= src_buffer_size) {
Tony-LunarGef035472021-11-02 10:23:33 -06006255 vuid = is_2 ? "VUID-VkCopyBufferInfo2-srcOffset-00113" : "VUID-vkCmdCopyBuffer-srcOffset-00113";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06006256 skip |= LogError(src_buffer_state->buffer(), vuid,
ziga-lunargd6b58ce2021-10-16 01:22:56 +02006257 "%s: pRegions[%" PRIu32 "].srcOffset (%" PRIuLEAST64
6258 ") is greater than size of srcBuffer (%" PRIuLEAST64 ").",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006259 func_name, i, region.srcOffset, src_buffer_size);
Mark Lobodzinski3438ab62019-09-02 14:19:40 -06006260 }
6261
6262 // The dstOffset member of each element of pRegions must be less than the size of dstBuffer
sfricke-samsung71f04e32022-03-16 01:21:21 -05006263 if (region.dstOffset >= dst_buffer_size) {
Tony-LunarGef035472021-11-02 10:23:33 -06006264 vuid = is_2 ? "VUID-VkCopyBufferInfo2-dstOffset-00114" : "VUID-vkCmdCopyBuffer-dstOffset-00114";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06006265 skip |= LogError(dst_buffer_state->buffer(), vuid,
ziga-lunargd6b58ce2021-10-16 01:22:56 +02006266 "%s: pRegions[%" PRIu32 "].dstOffset (%" PRIuLEAST64
6267 ") is greater than size of dstBuffer (%" PRIuLEAST64 ").",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006268 func_name, i, region.dstOffset, dst_buffer_size);
Mark Lobodzinski3438ab62019-09-02 14:19:40 -06006269 }
6270
6271 // The size member of each element of pRegions must be less than or equal to the size of srcBuffer minus srcOffset
sfricke-samsung71f04e32022-03-16 01:21:21 -05006272 if (region.size > (src_buffer_size - region.srcOffset)) {
Tony-LunarGef035472021-11-02 10:23:33 -06006273 vuid = is_2 ? "VUID-VkCopyBufferInfo2-size-00115" : "VUID-vkCmdCopyBuffer-size-00115";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06006274 skip |= LogError(src_buffer_state->buffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04006275 "%s: pRegions[%d].size (%" PRIuLEAST64 ") is greater than the source buffer size (%" PRIuLEAST64
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07006276 ") minus pRegions[%d].srcOffset (%" PRIuLEAST64 ").",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006277 func_name, i, region.size, src_buffer_size, i, region.srcOffset);
Mark Lobodzinski3438ab62019-09-02 14:19:40 -06006278 }
6279
6280 // The size member of each element of pRegions must be less than or equal to the size of dstBuffer minus dstOffset
sfricke-samsung71f04e32022-03-16 01:21:21 -05006281 if (region.size > (dst_buffer_size - region.dstOffset)) {
Tony-LunarGef035472021-11-02 10:23:33 -06006282 vuid = is_2 ? "VUID-VkCopyBufferInfo2-size-00116" : "VUID-vkCmdCopyBuffer-size-00116";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06006283 skip |= LogError(dst_buffer_state->buffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04006284 "%s: pRegions[%d].size (%" PRIuLEAST64 ") is greater than the destination buffer size (%" PRIuLEAST64
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07006285 ") minus pRegions[%d].dstOffset (%" PRIuLEAST64 ").",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006286 func_name, i, region.size, dst_buffer_size, i, region.dstOffset);
Mark Lobodzinski3438ab62019-09-02 14:19:40 -06006287 }
Mark Lobodzinski3438ab62019-09-02 14:19:40 -06006288
aitor-lunargb66a5fa2022-04-20 00:15:31 +02006289 // Perf improvement potential here
ziga-lunargb94ff002022-03-23 23:30:19 +01006290 // The union of the source regions, and the union of the destination regions, must not overlap in memory
aitor-lunarg26fbbc22022-04-22 18:42:08 +02006291 if (src_buffer_state->buffer() == dst_buffer_state->buffer()) {
6292 VkDeviceSize src_min = region.srcOffset;
6293 VkDeviceSize src_max = region.srcOffset + region.size;
6294 for (uint32_t j = 0; j < regionCount; j++) {
6295 VkDeviceSize dst_min = pRegions[j].dstOffset;
6296 VkDeviceSize dst_max = pRegions[j].dstOffset + region.size;
6297 if (((src_min > dst_min) && (src_min < dst_max)) || ((src_max > dst_min) && (src_max < dst_max)) ||
6298 ((src_min == dst_min && src_max == dst_max))) {
6299 vuid = is_2 ? "VUID-VkCopyBufferInfo2-pRegions-00117" : "VUID-vkCmdCopyBuffer-pRegions-00117";
6300 skip |= LogError(src_buffer_state->buffer(), vuid,
6301 "%s: Detected overlap between source and dest regions in memory.", func_name);
6302 }
ziga-lunargb94ff002022-03-23 23:30:19 +01006303 }
Mark Lobodzinski3438ab62019-09-02 14:19:40 -06006304 }
6305 }
6306
ziga-lunargb94ff002022-03-23 23:30:19 +01006307
Mark Lobodzinski3438ab62019-09-02 14:19:40 -06006308 return skip;
6309}
sfricke-samsung11813ab2021-10-20 14:53:37 -07006310template <typename RegionType>
6311bool CoreChecks::ValidateCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount,
Tony-LunarGef035472021-11-02 10:23:33 -06006312 const RegionType *pRegions, CMD_TYPE cmd_type) const {
Jeremy Gebbenb68fa022022-01-28 10:08:37 -07006313 auto cb_node = GetRead<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenf4449392022-01-28 10:09:10 -07006314 auto src_buffer_state = Get<BUFFER_STATE>(srcBuffer);
6315 auto dst_buffer_state = Get<BUFFER_STATE>(dstBuffer);
Tony-LunarGef035472021-11-02 10:23:33 -06006316 const bool is_2 = (cmd_type == CMD_COPYBUFFER2KHR || cmd_type == CMD_COPYBUFFER2);
sfricke-samsung11813ab2021-10-20 14:53:37 -07006317 const char *func_name = CommandTypeString(cmd_type);
6318 const char *vuid;
6319
Mark Lobodzinski680421d2017-02-09 13:06:56 -07006320 bool skip = false;
Tony-LunarGef035472021-11-02 10:23:33 -06006321 vuid = is_2 ? "VUID-VkCopyBufferInfo2-srcBuffer-00119" : "VUID-vkCmdCopyBuffer-srcBuffer-00119";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006322 skip |= ValidateMemoryIsBoundToBuffer(src_buffer_state.get(), func_name, vuid);
Tony-LunarGef035472021-11-02 10:23:33 -06006323 vuid = is_2 ? "VUID-VkCopyBufferInfo2-dstBuffer-00121" : "VUID-vkCmdCopyBuffer-dstBuffer-00121";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006324 skip |= ValidateMemoryIsBoundToBuffer(dst_buffer_state.get(), func_name, vuid);
sfricke-samsung11813ab2021-10-20 14:53:37 -07006325
Mark Lobodzinski680421d2017-02-09 13:06:56 -07006326 // Validate that SRC & DST buffers have correct usage flags set
Tony-LunarGef035472021-11-02 10:23:33 -06006327 vuid = is_2 ? "VUID-VkCopyBufferInfo2-srcBuffer-00118" : "VUID-vkCmdCopyBuffer-srcBuffer-00118";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006328 skip |= ValidateBufferUsageFlags(src_buffer_state.get(), VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, vuid, func_name,
sfricke-samsung11813ab2021-10-20 14:53:37 -07006329 "VK_BUFFER_USAGE_TRANSFER_SRC_BIT");
Tony-LunarGef035472021-11-02 10:23:33 -06006330 vuid = is_2 ? "VUID-VkCopyBufferInfo2-dstBuffer-00120" : "VUID-vkCmdCopyBuffer-dstBuffer-00120";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006331 skip |= ValidateBufferUsageFlags(dst_buffer_state.get(), VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, vuid, func_name,
sfricke-samsung11813ab2021-10-20 14:53:37 -07006332 "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
6333
Jeremy Gebben9f537102021-10-05 16:37:12 -06006334 skip |= ValidateCmd(cb_node.get(), cmd_type);
Tony-LunarGef035472021-11-02 10:23:33 -06006335 skip |= ValidateCmdCopyBufferBounds(src_buffer_state.get(), dst_buffer_state.get(), regionCount, pRegions, cmd_type);
sfricke-samsung11813ab2021-10-20 14:53:37 -07006336
Tony-LunarGef035472021-11-02 10:23:33 -06006337 vuid = is_2 ? "VUID-vkCmdCopyBuffer2-commandBuffer-01822" : "VUID-vkCmdCopyBuffer-commandBuffer-01822";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006338 skip |= ValidateProtectedBuffer(cb_node.get(), src_buffer_state.get(), func_name, vuid);
Tony-LunarGef035472021-11-02 10:23:33 -06006339 vuid = is_2 ? "VUID-vkCmdCopyBuffer2-commandBuffer-01823" : "VUID-vkCmdCopyBuffer-commandBuffer-01823";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006340 skip |= ValidateProtectedBuffer(cb_node.get(), dst_buffer_state.get(), func_name, vuid);
Tony-LunarGef035472021-11-02 10:23:33 -06006341 vuid = is_2 ? "VUID-vkCmdCopyBuffer2-commandBuffer-01824" : "VUID-vkCmdCopyBuffer-commandBuffer-01824";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006342 skip |= ValidateUnprotectedBuffer(cb_node.get(), dst_buffer_state.get(), func_name, vuid);
Tony-LunarGef035472021-11-02 10:23:33 -06006343
Mark Lobodzinski680421d2017-02-09 13:06:56 -07006344 return skip;
6345}
Mark Lobodzinskiab9be282017-02-09 12:01:27 -07006346
sfricke-samsung11813ab2021-10-20 14:53:37 -07006347bool CoreChecks::PreCallValidateCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
6348 uint32_t regionCount, const VkBufferCopy *pRegions) const {
Tony-LunarGef035472021-11-02 10:23:33 -06006349 return ValidateCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions, CMD_COPYBUFFER);
sfricke-samsung11813ab2021-10-20 14:53:37 -07006350}
6351
Jeff Leger178b1e52020-10-05 12:22:23 -04006352bool CoreChecks::PreCallValidateCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
6353 const VkCopyBufferInfo2KHR *pCopyBufferInfos) const {
sfricke-samsung11813ab2021-10-20 14:53:37 -07006354 return ValidateCmdCopyBuffer(commandBuffer, pCopyBufferInfos->srcBuffer, pCopyBufferInfos->dstBuffer,
Tony-LunarGef035472021-11-02 10:23:33 -06006355 pCopyBufferInfos->regionCount, pCopyBufferInfos->pRegions, CMD_COPYBUFFER2KHR);
6356}
6357
6358bool CoreChecks::PreCallValidateCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfos) const {
6359 return ValidateCmdCopyBuffer(commandBuffer, pCopyBufferInfos->srcBuffer, pCopyBufferInfos->dstBuffer,
6360 pCopyBufferInfos->regionCount, pCopyBufferInfos->pRegions, CMD_COPYBUFFER2);
Jeff Leger178b1e52020-10-05 12:22:23 -04006361}
6362
Jeff Bolz46c0ea02019-10-09 13:06:29 -05006363bool CoreChecks::ValidateIdleBuffer(VkBuffer buffer) const {
Mark Lobodzinski306441e2017-02-10 13:48:38 -07006364 bool skip = false;
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06006365 auto buffer_state = Get<BUFFER_STATE>(buffer);
sfricke-samsung9c7d8552020-08-16 22:12:21 -07006366 if (buffer_state) {
Jeremy Gebben9efe1cf2021-05-15 20:05:09 -06006367 if (buffer_state->InUse()) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07006368 skip |= LogError(buffer, "VUID-vkDestroyBuffer-buffer-00922", "Cannot free %s that is in use by a command buffer.",
6369 report_data->FormatHandle(buffer).c_str());
Mark Lobodzinski306441e2017-02-10 13:48:38 -07006370 }
6371 }
6372 return skip;
6373}
6374
Jeff Bolz5c801d12019-10-09 10:38:45 -05006375bool CoreChecks::PreCallValidateDestroyImageView(VkDevice device, VkImageView imageView,
6376 const VkAllocationCallbacks *pAllocator) const {
Jeremy Gebbenf4449392022-01-28 10:09:10 -07006377 auto image_view_state = Get<IMAGE_VIEW_STATE>(imageView);
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07006378
Mark Lobodzinski306441e2017-02-10 13:48:38 -07006379 bool skip = false;
Mark Lobodzinskic8c8d0d2019-01-10 12:55:26 -07006380 if (image_view_state) {
Jeremy Gebben9f537102021-10-05 16:37:12 -06006381 skip |= ValidateObjectNotInUse(image_view_state.get(), "vkDestroyImageView", "VUID-vkDestroyImageView-imageView-01026");
Mark Lobodzinski306441e2017-02-10 13:48:38 -07006382 }
6383 return skip;
6384}
6385
Jeff Bolz5c801d12019-10-09 10:38:45 -05006386bool CoreChecks::PreCallValidateDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) const {
Jeremy Gebben9f537102021-10-05 16:37:12 -06006387 return ValidateIdleBuffer(buffer);
Mark Lobodzinski306441e2017-02-10 13:48:38 -07006388}
6389
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07006390bool CoreChecks::PreCallValidateDestroyBufferView(VkDevice device, VkBufferView bufferView,
Jeff Bolz5c801d12019-10-09 10:38:45 -05006391 const VkAllocationCallbacks *pAllocator) const {
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06006392 auto buffer_view_state = Get<BUFFER_VIEW_STATE>(bufferView);
Mark Lobodzinski306441e2017-02-10 13:48:38 -07006393 bool skip = false;
Mark Lobodzinskidd995d22019-01-11 11:05:15 -07006394 if (buffer_view_state) {
Jeremy Gebben9f537102021-10-05 16:37:12 -06006395 skip |= ValidateObjectNotInUse(buffer_view_state.get(), "vkDestroyBufferView", "VUID-vkDestroyBufferView-bufferView-00936");
Mark Lobodzinski306441e2017-02-10 13:48:38 -07006396 }
6397 return skip;
6398}
6399
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07006400bool CoreChecks::PreCallValidateCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
Jeff Bolz5c801d12019-10-09 10:38:45 -05006401 VkDeviceSize size, uint32_t data) const {
Jeremy Gebbenb68fa022022-01-28 10:08:37 -07006402 auto cb_node = GetRead<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06006403 auto buffer_state = Get<BUFFER_STATE>(dstBuffer);
Mark Lobodzinskidf0acbf2017-02-10 14:01:27 -07006404 bool skip = false;
Jeremy Gebben9f537102021-10-05 16:37:12 -06006405 skip |= ValidateMemoryIsBoundToBuffer(buffer_state.get(), "vkCmdFillBuffer()", "VUID-vkCmdFillBuffer-dstBuffer-00031");
6406 skip |= ValidateCmd(cb_node.get(), CMD_FILLBUFFER);
Mark Lobodzinskidf0acbf2017-02-10 14:01:27 -07006407 // Validate that DST buffer has correct usage flags set
Jeremy Gebben9f537102021-10-05 16:37:12 -06006408 skip |=
6409 ValidateBufferUsageFlags(buffer_state.get(), VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "VUID-vkCmdFillBuffer-dstBuffer-00029",
6410 "vkCmdFillBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
Mark Lobodzinski693fbfd2019-12-03 16:06:30 -07006411
Jeremy Gebben9f537102021-10-05 16:37:12 -06006412 skip |=
6413 ValidateProtectedBuffer(cb_node.get(), buffer_state.get(), "vkCmdFillBuffer()", "VUID-vkCmdFillBuffer-commandBuffer-01811");
6414 skip |= ValidateUnprotectedBuffer(cb_node.get(), buffer_state.get(), "vkCmdFillBuffer()",
6415 "VUID-vkCmdFillBuffer-commandBuffer-01812");
sfricke-samsung022fa252020-07-24 03:26:16 -07006416
Mark Lobodzinski693fbfd2019-12-03 16:06:30 -07006417 if (dstOffset >= buffer_state->createInfo.size) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07006418 skip |= LogError(dstBuffer, "VUID-vkCmdFillBuffer-dstOffset-00024",
6419 "vkCmdFillBuffer(): dstOffset (0x%" PRIxLEAST64
6420 ") is not less than destination buffer (%s) size (0x%" PRIxLEAST64 ").",
6421 dstOffset, report_data->FormatHandle(dstBuffer).c_str(), buffer_state->createInfo.size);
Mark Lobodzinski693fbfd2019-12-03 16:06:30 -07006422 }
6423
6424 if ((size != VK_WHOLE_SIZE) && (size > (buffer_state->createInfo.size - dstOffset))) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07006425 skip |= LogError(dstBuffer, "VUID-vkCmdFillBuffer-size-00027",
6426 "vkCmdFillBuffer(): size (0x%" PRIxLEAST64 ") is greater than dstBuffer (%s) size (0x%" PRIxLEAST64
6427 ") minus dstOffset (0x%" PRIxLEAST64 ").",
6428 size, report_data->FormatHandle(dstBuffer).c_str(), buffer_state->createInfo.size, dstOffset);
Mark Lobodzinski693fbfd2019-12-03 16:06:30 -07006429 }
6430
sfricke-samsung45996a42021-09-16 13:45:27 -07006431 if (!IsExtEnabled(device_extensions.vk_khr_maintenance1)) {
Jeremy Gebben9f537102021-10-05 16:37:12 -06006432 skip |= ValidateCmdQueueFlags(cb_node.get(), "vkCmdFillBuffer()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT,
ziga-lunarg3c5c84e2021-08-04 15:18:56 +02006433 "VUID-vkCmdFillBuffer-commandBuffer-00030");
6434 }
6435
Mark Lobodzinskidf0acbf2017-02-10 14:01:27 -07006436 return skip;
6437}
6438
sfricke-samsung71f04e32022-03-16 01:21:21 -05006439template <typename RegionType>
6440bool CoreChecks::ValidateBufferImageCopyData(const CMD_BUFFER_STATE *cb_node, uint32_t regionCount, const RegionType *pRegions,
6441 const IMAGE_STATE *image_state, const char *function, CMD_TYPE cmd_type,
6442 bool image_to_buffer) const {
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07006443 bool skip = false;
Tony Barbour845d29b2021-11-09 11:43:14 -07006444 const bool is_2 = (cmd_type == CMD_COPYBUFFERTOIMAGE2KHR || cmd_type == CMD_COPYBUFFERTOIMAGE2);
sfricke-samsung03f6ffd2020-10-21 01:12:08 -07006445 const char *vuid;
Jeff Leger178b1e52020-10-05 12:22:23 -04006446
sfricke-samsung125d2b42020-05-28 06:32:43 -07006447 assert(image_state != nullptr);
6448 const VkFormat image_format = image_state->createInfo.format;
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07006449
6450 for (uint32_t i = 0; i < regionCount; i++) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05006451 const RegionType region = pRegions[i];
6452 const VkImageAspectFlags region_aspect_mask = region.imageSubresource.aspectMask;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006453 if (image_state->createInfo.imageType == VK_IMAGE_TYPE_1D) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05006454 if ((region.imageOffset.y != 0) || (region.imageExtent.height != 1)) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006455 skip |= LogError(image_state->image(), GetBufferImageCopyCommandVUID("00199", image_to_buffer, is_2),
Jeff Leger178b1e52020-10-05 12:22:23 -04006456 "%s: pRegion[%d] imageOffset.y is %d and imageExtent.height is %d. For 1D images these must be 0 "
6457 "and 1, respectively.",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006458 function, i, region.imageOffset.y, region.imageExtent.height);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07006459 }
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006460 }
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07006461
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006462 if ((image_state->createInfo.imageType == VK_IMAGE_TYPE_1D) || (image_state->createInfo.imageType == VK_IMAGE_TYPE_2D)) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05006463 if ((region.imageOffset.z != 0) || (region.imageExtent.depth != 1)) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006464 skip |= LogError(image_state->image(), GetBufferImageCopyCommandVUID("00201", image_to_buffer, is_2),
Jeff Leger178b1e52020-10-05 12:22:23 -04006465 "%s: pRegion[%d] imageOffset.z is %d and imageExtent.depth is %d. For 1D and 2D images these "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07006466 "must be 0 and 1, respectively.",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006467 function, i, region.imageOffset.z, region.imageExtent.depth);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07006468 }
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006469 }
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07006470
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006471 if (image_state->createInfo.imageType == VK_IMAGE_TYPE_3D) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05006472 if ((0 != region.imageSubresource.baseArrayLayer) || (1 != region.imageSubresource.layerCount)) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006473 skip |= LogError(image_state->image(), GetBufferImageCopyCommandVUID("00213", image_to_buffer, is_2),
Jeff Leger178b1e52020-10-05 12:22:23 -04006474 "%s: pRegion[%d] imageSubresource.baseArrayLayer is %d and imageSubresource.layerCount is %d. "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07006475 "For 3D images these must be 0 and 1, respectively.",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006476 function, i, region.imageSubresource.baseArrayLayer, region.imageSubresource.layerCount);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006477 }
6478 }
6479
6480 // If the the calling command's VkImage parameter's format is not a depth/stencil format,
Dave Houltona585d132019-01-18 13:05:42 -07006481 // then bufferOffset must be a multiple of the calling command's VkImage parameter's element size
sfricke-samsung73e755c2021-09-30 08:34:57 -07006482 const uint32_t element_size =
6483 FormatIsDepthOrStencil(image_format) ? 0 : FormatElementSize(image_format, region_aspect_mask);
sfricke-samsung71f04e32022-03-16 01:21:21 -05006484 const VkDeviceSize bufferOffset = region.bufferOffset;
Locke497739c2019-03-08 11:50:47 -07006485
sfricke-samsung8feecc12021-01-23 03:28:38 -08006486 if (FormatIsDepthOrStencil(image_format)) {
6487 if (SafeModulo(bufferOffset, 4) != 0) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006488 skip |= LogError(image_state->image(), GetBufferImageCopyCommandVUID("04053", image_to_buffer, is_2),
sfricke-samsung8feecc12021-01-23 03:28:38 -08006489 "%s: pRegion[%d] bufferOffset 0x%" PRIxLEAST64
6490 " must be a multiple 4 if using a depth/stencil format (%s).",
6491 function, i, bufferOffset, string_VkFormat(image_format));
6492 }
6493 } else {
6494 // If not depth/stencil and not multi-plane
6495 if (!FormatIsMultiplane(image_format) && (SafeModulo(bufferOffset, element_size) != 0)) {
sfricke-samsung45996a42021-09-16 13:45:27 -07006496 vuid = IsExtEnabled(device_extensions.vk_khr_sampler_ycbcr_conversion)
Tony Barbour845d29b2021-11-09 11:43:14 -07006497 ? GetBufferImageCopyCommandVUID("01558", image_to_buffer, is_2)
6498 : GetBufferImageCopyCommandVUID("00193", image_to_buffer, is_2);
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06006499 skip |= LogError(image_state->image(), vuid,
sfricke-samsung8feecc12021-01-23 03:28:38 -08006500 "%s: pRegion[%d] bufferOffset 0x%" PRIxLEAST64
6501 " must be a multiple of this format's texel size (%" PRIu32 ").",
6502 function, i, bufferOffset, element_size);
6503 }
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006504 }
6505
sfricke-samsung5f11b0e2022-03-22 14:12:15 -05006506 // Make sure not a empty region
6507 if (region.imageExtent.width == 0) {
6508 vuid = is_2 ? "VUID-VkBufferImageCopy2-imageExtent-06659" : "VUID-VkBufferImageCopy-imageExtent-06659";
6509 LogObjectList objlist(cb_node->commandBuffer());
6510 objlist.add(image_state->image());
6511 skip |=
6512 LogError(objlist, vuid, "%s: pRegion[%" PRIu32 "] extent.width must not be zero as empty copies are not allowed.",
6513 function, i);
6514 }
6515 if (region.imageExtent.height == 0) {
6516 vuid = is_2 ? "VUID-VkBufferImageCopy2-imageExtent-06660" : "VUID-VkBufferImageCopy-imageExtent-06660";
6517 LogObjectList objlist(cb_node->commandBuffer());
6518 objlist.add(image_state->image());
6519 skip |=
6520 LogError(objlist, vuid, "%s: pRegion[%" PRIu32 "] extent.height must not be zero as empty copies are not allowed.",
6521 function, i);
6522 }
6523 if (region.imageExtent.depth == 0) {
6524 vuid = is_2 ? "VUID-VkBufferImageCopy2-imageExtent-06661" : "VUID-VkBufferImageCopy-imageExtent-06661";
6525 LogObjectList objlist(cb_node->commandBuffer());
6526 objlist.add(image_state->image());
6527 skip |=
6528 LogError(objlist, vuid, "%s: pRegion[%" PRIu32 "] extent.depth must not be zero as empty copies are not allowed.",
6529 function, i);
6530 }
6531
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006532 // BufferRowLength must be 0, or greater than or equal to the width member of imageExtent
sfricke-samsung71f04e32022-03-16 01:21:21 -05006533 if ((region.bufferRowLength != 0) && (region.bufferRowLength < region.imageExtent.width)) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006534 vuid = (is_2) ? "VUID-VkBufferImageCopy2-bufferRowLength-00195" : "VUID-VkBufferImageCopy-bufferRowLength-00195";
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06006535 skip |=
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06006536 LogError(image_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04006537 "%s: pRegion[%d] bufferRowLength (%d) must be zero or greater-than-or-equal-to imageExtent.width (%d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006538 function, i, region.bufferRowLength, region.imageExtent.width);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006539 }
6540
6541 // BufferImageHeight must be 0, or greater than or equal to the height member of imageExtent
sfricke-samsung71f04e32022-03-16 01:21:21 -05006542 if ((region.bufferImageHeight != 0) && (region.bufferImageHeight < region.imageExtent.height)) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006543 vuid = (is_2) ? "VUID-VkBufferImageCopy2-bufferImageHeight-00196" : "VUID-VkBufferImageCopy-bufferImageHeight-00196";
Jeff Leger178b1e52020-10-05 12:22:23 -04006544 skip |=
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06006545 LogError(image_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04006546 "%s: pRegion[%d] bufferImageHeight (%d) must be zero or greater-than-or-equal-to imageExtent.height (%d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006547 function, i, region.bufferImageHeight, region.imageExtent.height);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006548 }
6549
Mark Lobodzinskia8f6f5b2019-06-14 07:41:19 -06006550 // Calculate adjusted image extent, accounting for multiplane image factors
sfricke-samsung71f04e32022-03-16 01:21:21 -05006551 VkExtent3D adjusted_image_extent = image_state->GetSubresourceExtent(region.imageSubresource);
Mark Lobodzinskia8f6f5b2019-06-14 07:41:19 -06006552 // imageOffset.x and (imageExtent.width + imageOffset.x) must both be >= 0 and <= image subresource width
sfricke-samsung71f04e32022-03-16 01:21:21 -05006553 if ((region.imageOffset.x < 0) || (region.imageOffset.x > static_cast<int32_t>(adjusted_image_extent.width)) ||
6554 ((region.imageOffset.x + static_cast<int32_t>(region.imageExtent.width)) >
Mark Lobodzinski72b1a222020-03-18 11:36:10 -06006555 static_cast<int32_t>(adjusted_image_extent.width))) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006556 skip |= LogError(image_state->image(), GetBufferImageCopyCommandVUID("00197", image_to_buffer, is_2),
Jeff Leger178b1e52020-10-05 12:22:23 -04006557 "%s: Both pRegion[%d] imageoffset.x (%d) and (imageExtent.width + imageOffset.x) (%d) must be >= "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07006558 "zero or <= image subresource width (%d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006559 function, i, region.imageOffset.x, (region.imageOffset.x + region.imageExtent.width),
Mark Lobodzinski27c824b2020-03-18 11:26:59 -06006560 adjusted_image_extent.width);
Mark Lobodzinskia8f6f5b2019-06-14 07:41:19 -06006561 }
6562
6563 // imageOffset.y and (imageExtent.height + imageOffset.y) must both be >= 0 and <= image subresource height
sfricke-samsung71f04e32022-03-16 01:21:21 -05006564 if ((region.imageOffset.y < 0) || (region.imageOffset.y > static_cast<int32_t>(adjusted_image_extent.height)) ||
6565 ((region.imageOffset.y + static_cast<int32_t>(region.imageExtent.height)) >
Mark Lobodzinski72b1a222020-03-18 11:36:10 -06006566 static_cast<int32_t>(adjusted_image_extent.height))) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006567 skip |= LogError(image_state->image(), GetBufferImageCopyCommandVUID("00198", image_to_buffer, is_2),
Jeff Leger178b1e52020-10-05 12:22:23 -04006568 "%s: Both pRegion[%d] imageoffset.y (%d) and (imageExtent.height + imageOffset.y) (%d) must be >= "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07006569 "zero or <= image subresource height (%d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006570 function, i, region.imageOffset.y, (region.imageOffset.y + region.imageExtent.height),
Mark Lobodzinski27c824b2020-03-18 11:26:59 -06006571 adjusted_image_extent.height);
Mark Lobodzinskia8f6f5b2019-06-14 07:41:19 -06006572 }
6573
6574 // imageOffset.z and (imageExtent.depth + imageOffset.z) must both be >= 0 and <= image subresource depth
sfricke-samsung71f04e32022-03-16 01:21:21 -05006575 if ((region.imageOffset.z < 0) || (region.imageOffset.z > static_cast<int32_t>(adjusted_image_extent.depth)) ||
6576 ((region.imageOffset.z + static_cast<int32_t>(region.imageExtent.depth)) >
Mark Lobodzinski72b1a222020-03-18 11:36:10 -06006577 static_cast<int32_t>(adjusted_image_extent.depth))) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006578 skip |= LogError(image_state->image(), GetBufferImageCopyCommandVUID("00200", image_to_buffer, is_2),
Jeff Leger178b1e52020-10-05 12:22:23 -04006579 "%s: Both pRegion[%d] imageoffset.z (%d) and (imageExtent.depth + imageOffset.z) (%d) must be >= "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07006580 "zero or <= image subresource depth (%d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006581 function, i, region.imageOffset.z, (region.imageOffset.z + region.imageExtent.depth),
Mark Lobodzinski27c824b2020-03-18 11:26:59 -06006582 adjusted_image_extent.depth);
Mark Lobodzinskia8f6f5b2019-06-14 07:41:19 -06006583 }
6584
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006585 // subresource aspectMask must have exactly 1 bit set
6586 const int num_bits = sizeof(VkFlags) * CHAR_BIT;
sfricke-samsung125d2b42020-05-28 06:32:43 -07006587 std::bitset<num_bits> aspect_mask_bits(region_aspect_mask);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006588 if (aspect_mask_bits.count() != 1) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006589 vuid = (is_2) ? "VUID-VkBufferImageCopy2-aspectMask-00212" : "VUID-VkBufferImageCopy-aspectMask-00212";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06006590 skip |= LogError(image_state->image(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04006591 "%s: aspectMasks for imageSubresource in pRegion[%d] must have only a single bit set.", function, i);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006592 }
6593
6594 // image subresource aspect bit must match format
sfricke-samsung125d2b42020-05-28 06:32:43 -07006595 if (!VerifyAspectsPresent(region_aspect_mask, image_format)) {
Jeff Leger178b1e52020-10-05 12:22:23 -04006596 skip |=
Tony Barbour845d29b2021-11-09 11:43:14 -07006597 LogError(image_state->image(), GetBufferImageCopyCommandVUID("00211", image_to_buffer, is_2),
Jeff Leger178b1e52020-10-05 12:22:23 -04006598 "%s: pRegion[%d] subresource aspectMask 0x%x specifies aspects that are not present in image format 0x%x.",
6599 function, i, region_aspect_mask, image_format);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006600 }
6601
6602 // Checks that apply only to compressed images
sfricke-samsung01da6312021-10-20 07:51:32 -07006603 if (FormatIsBlockedImage(image_format)) {
sfricke-samsung125d2b42020-05-28 06:32:43 -07006604 auto block_size = FormatTexelBlockExtent(image_format);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006605
6606 // BufferRowLength must be a multiple of block width
sfricke-samsung71f04e32022-03-16 01:21:21 -05006607 if (SafeModulo(region.bufferRowLength, block_size.width) != 0) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006608 skip |= LogError(image_state->image(), GetBufferImageCopyCommandVUID("00203", image_to_buffer, is_2),
sfricke-samsung01da6312021-10-20 07:51:32 -07006609 "%s: pRegion[%d] bufferRowLength (%d) must be a multiple of the blocked image's texel width (%d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006610 function, i, region.bufferRowLength, block_size.width);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07006611 }
6612
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006613 // BufferRowHeight must be a multiple of block height
sfricke-samsung71f04e32022-03-16 01:21:21 -05006614 if (SafeModulo(region.bufferImageHeight, block_size.height) != 0) {
sfricke-samsung01da6312021-10-20 07:51:32 -07006615 skip |=
Tony Barbour845d29b2021-11-09 11:43:14 -07006616 LogError(image_state->image(), GetBufferImageCopyCommandVUID("00204", image_to_buffer, is_2),
sfricke-samsung01da6312021-10-20 07:51:32 -07006617 "%s: pRegion[%d] bufferImageHeight (%d) must be a multiple of the blocked image's texel height (%d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006618 function, i, region.bufferImageHeight, block_size.height);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07006619 }
6620
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006621 // image offsets must be multiples of block dimensions
sfricke-samsung71f04e32022-03-16 01:21:21 -05006622 if ((SafeModulo(region.imageOffset.x, block_size.width) != 0) ||
6623 (SafeModulo(region.imageOffset.y, block_size.height) != 0) ||
6624 (SafeModulo(region.imageOffset.z, block_size.depth) != 0)) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006625 skip |= LogError(image_state->image(), GetBufferImageCopyCommandVUID("00205", image_to_buffer, is_2),
sfricke-samsung01da6312021-10-20 07:51:32 -07006626 "%s: pRegion[%d] imageOffset(x,y) (%d, %d) must be multiples of the blocked image's texel "
Petr Krausb0d5e592021-05-21 23:37:11 +02006627 "width & height (%d, %d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006628 function, i, region.imageOffset.x, region.imageOffset.y, block_size.width, block_size.height);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07006629 }
6630
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006631 // bufferOffset must be a multiple of block size (linear bytes)
sfricke-samsung73e755c2021-09-30 08:34:57 -07006632 if (SafeModulo(bufferOffset, element_size) != 0) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006633 skip |= LogError(image_state->image(), GetBufferImageCopyCommandVUID("00206", image_to_buffer, is_2),
Jeff Leger178b1e52020-10-05 12:22:23 -04006634 "%s: pRegion[%d] bufferOffset (0x%" PRIxLEAST64
sfricke-samsung01da6312021-10-20 07:51:32 -07006635 ") must be a multiple of the blocked image's texel block size (%" PRIu32 ").",
sfricke-samsung73e755c2021-09-30 08:34:57 -07006636 function, i, bufferOffset, element_size);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07006637 }
Dave Houlton67e9b532017-03-02 17:00:10 -07006638
6639 // imageExtent width must be a multiple of block width, or extent+offset width must equal subresource width
sfricke-samsung71f04e32022-03-16 01:21:21 -05006640 VkExtent3D mip_extent = image_state->GetSubresourceExtent(region.imageSubresource);
6641 if ((SafeModulo(region.imageExtent.width, block_size.width) != 0) &&
6642 (region.imageExtent.width + region.imageOffset.x != mip_extent.width)) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006643 skip |= LogError(image_state->image(), GetBufferImageCopyCommandVUID("00207", image_to_buffer, is_2),
sfricke-samsung01da6312021-10-20 07:51:32 -07006644 "%s: pRegion[%d] extent width (%d) must be a multiple of the blocked texture block width "
Petr Krausb0d5e592021-05-21 23:37:11 +02006645 "(%d), or when added to offset.x (%d) must equal the image subresource width (%d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006646 function, i, region.imageExtent.width, block_size.width, region.imageOffset.x, mip_extent.width);
Dave Houlton67e9b532017-03-02 17:00:10 -07006647 }
6648
6649 // imageExtent height must be a multiple of block height, or extent+offset height must equal subresource height
sfricke-samsung71f04e32022-03-16 01:21:21 -05006650 if ((SafeModulo(region.imageExtent.height, block_size.height) != 0) &&
6651 (region.imageExtent.height + region.imageOffset.y != mip_extent.height)) {
6652 skip |=
6653 LogError(image_state->image(), GetBufferImageCopyCommandVUID("00208", image_to_buffer, is_2),
6654 "%s: pRegion[%d] extent height (%d) must be a multiple of the blocked texture block height "
6655 "(%d), or when added to offset.y (%d) must equal the image subresource height (%d).",
6656 function, i, region.imageExtent.height, block_size.height, region.imageOffset.y, mip_extent.height);
Dave Houlton67e9b532017-03-02 17:00:10 -07006657 }
6658
6659 // imageExtent depth must be a multiple of block depth, or extent+offset depth must equal subresource depth
sfricke-samsung71f04e32022-03-16 01:21:21 -05006660 if ((SafeModulo(region.imageExtent.depth, block_size.depth) != 0) &&
6661 (region.imageExtent.depth + region.imageOffset.z != mip_extent.depth)) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006662 skip |= LogError(image_state->image(), GetBufferImageCopyCommandVUID("00209", image_to_buffer, is_2),
sfricke-samsung01da6312021-10-20 07:51:32 -07006663 "%s: pRegion[%d] extent width (%d) must be a multiple of the blocked texture block depth "
Petr Krausb0d5e592021-05-21 23:37:11 +02006664 "(%d), or when added to offset.z (%d) must equal the image subresource depth (%d).",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006665 function, i, region.imageExtent.depth, block_size.depth, region.imageOffset.z, mip_extent.depth);
Dave Houlton67e9b532017-03-02 17:00:10 -07006666 }
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006667 }
sfricke-samsung552d5e12020-01-07 22:00:20 -08006668
6669 // Checks that apply only to multi-planar format images
sfricke-samsung125d2b42020-05-28 06:32:43 -07006670 if (FormatIsMultiplane(image_format)) {
sfricke-samsung552d5e12020-01-07 22:00:20 -08006671 // VK_IMAGE_ASPECT_PLANE_2_BIT valid only for image formats with three planes
sfricke-samsung125d2b42020-05-28 06:32:43 -07006672 if ((FormatPlaneCount(image_format) < 3) && (region_aspect_mask == VK_IMAGE_ASPECT_PLANE_2_BIT)) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006673 skip |= LogError(image_state->image(), GetBufferImageCopyCommandVUID("01560", image_to_buffer, is_2),
Jeff Leger178b1e52020-10-05 12:22:23 -04006674 "%s: pRegion[%d] subresource aspectMask cannot be VK_IMAGE_ASPECT_PLANE_2_BIT unless image "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07006675 "format has three planes.",
6676 function, i);
sfricke-samsung552d5e12020-01-07 22:00:20 -08006677 }
6678
6679 // image subresource aspectMask must be VK_IMAGE_ASPECT_PLANE_*_BIT
sfricke-samsung125d2b42020-05-28 06:32:43 -07006680 if (0 ==
6681 (region_aspect_mask & (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT | VK_IMAGE_ASPECT_PLANE_2_BIT))) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006682 skip |= LogError(image_state->image(), GetBufferImageCopyCommandVUID("01560", image_to_buffer, is_2),
Jeff Leger178b1e52020-10-05 12:22:23 -04006683 "%s: pRegion[%d] subresource aspectMask for multi-plane image formats must have a "
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07006684 "VK_IMAGE_ASPECT_PLANE_*_BIT when copying to or from.",
6685 function, i);
sfricke-samsung125d2b42020-05-28 06:32:43 -07006686 } else {
6687 // Know aspect mask is valid
6688 const VkFormat compatible_format = FindMultiplaneCompatibleFormat(image_format, region_aspect_mask);
6689 const uint32_t compatible_size = FormatElementSize(compatible_format);
sfricke-samsung8feecc12021-01-23 03:28:38 -08006690 if (SafeModulo(bufferOffset, compatible_size) != 0) {
sfricke-samsung125d2b42020-05-28 06:32:43 -07006691 skip |= LogError(
Tony Barbour845d29b2021-11-09 11:43:14 -07006692 image_state->image(), GetBufferImageCopyCommandVUID("01559", image_to_buffer, is_2),
Jeff Leger178b1e52020-10-05 12:22:23 -04006693 "%s: pRegion[%d]->bufferOffset is 0x%" PRIxLEAST64
sfricke-samsung125d2b42020-05-28 06:32:43 -07006694 " but must be a multiple of the multi-plane compatible format's texel size (%u) for plane %u (%s).",
sfricke-samsung8feecc12021-01-23 03:28:38 -08006695 function, i, bufferOffset, element_size, GetPlaneIndex(region_aspect_mask),
sfricke-samsung125d2b42020-05-28 06:32:43 -07006696 string_VkFormat(compatible_format));
6697 }
sfricke-samsung552d5e12020-01-07 22:00:20 -08006698 }
6699 }
sfricke-samsung8feecc12021-01-23 03:28:38 -08006700
6701 // TODO - Don't use ValidateCmdQueueFlags due to currently not having way to add more descriptive message
Jeremy Gebbencd7fa282021-10-27 10:25:32 -06006702 const COMMAND_POOL_STATE *command_pool = cb_node->command_pool;
sfricke-samsung8feecc12021-01-23 03:28:38 -08006703 assert(command_pool != nullptr);
6704 const uint32_t queue_family_index = command_pool->queueFamilyIndex;
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06006705 const VkQueueFlags queue_flags = physical_device_state->queue_family_properties[queue_family_index].queueFlags;
sfricke-samsung8feecc12021-01-23 03:28:38 -08006706 if (((queue_flags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT)) == 0) && (SafeModulo(bufferOffset, 4) != 0)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06006707 LogObjectList objlist(cb_node->commandBuffer());
6708 objlist.add(command_pool->commandPool());
sfricke-samsung4389faa2022-03-23 01:19:42 -05006709 objlist.add(image_state->image());
6710 skip |= LogError(objlist, GetBufferImageCopyCommandVUID("04052", image_to_buffer, is_2),
sfricke-samsung8feecc12021-01-23 03:28:38 -08006711 "%s: pRegion[%d] bufferOffset 0x%" PRIxLEAST64
6712 " must be a multiple 4 because the command buffer %s was allocated from the command pool %s "
6713 "which was created with queueFamilyIndex %u, which doesn't contain the VK_QUEUE_GRAPHICS_BIT or "
6714 "VK_QUEUE_COMPUTE_BIT flag.",
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06006715 function, i, bufferOffset, report_data->FormatHandle(cb_node->commandBuffer()).c_str(),
6716 report_data->FormatHandle(command_pool->commandPool()).c_str(), queue_family_index);
sfricke-samsung8feecc12021-01-23 03:28:38 -08006717 }
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006718 }
6719
6720 return skip;
6721}
6722
sfricke-samsung71f04e32022-03-16 01:21:21 -05006723template <typename RegionType>
6724bool CoreChecks::ValidateImageBounds(const IMAGE_STATE *image_state, const uint32_t regionCount, const RegionType *pRegions,
6725 const char *func_name, const char *msg_code) const {
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006726 bool skip = false;
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006727 const VkImageCreateInfo *image_info = &(image_state->createInfo);
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006728
6729 for (uint32_t i = 0; i < regionCount; i++) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05006730 const RegionType region = pRegions[i];
6731 VkExtent3D extent = region.imageExtent;
6732 VkOffset3D offset = region.imageOffset;
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006733
sfricke-samsung71f04e32022-03-16 01:21:21 -05006734 VkExtent3D image_extent = image_state->GetSubresourceExtent(region.imageSubresource);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006735
sfricke-samsung01da6312021-10-20 07:51:32 -07006736 // If we're using a blocked image format, valid extent is rounded up to multiple of block size (per
6737 // vkspec.html#_common_operation)
6738 if (FormatIsBlockedImage(image_info->format)) {
Dave Houltona585d132019-01-18 13:05:42 -07006739 auto block_extent = FormatTexelBlockExtent(image_info->format);
Dave Houlton9dae7ec2017-03-01 16:23:25 -07006740 if (image_extent.width % block_extent.width) {
6741 image_extent.width += (block_extent.width - (image_extent.width % block_extent.width));
6742 }
6743 if (image_extent.height % block_extent.height) {
6744 image_extent.height += (block_extent.height - (image_extent.height % block_extent.height));
6745 }
6746 if (image_extent.depth % block_extent.depth) {
6747 image_extent.depth += (block_extent.depth - (image_extent.depth % block_extent.depth));
6748 }
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006749 }
6750
Dave Houltonfc1a4052017-04-27 14:32:45 -06006751 if (0 != ExceedsBounds(&offset, &extent, &image_extent)) {
Petr Krausb0d5e592021-05-21 23:37:11 +02006752 skip |= LogError(image_state->image(), msg_code, "%s: pRegion[%d] exceeds image bounds.", func_name, i);
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07006753 }
6754 }
6755
6756 return skip;
6757}
6758
sfricke-samsung71f04e32022-03-16 01:21:21 -05006759template <typename RegionType>
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07006760bool CoreChecks::ValidateBufferBounds(const IMAGE_STATE *image_state, const BUFFER_STATE *buff_state, uint32_t regionCount,
sfricke-samsung71f04e32022-03-16 01:21:21 -05006761 const RegionType *pRegions, const char *func_name, const char *msg_code) const {
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006762 bool skip = false;
6763
sfricke-samsung11d15ba2021-09-30 09:19:56 -07006764 const VkDeviceSize buffer_size = buff_state->createInfo.size;
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006765
6766 for (uint32_t i = 0; i < regionCount; i++) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05006767 const RegionType region = pRegions[i];
6768 const VkDeviceSize buffer_copy_size = GetBufferSizeFromCopyImage(region, image_state->createInfo.format);
sfricke-samsung11d15ba2021-09-30 09:19:56 -07006769 // This blocks against invalid VkBufferCopyImage that already have been caught elsewhere
6770 if (buffer_copy_size != 0) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05006771 const VkDeviceSize max_buffer_copy = buffer_copy_size + region.bufferOffset;
sfricke-samsung11d15ba2021-09-30 09:19:56 -07006772 if (buffer_size < max_buffer_copy) {
6773 skip |= LogError(device, msg_code,
6774 "%s: pRegion[%" PRIu32 "] is trying to copy %" PRIu64 " bytes plus %" PRIu64
6775 " offset to/from the VkBuffer (%s) which exceeds the VkBuffer total size of %" PRIu64 " bytes.",
sfricke-samsung71f04e32022-03-16 01:21:21 -05006776 func_name, i, buffer_copy_size, region.bufferOffset,
sfricke-samsung11d15ba2021-09-30 09:19:56 -07006777 report_data->FormatHandle(buff_state->buffer()).c_str(), buffer_size);
6778 }
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006779 }
6780 }
6781
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07006782 return skip;
6783}
6784
sfricke-samsung71f04e32022-03-16 01:21:21 -05006785template <typename RegionType>
Jeff Leger178b1e52020-10-05 12:22:23 -04006786bool CoreChecks::ValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
sfricke-samsung71f04e32022-03-16 01:21:21 -05006787 VkBuffer dstBuffer, uint32_t regionCount, const RegionType *pRegions,
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006788
6789 CMD_TYPE cmd_type) const {
Jeremy Gebbenb68fa022022-01-28 10:08:37 -07006790 auto cb_node = GetRead<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenf4449392022-01-28 10:09:10 -07006791 auto src_image_state = Get<IMAGE_STATE>(srcImage);
6792 auto dst_buffer_state = Get<BUFFER_STATE>(dstBuffer);
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07006793
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006794 const bool is_2 = (cmd_type == CMD_COPYIMAGETOBUFFER2KHR || cmd_type == CMD_COPYIMAGETOBUFFER2);
sfricke-samsung85584a72021-09-30 21:43:38 -07006795 const char *func_name = CommandTypeString(cmd_type);
Jeff Leger178b1e52020-10-05 12:22:23 -04006796 const char *vuid;
6797
Tony Barbour845d29b2021-11-09 11:43:14 -07006798 bool skip = ValidateBufferImageCopyData(cb_node.get(), regionCount, pRegions, src_image_state.get(), func_name, cmd_type, true);
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006799
6800 // Validate command buffer state
Jeremy Gebben9f537102021-10-05 16:37:12 -06006801 skip |= ValidateCmd(cb_node.get(), cmd_type);
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006802
6803 // Command pool must support graphics, compute, or transfer operations
Jeremy Gebbencd7fa282021-10-27 10:25:32 -06006804 const auto pool = cb_node->command_pool;
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006805
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06006806 VkQueueFlags queue_flags = physical_device_state->queue_family_properties[pool->queueFamilyIndex].queueFlags;
Mark Lobodzinskif6dd3762019-02-27 12:11:59 -07006807
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006808 if (0 == (queue_flags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT))) {
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006809 vuid = is_2 ? "VUID-vkCmdCopyImageToBuffer2-commandBuffer-cmdpool" : "VUID-vkCmdCopyImageToBuffer-commandBuffer-cmdpool";
Jeff Leger178b1e52020-10-05 12:22:23 -04006810 skip |= LogError(cb_node->createInfo.commandPool, vuid,
6811 "Cannot call %s on a command buffer allocated from a pool without graphics, compute, "
6812 "or transfer capabilities.",
6813 func_name);
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006814 }
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006815
6816 vuid = is_2 ? "VUID-VkCopyImageToBufferInfo2-pRegions-00182" : "VUID-vkCmdCopyImageToBuffer-pRegions-06220";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006817 skip |= ValidateImageBounds(src_image_state.get(), regionCount, pRegions, func_name, vuid);
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006818 vuid = is_2 ? "VUID-VkCopyImageToBufferInfo2-pRegions-00183" : "VUID-vkCmdCopyImageToBuffer-pRegions-00183";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006819 skip |= ValidateBufferBounds(src_image_state.get(), dst_buffer_state.get(), regionCount, pRegions, func_name, vuid);
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006820
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006821 vuid = is_2 ? "VUID-VkCopyImageToBufferInfo2-srcImage-00188" : "VUID-vkCmdCopyImageToBuffer-srcImage-00188";
6822 std::string location = func_name;
6823 location.append("() : srcImage");
6824 skip |= ValidateImageSampleCount(src_image_state.get(), VK_SAMPLE_COUNT_1_BIT, location.c_str(), vuid);
Jeff Leger178b1e52020-10-05 12:22:23 -04006825
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006826 vuid = is_2 ? "VUID-VkCopyImageToBufferInfo2-srcImage-00187" : "VUID-vkCmdCopyImageToBuffer-srcImage-00187";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006827 skip |= ValidateMemoryIsBoundToImage(src_image_state.get(), func_name, vuid);
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006828 vuid = is_2 ? "vkCmdCopyImageToBuffer-dstBuffer2-00192" : "vkCmdCopyImageToBuffer dstBuffer-00192";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006829 skip |= ValidateMemoryIsBoundToBuffer(dst_buffer_state.get(), func_name, vuid);
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07006830
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006831 // Validate that SRC image & DST buffer have correct usage flags set
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006832 vuid = is_2 ? "VUID-VkCopyImageToBufferInfo2-srcImage-00186" : "VUID-vkCmdCopyImageToBuffer-srcImage-00186";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006833 skip |= ValidateImageUsageFlags(src_image_state.get(), VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, vuid, func_name,
Dave Houltond8ed0212018-05-16 17:18:24 -06006834 "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006835 vuid = is_2 ? "VUID-VkCopyImageToBufferInfo2-dstBuffer-00191" : "VUID-vkCmdCopyImageToBuffer-dstBuffer-00191";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006836 skip |= ValidateBufferUsageFlags(dst_buffer_state.get(), VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, vuid, func_name,
Dave Houltond8ed0212018-05-16 17:18:24 -06006837 "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006838 vuid = is_2 ? "VUID-vkCmdCopyImageToBuffer2-commandBuffer-01831" : "VUID-vkCmdCopyImageToBuffer-commandBuffer-01831";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006839 skip |= ValidateProtectedImage(cb_node.get(), src_image_state.get(), func_name, vuid);
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006840 vuid = is_2 ? "VUID-vkCmdCopyImageToBuffer2-commandBuffer-01832" : "VUID-vkCmdCopyImageToBuffer-commandBuffer-01832";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006841 skip |= ValidateProtectedBuffer(cb_node.get(), dst_buffer_state.get(), func_name, vuid);
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006842 vuid = is_2 ? "VUID-vkCmdCopyImageToBuffer2-commandBuffer-01833" : "VUID-vkCmdCopyImageToBuffer-commandBuffer-01833";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006843 skip |= ValidateUnprotectedBuffer(cb_node.get(), dst_buffer_state.get(), func_name, vuid);
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02006844
6845 // Validation for VK_EXT_fragment_density_map
6846 if (src_image_state->createInfo.flags & VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT) {
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006847 vuid = is_2 ? "VUID-VkCopyImageToBufferInfo2-srcImage-02544" : "VUID-vkCmdCopyImageToBuffer-srcImage-02544";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06006848 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04006849 "%s: srcImage must not have been created with flags containing "
6850 "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT",
6851 func_name);
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02006852 }
6853
sfricke-samsung45996a42021-09-16 13:45:27 -07006854 if (IsExtEnabled(device_extensions.vk_khr_maintenance1)) {
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006855 vuid = is_2 ? "VUID-VkCopyImageToBufferInfo2-srcImage-01998" : "VUID-vkCmdCopyImageToBuffer-srcImage-01998";
6856 skip |= ValidateImageFormatFeatureFlags(src_image_state.get(), VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT, func_name, vuid);
Cort Stratton186b1a22018-05-01 20:18:06 -04006857 }
Tobin Ehlisc8266452017-04-07 12:20:30 -06006858 bool hit_error = false;
Jeff Leger178b1e52020-10-05 12:22:23 -04006859
sfricke-samsung45996a42021-09-16 13:45:27 -07006860 const char *src_invalid_layout_vuid =
6861 (src_image_state->shared_presentable && IsExtEnabled(device_extensions.vk_khr_shared_presentable_image))
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006862 ? (vuid =
6863 is_2 ? "VUID-VkCopyImageToBufferInfo2-srcImageLayout-01397" : "VUID-vkCmdCopyImageToBuffer-srcImageLayout-01397")
6864 : (vuid = is_2 ? "VUID-VkCopyImageToBufferInfo2-srcImageLayout-00190"
6865 : "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00190");
Jeff Leger178b1e52020-10-05 12:22:23 -04006866
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07006867 for (uint32_t i = 0; i < regionCount; ++i) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05006868 const RegionType region = pRegions[i];
6869 skip |= ValidateImageSubresourceLayers(cb_node.get(), &region.imageSubresource, func_name, "imageSubresource", i);
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006870 vuid = is_2 ? "VUID-VkCopyImageToBufferInfo2-srcImageLayout-00189" : "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00189";
sfricke-samsung71f04e32022-03-16 01:21:21 -05006871 skip |= VerifyImageLayout(cb_node.get(), src_image_state.get(), region.imageSubresource, srcImageLayout,
Jeff Leger178b1e52020-10-05 12:22:23 -04006872 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, func_name, src_invalid_layout_vuid, vuid, &hit_error);
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006873 vuid = is_2 ? "VUID-VkCopyImageToBufferInfo2-imageOffset-01794" : "VUID-vkCmdCopyImageToBuffer-imageOffset-01794";
sfricke-samsung71f04e32022-03-16 01:21:21 -05006874 skip |= ValidateCopyBufferImageTransferGranularityRequirements(cb_node.get(), src_image_state.get(), &region, i, func_name,
6875 vuid);
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006876 vuid = is_2 ? "VUID-VkCopyImageToBufferInfo2-imageSubresource-01703" : "VUID-vkCmdCopyImageToBuffer-imageSubresource-01703";
sfricke-samsung71f04e32022-03-16 01:21:21 -05006877 skip |= ValidateImageMipLevel(cb_node.get(), src_image_state.get(), region.imageSubresource.mipLevel, i, func_name,
Jeff Leger178b1e52020-10-05 12:22:23 -04006878 "imageSubresource", vuid);
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006879 vuid = is_2 ? "VUID-VkCopyImageToBufferInfo2-imageSubresource-01704" : "VUID-vkCmdCopyImageToBuffer-imageSubresource-01704";
sfricke-samsung71f04e32022-03-16 01:21:21 -05006880 skip |= ValidateImageArrayLayerRange(cb_node.get(), src_image_state.get(), region.imageSubresource.baseArrayLayer,
6881 region.imageSubresource.layerCount, i, func_name, "imageSubresource", vuid);
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07006882 }
6883 return skip;
6884}
6885
Jeff Leger178b1e52020-10-05 12:22:23 -04006886bool CoreChecks::PreCallValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
6887 VkBuffer dstBuffer, uint32_t regionCount,
6888 const VkBufferImageCopy *pRegions) const {
6889 return ValidateCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions,
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006890 CMD_COPYIMAGETOBUFFER);
Jeff Leger178b1e52020-10-05 12:22:23 -04006891}
6892
6893bool CoreChecks::PreCallValidateCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
6894 const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo) const {
6895 return ValidateCmdCopyImageToBuffer(commandBuffer, pCopyImageToBufferInfo->srcImage, pCopyImageToBufferInfo->srcImageLayout,
6896 pCopyImageToBufferInfo->dstBuffer, pCopyImageToBufferInfo->regionCount,
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006897 pCopyImageToBufferInfo->pRegions, CMD_COPYIMAGETOBUFFER2KHR);
Jeff Leger178b1e52020-10-05 12:22:23 -04006898}
6899
Tony Barbour845d29b2021-11-09 11:43:14 -07006900bool CoreChecks::PreCallValidateCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
6901 const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo) const {
6902 return ValidateCmdCopyImageToBuffer(commandBuffer, pCopyImageToBufferInfo->srcImage, pCopyImageToBufferInfo->srcImageLayout,
6903 pCopyImageToBufferInfo->dstBuffer, pCopyImageToBufferInfo->regionCount,
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006904 pCopyImageToBufferInfo->pRegions, CMD_COPYIMAGETOBUFFER2);
Tony Barbour845d29b2021-11-09 11:43:14 -07006905}
6906
John Zulauf1686f232019-07-09 16:27:11 -06006907void CoreChecks::PreCallRecordCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
6908 VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) {
6909 StateTracker::PreCallRecordCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
6910
Jeremy Gebben332d4dd2022-01-01 12:40:02 -07006911 auto cb_node = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06006912 auto src_image_state = Get<IMAGE_STATE>(srcImage);
John Zulauff660ad62019-03-23 07:16:05 -06006913 // Make sure that all image slices record referenced layout
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07006914 for (uint32_t i = 0; i < regionCount; ++i) {
Jeremy Gebben1ec89332021-08-05 13:51:49 -06006915 cb_node->SetImageInitialLayout(*src_image_state, pRegions[i].imageSubresource, srcImageLayout);
Tobin Ehlise35b66a2017-03-15 12:18:31 -06006916 }
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006917}
6918
Jeff Leger178b1e52020-10-05 12:22:23 -04006919void CoreChecks::PreCallRecordCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
6920 const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo) {
6921 StateTracker::PreCallRecordCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo);
6922
Jeremy Gebben332d4dd2022-01-01 12:40:02 -07006923 auto cb_node = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06006924 auto src_image_state = Get<IMAGE_STATE>(pCopyImageToBufferInfo->srcImage);
Jeff Leger178b1e52020-10-05 12:22:23 -04006925 // Make sure that all image slices record referenced layout
6926 for (uint32_t i = 0; i < pCopyImageToBufferInfo->regionCount; ++i) {
Jeremy Gebben1ec89332021-08-05 13:51:49 -06006927 cb_node->SetImageInitialLayout(*src_image_state, pCopyImageToBufferInfo->pRegions[i].imageSubresource,
6928 pCopyImageToBufferInfo->srcImageLayout);
Jeff Leger178b1e52020-10-05 12:22:23 -04006929 }
6930}
6931
Tony-LunarGaf3632a2021-11-10 15:51:57 -07006932void CoreChecks::PreCallRecordCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
6933 const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo) {
6934 StateTracker::PreCallRecordCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo);
6935
6936 auto cb_node = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
6937 auto src_image_state = Get<IMAGE_STATE>(pCopyImageToBufferInfo->srcImage);
6938 // Make sure that all image slices record referenced layout
6939 for (uint32_t i = 0; i < pCopyImageToBufferInfo->regionCount; ++i) {
6940 cb_node->SetImageInitialLayout(*src_image_state, pCopyImageToBufferInfo->pRegions[i].imageSubresource,
6941 pCopyImageToBufferInfo->srcImageLayout);
6942 }
6943}
6944
Jeff Leger178b1e52020-10-05 12:22:23 -04006945template <typename RegionType>
6946bool CoreChecks::ValidateCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
6947 VkImageLayout dstImageLayout, uint32_t regionCount, const RegionType *pRegions,
Tony Barbour845d29b2021-11-09 11:43:14 -07006948 CMD_TYPE cmd_type) const {
Jeremy Gebbenb68fa022022-01-28 10:08:37 -07006949 auto cb_node = GetRead<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenf4449392022-01-28 10:09:10 -07006950 auto src_buffer_state = Get<BUFFER_STATE>(srcBuffer);
6951 auto dst_image_state = Get<IMAGE_STATE>(dstImage);
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07006952
Tony Barbour845d29b2021-11-09 11:43:14 -07006953 const bool is_2 = (cmd_type == CMD_COPYBUFFERTOIMAGE2KHR || cmd_type == CMD_COPYBUFFERTOIMAGE2);
sfricke-samsung85584a72021-09-30 21:43:38 -07006954 const char *func_name = CommandTypeString(cmd_type);
Jeff Leger178b1e52020-10-05 12:22:23 -04006955 const char *vuid;
6956
Tony Barbour845d29b2021-11-09 11:43:14 -07006957 bool skip =
6958 ValidateBufferImageCopyData(cb_node.get(), regionCount, pRegions, dst_image_state.get(), func_name, cmd_type, false);
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006959
6960 // Validate command buffer state
Jeremy Gebben9f537102021-10-05 16:37:12 -06006961 skip |= ValidateCmd(cb_node.get(), cmd_type);
Mark Lobodzinskid2b2f612017-02-15 13:45:18 -07006962
Tony Barbour845d29b2021-11-09 11:43:14 -07006963 vuid = is_2 ? "VUID-VkCopyBufferToImageInfo2-pRegions-00172" : "VUID-vkCmdCopyBufferToImage-pRegions-06217";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006964 skip |= ValidateImageBounds(dst_image_state.get(), regionCount, pRegions, func_name, vuid);
Tony Barbour845d29b2021-11-09 11:43:14 -07006965 vuid = is_2 ? "VUID-VkCopyBufferToImageInfo2-pRegions-00171" : "VUID-vkCmdCopyBufferToImage-pRegions-00171";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006966 skip |= ValidateBufferBounds(dst_image_state.get(), src_buffer_state.get(), regionCount, pRegions, func_name, vuid);
Jeff Leger178b1e52020-10-05 12:22:23 -04006967
Tony Barbour845d29b2021-11-09 11:43:14 -07006968 vuid = is_2 ? "VUID-VkCopyBufferToImageInfo2-dstImage-00179" : "VUID-vkCmdCopyBufferToImage-dstImage-00179";
6969 std::string location = func_name;
6970 location.append("() : dstImage");
6971 skip |= ValidateImageSampleCount(dst_image_state.get(), VK_SAMPLE_COUNT_1_BIT, location.c_str(), vuid);
6972 vuid = is_2 ? "VUID-VkCopyBufferToImageInfo2-srcBuffer-00176" : "VUID-vkCmdCopyBufferToImage-srcBuffer-00176";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006973 skip |= ValidateMemoryIsBoundToBuffer(src_buffer_state.get(), func_name, vuid);
Tony Barbour845d29b2021-11-09 11:43:14 -07006974 vuid = is_2 ? "VUID-VkCopyBufferToImageInfo2-dstImage-00178" : "VUID-vkCmdCopyBufferToImage-dstImage-00178";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006975 skip |= ValidateMemoryIsBoundToImage(dst_image_state.get(), func_name, vuid);
Tony Barbour845d29b2021-11-09 11:43:14 -07006976 vuid = is_2 ? "VUID-VkCopyBufferToImageInfo2-srcBuffer-00174" : "VUID-vkCmdCopyBufferToImage-srcBuffer-00174";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006977 skip |= ValidateBufferUsageFlags(src_buffer_state.get(), VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, vuid, func_name,
Dave Houltond8ed0212018-05-16 17:18:24 -06006978 "VK_BUFFER_USAGE_TRANSFER_SRC_BIT");
Tony Barbour845d29b2021-11-09 11:43:14 -07006979 vuid = is_2 ? "VUID-VkCopyBufferToImageInfo2-dstImage-00177" : "VUID-vkCmdCopyBufferToImage-dstImage-00177";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006980 skip |= ValidateImageUsageFlags(dst_image_state.get(), VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, vuid, func_name,
Dave Houltond8ed0212018-05-16 17:18:24 -06006981 "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
Tony Barbour845d29b2021-11-09 11:43:14 -07006982 vuid = is_2 ? "VUID-vkCmdCopyBufferToImage2-commandBuffer-01828" : "VUID-vkCmdCopyBufferToImage-commandBuffer-01828";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006983 skip |= ValidateProtectedBuffer(cb_node.get(), src_buffer_state.get(), func_name, vuid);
Tony Barbour845d29b2021-11-09 11:43:14 -07006984 vuid = is_2 ? "VUID-vkCmdCopyBufferToImage2-commandBuffer-01829" : "VUID-vkCmdCopyBufferToImage-commandBuffer-01829";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006985 skip |= ValidateProtectedImage(cb_node.get(), dst_image_state.get(), func_name, vuid);
Tony Barbour845d29b2021-11-09 11:43:14 -07006986 vuid = is_2 ? "VUID-vkCmdCopyBufferToImage-commandBuffer-01830" : "VUID-vkCmdCopyBufferToImage-commandBuffer-01830";
Jeremy Gebben9f537102021-10-05 16:37:12 -06006987 skip |= ValidateUnprotectedImage(cb_node.get(), dst_image_state.get(), func_name, vuid);
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02006988
6989 // Validation for VK_EXT_fragment_density_map
6990 if (dst_image_state->createInfo.flags & VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006991 vuid = is_2 ? "VUID-VkCopyBufferToImageInfo2-dstImage-02543" : "VUID-vkCmdCopyBufferToImage-dstImage-02543";
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06006992 skip |= LogError(cb_node->commandBuffer(), vuid,
Jeff Leger178b1e52020-10-05 12:22:23 -04006993 "%s: dstImage must not have been created with flags containing "
6994 "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT",
6995 func_name);
janharaldfredriksen-arm3b793772020-05-12 18:55:53 +02006996 }
6997
sfricke-samsung45996a42021-09-16 13:45:27 -07006998 if (IsExtEnabled(device_extensions.vk_khr_maintenance1)) {
Tony Barbour845d29b2021-11-09 11:43:14 -07006999 vuid = is_2 ? "VUID-VkCopyBufferToImageInfo2-dstImage-01997" : "VUID-vkCmdCopyBufferToImage-dstImage-01997";
7000 skip |= ValidateImageFormatFeatureFlags(dst_image_state.get(), VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT, func_name, vuid);
Cort Stratton186b1a22018-05-01 20:18:06 -04007001 }
Tobin Ehlisc8266452017-04-07 12:20:30 -06007002 bool hit_error = false;
Jeff Leger178b1e52020-10-05 12:22:23 -04007003
sfricke-samsung45996a42021-09-16 13:45:27 -07007004 const char *dst_invalid_layout_vuid =
7005 (dst_image_state->shared_presentable && IsExtEnabled(device_extensions.vk_khr_shared_presentable_image))
Tony Barbour845d29b2021-11-09 11:43:14 -07007006 ? (is_2 ? "VUID-VkCopyBufferToImageInfo2-dstImageLayout-01396"
sfricke-samsung45996a42021-09-16 13:45:27 -07007007 : "VUID-vkCmdCopyBufferToImage-dstImageLayout-01396")
Tony Barbour845d29b2021-11-09 11:43:14 -07007008 : (is_2 ? "VUID-VkCopyBufferToImageInfo2-dstImageLayout-00181"
sfricke-samsung45996a42021-09-16 13:45:27 -07007009 : "VUID-vkCmdCopyBufferToImage-dstImageLayout-00181");
Jeff Leger178b1e52020-10-05 12:22:23 -04007010
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07007011 for (uint32_t i = 0; i < regionCount; ++i) {
sfricke-samsung71f04e32022-03-16 01:21:21 -05007012 const RegionType region = pRegions[i];
7013 skip |= ValidateImageSubresourceLayers(cb_node.get(), &region.imageSubresource, func_name, "imageSubresource", i);
Tony Barbour845d29b2021-11-09 11:43:14 -07007014 vuid = is_2 ? "VUID-VkCopyBufferToImageInfo2-dstImageLayout-00180" : "VUID-vkCmdCopyBufferToImage-dstImageLayout-00180";
sfricke-samsung71f04e32022-03-16 01:21:21 -05007015 skip |= VerifyImageLayout(cb_node.get(), dst_image_state.get(), region.imageSubresource, dstImageLayout,
Jeff Leger178b1e52020-10-05 12:22:23 -04007016 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, func_name, dst_invalid_layout_vuid, vuid, &hit_error);
Tony Barbour845d29b2021-11-09 11:43:14 -07007017 vuid = is_2 ? "VUID-VkCopyBufferToImageInfo2-imageOffset-01793" : "VUID-vkCmdCopyBufferToImage-imageOffset-01793";
sfricke-samsung71f04e32022-03-16 01:21:21 -05007018 skip |= ValidateCopyBufferImageTransferGranularityRequirements(cb_node.get(), dst_image_state.get(), &region, i, func_name,
7019 vuid);
Tony Barbour845d29b2021-11-09 11:43:14 -07007020 vuid = is_2 ? "VUID-VkCopyBufferToImageInfo2-imageSubresource-01701" : "VUID-vkCmdCopyBufferToImage-imageSubresource-01701";
sfricke-samsung71f04e32022-03-16 01:21:21 -05007021 skip |= ValidateImageMipLevel(cb_node.get(), dst_image_state.get(), region.imageSubresource.mipLevel, i, func_name,
Jeff Leger178b1e52020-10-05 12:22:23 -04007022 "imageSubresource", vuid);
Tony Barbour845d29b2021-11-09 11:43:14 -07007023 vuid = is_2 ? "VUID-VkCopyBufferToImageInfo2-imageSubresource-01702" : "VUID-vkCmdCopyBufferToImage-imageSubresource-01702";
sfricke-samsung71f04e32022-03-16 01:21:21 -05007024 skip |= ValidateImageArrayLayerRange(cb_node.get(), dst_image_state.get(), region.imageSubresource.baseArrayLayer,
7025 region.imageSubresource.layerCount, i, func_name, "imageSubresource", vuid);
sfricke-samsungea4fd142020-10-17 23:51:59 -07007026
7027 // TODO - Don't use ValidateCmdQueueFlags due to currently not having way to add more descriptive message
Jeremy Gebbencd7fa282021-10-27 10:25:32 -06007028 const COMMAND_POOL_STATE *command_pool = cb_node->command_pool;
sfricke-samsungea4fd142020-10-17 23:51:59 -07007029 assert(command_pool != nullptr);
7030 const uint32_t queue_family_index = command_pool->queueFamilyIndex;
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06007031 const VkQueueFlags queue_flags = physical_device_state->queue_family_properties[queue_family_index].queueFlags;
sfricke-samsung71f04e32022-03-16 01:21:21 -05007032 const VkImageAspectFlags region_aspect_mask = region.imageSubresource.aspectMask;
sfricke-samsungea4fd142020-10-17 23:51:59 -07007033 if (((queue_flags & VK_QUEUE_GRAPHICS_BIT) == 0) &&
7034 ((region_aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) != 0)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06007035 LogObjectList objlist(cb_node->commandBuffer());
7036 objlist.add(command_pool->commandPool());
sfricke-samsung4389faa2022-03-23 01:19:42 -05007037 objlist.add(dst_image_state->image());
Tony Barbour845d29b2021-11-09 11:43:14 -07007038 vuid = is_2 ? "VUID-VkCopyBufferToImageInfo2-commandBuffer-04477"
sfricke-samsungea4fd142020-10-17 23:51:59 -07007039 : "VUID-vkCmdCopyBufferToImage-commandBuffer-04477";
sfricke-samsung4389faa2022-03-23 01:19:42 -05007040 skip |= LogError(objlist, vuid,
sfricke-samsungea4fd142020-10-17 23:51:59 -07007041 "%s(): pRegion[%d] subresource aspectMask 0x%x specifies VK_IMAGE_ASPECT_DEPTH_BIT or "
7042 "VK_IMAGE_ASPECT_STENCIL_BIT but the command buffer %s was allocated from the command pool %s "
7043 "which was created with queueFamilyIndex %u, which doesn't contain the VK_QUEUE_GRAPHICS_BIT flag.",
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06007044 func_name, i, region_aspect_mask, report_data->FormatHandle(cb_node->commandBuffer()).c_str(),
7045 report_data->FormatHandle(command_pool->commandPool()).c_str(), queue_family_index);
sfricke-samsungea4fd142020-10-17 23:51:59 -07007046 }
Mark Lobodzinski033c90b2017-02-15 13:58:23 -07007047 }
7048 return skip;
7049}
7050
Jeff Leger178b1e52020-10-05 12:22:23 -04007051bool CoreChecks::PreCallValidateCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
7052 VkImageLayout dstImageLayout, uint32_t regionCount,
7053 const VkBufferImageCopy *pRegions) const {
7054 return ValidateCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions,
Tony Barbour845d29b2021-11-09 11:43:14 -07007055 CMD_COPYBUFFERTOIMAGE);
Jeff Leger178b1e52020-10-05 12:22:23 -04007056}
7057
7058bool CoreChecks::PreCallValidateCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
7059 const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo) const {
7060 return ValidateCmdCopyBufferToImage(commandBuffer, pCopyBufferToImageInfo->srcBuffer, pCopyBufferToImageInfo->dstImage,
7061 pCopyBufferToImageInfo->dstImageLayout, pCopyBufferToImageInfo->regionCount,
Tony Barbour845d29b2021-11-09 11:43:14 -07007062 pCopyBufferToImageInfo->pRegions, CMD_COPYBUFFERTOIMAGE2KHR);
7063}
7064
7065bool CoreChecks::PreCallValidateCmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
7066 const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo) const {
7067 return ValidateCmdCopyBufferToImage(commandBuffer, pCopyBufferToImageInfo->srcBuffer, pCopyBufferToImageInfo->dstImage,
7068 pCopyBufferToImageInfo->dstImageLayout, pCopyBufferToImageInfo->regionCount,
7069 pCopyBufferToImageInfo->pRegions, CMD_COPYBUFFERTOIMAGE2);
Jeff Leger178b1e52020-10-05 12:22:23 -04007070}
7071
John Zulauf1686f232019-07-09 16:27:11 -06007072void CoreChecks::PreCallRecordCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
7073 VkImageLayout dstImageLayout, uint32_t regionCount,
7074 const VkBufferImageCopy *pRegions) {
7075 StateTracker::PreCallRecordCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
7076
Jeremy Gebben332d4dd2022-01-01 12:40:02 -07007077 auto cb_node = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06007078 auto dst_image_state = Get<IMAGE_STATE>(dstImage);
John Zulauff660ad62019-03-23 07:16:05 -06007079 // Make sure that all image slices are record referenced layout
Mark Lobodzinskib7eafbe2019-01-10 13:40:39 -07007080 for (uint32_t i = 0; i < regionCount; ++i) {
Jeremy Gebben1ec89332021-08-05 13:51:49 -06007081 cb_node->SetImageInitialLayout(*dst_image_state, pRegions[i].imageSubresource, dstImageLayout);
Tobin Ehlise35b66a2017-03-15 12:18:31 -06007082 }
Mark Lobodzinskiab9ea3e2017-02-15 12:59:00 -07007083}
Mike Weiblen672b58b2017-02-21 14:32:53 -07007084
Jeff Leger178b1e52020-10-05 12:22:23 -04007085void CoreChecks::PreCallRecordCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
7086 const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo2KHR) {
7087 StateTracker::PreCallRecordCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo2KHR);
7088
Jeremy Gebben332d4dd2022-01-01 12:40:02 -07007089 auto cb_node = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
Jeremy Gebbenb20a8242021-11-05 15:14:43 -06007090 auto dst_image_state = Get<IMAGE_STATE>(pCopyBufferToImageInfo2KHR->dstImage);
Jeff Leger178b1e52020-10-05 12:22:23 -04007091 // Make sure that all image slices are record referenced layout
7092 for (uint32_t i = 0; i < pCopyBufferToImageInfo2KHR->regionCount; ++i) {
Jeremy Gebben1ec89332021-08-05 13:51:49 -06007093 cb_node->SetImageInitialLayout(*dst_image_state, pCopyBufferToImageInfo2KHR->pRegions[i].imageSubresource,
7094 pCopyBufferToImageInfo2KHR->dstImageLayout);
Jeff Leger178b1e52020-10-05 12:22:23 -04007095 }
7096}
Tony Barbour845d29b2021-11-09 11:43:14 -07007097
7098void CoreChecks::PreCallRecordCmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
7099 const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo) {
7100 StateTracker::PreCallRecordCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo);
7101
7102 auto cb_node = GetWrite<CMD_BUFFER_STATE>(commandBuffer);
7103 auto dst_image_state = Get<IMAGE_STATE>(pCopyBufferToImageInfo->dstImage);
7104 // Make sure that all image slices are record referenced layout
7105 for (uint32_t i = 0; i < pCopyBufferToImageInfo->regionCount; ++i) {
7106 cb_node->SetImageInitialLayout(*dst_image_state, pCopyBufferToImageInfo->pRegions[i].imageSubresource,
7107 pCopyBufferToImageInfo->dstImageLayout);
7108 }
7109}
7110
Mark Lobodzinskib56bbb92019-02-18 11:49:59 -07007111bool CoreChecks::PreCallValidateGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource,
Jeff Bolz5c801d12019-10-09 10:38:45 -05007112 VkSubresourceLayout *pLayout) const {
Mike Weiblen672b58b2017-02-21 14:32:53 -07007113 bool skip = false;
7114 const VkImageAspectFlags sub_aspect = pSubresource->aspectMask;
7115
Dave Houlton1d960ff2018-01-19 12:17:05 -07007116 // The aspectMask member of pSubresource must only have a single bit set
Mike Weiblen672b58b2017-02-21 14:32:53 -07007117 const int num_bits = sizeof(sub_aspect) * CHAR_BIT;
7118 std::bitset<num_bits> aspect_mask_bits(sub_aspect);
7119 if (aspect_mask_bits.count() != 1) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07007120 skip |= LogError(image, "VUID-vkGetImageSubresourceLayout-aspectMask-00997",
7121 "vkGetImageSubresourceLayout(): VkImageSubresource.aspectMask must have exactly 1 bit set.");
Mike Weiblen672b58b2017-02-21 14:32:53 -07007122 }
7123
Jeremy Gebbenf4449392022-01-28 10:09:10 -07007124 auto image_entry = Get<IMAGE_STATE>(image);
Mike Weiblen672b58b2017-02-21 14:32:53 -07007125 if (!image_entry) {
7126 return skip;
7127 }
7128
Mark Lobodzinski6f358172019-10-02 11:09:12 -06007129 // Image must have been created with tiling equal to VK_IMAGE_TILING_LINEAR
sfricke-samsung45996a42021-09-16 13:45:27 -07007130 if (IsExtEnabled(device_extensions.vk_ext_image_drm_format_modifier)) {
Mark Lobodzinski6f358172019-10-02 11:09:12 -06007131 if ((image_entry->createInfo.tiling != VK_IMAGE_TILING_LINEAR) &&
7132 (image_entry->createInfo.tiling != VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT)) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07007133 skip |= LogError(image, "VUID-vkGetImageSubresourceLayout-image-02270",
7134 "vkGetImageSubresourceLayout(): Image must have tiling of VK_IMAGE_TILING_LINEAR or "
7135 "VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT.");
Mark Lobodzinski6f358172019-10-02 11:09:12 -06007136 }
7137 } else {
7138 if (image_entry->createInfo.tiling != VK_IMAGE_TILING_LINEAR) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07007139 skip |= LogError(image, "VUID-vkGetImageSubresourceLayout-image-00996",
7140 "vkGetImageSubresourceLayout(): Image must have tiling of VK_IMAGE_TILING_LINEAR.");
Mark Lobodzinski6f358172019-10-02 11:09:12 -06007141 }
Mike Weiblen672b58b2017-02-21 14:32:53 -07007142 }
7143
Dave Houlton1d960ff2018-01-19 12:17:05 -07007144 // mipLevel must be less than the mipLevels specified in VkImageCreateInfo when the image was created
Mike Weiblen672b58b2017-02-21 14:32:53 -07007145 if (pSubresource->mipLevel >= image_entry->createInfo.mipLevels) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07007146 skip |= LogError(image, "VUID-vkGetImageSubresourceLayout-mipLevel-01716",
7147 "vkGetImageSubresourceLayout(): pSubresource.mipLevel (%d) must be less than %d.", pSubresource->mipLevel,
7148 image_entry->createInfo.mipLevels);
Mike Weiblen672b58b2017-02-21 14:32:53 -07007149 }
7150
Dave Houlton1d960ff2018-01-19 12:17:05 -07007151 // arrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when the image was created
Mike Weiblen672b58b2017-02-21 14:32:53 -07007152 if (pSubresource->arrayLayer >= image_entry->createInfo.arrayLayers) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07007153 skip |= LogError(image, "VUID-vkGetImageSubresourceLayout-arrayLayer-01717",
7154 "vkGetImageSubresourceLayout(): pSubresource.arrayLayer (%d) must be less than %d.",
7155 pSubresource->arrayLayer, image_entry->createInfo.arrayLayers);
Mike Weiblen672b58b2017-02-21 14:32:53 -07007156 }
7157
Dave Houlton1d960ff2018-01-19 12:17:05 -07007158 // subresource's aspect must be compatible with image's format.
Mike Weiblen672b58b2017-02-21 14:32:53 -07007159 const VkFormat img_format = image_entry->createInfo.format;
Mark Lobodzinski9824cac2019-10-02 13:19:38 -06007160 if (image_entry->createInfo.tiling == VK_IMAGE_TILING_LINEAR) {
7161 if (FormatIsMultiplane(img_format)) {
Mike Schuchardt2df08912020-12-15 16:28:09 -08007162 VkImageAspectFlags allowed_flags = (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT);
Mark Lobodzinski9824cac2019-10-02 13:19:38 -06007163 const char *vuid = "VUID-vkGetImageSubresourceLayout-format-01581"; // 2-plane version
7164 if (FormatPlaneCount(img_format) > 2u) {
Mike Schuchardt2df08912020-12-15 16:28:09 -08007165 allowed_flags |= VK_IMAGE_ASPECT_PLANE_2_BIT;
Mark Lobodzinski9824cac2019-10-02 13:19:38 -06007166 vuid = "VUID-vkGetImageSubresourceLayout-format-01582"; // 3-plane version
7167 }
7168 if (sub_aspect != (sub_aspect & allowed_flags)) {
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07007169 skip |= LogError(image, vuid,
7170 "vkGetImageSubresourceLayout(): For multi-planar images, VkImageSubresource.aspectMask (0x%" PRIx32
7171 ") must be a single-plane specifier flag.",
7172 sub_aspect);
Mark Lobodzinski9824cac2019-10-02 13:19:38 -06007173 }
7174 } else if (FormatIsColor(img_format)) {
7175 if (sub_aspect != VK_IMAGE_ASPECT_COLOR_BIT) {
ziga-lunargcc568bc2021-09-05 13:45:45 +02007176 skip |= LogError(image, "VUID-vkGetImageSubresourceLayout-format-04461",
Mark Lobodzinski4fc2bb42020-01-31 14:21:21 -07007177 "vkGetImageSubresourceLayout(): For color formats, VkImageSubresource.aspectMask must be "
7178 "VK_IMAGE_ASPECT_COLOR.");
Mark Lobodzinski9824cac2019-10-02 13:19:38 -06007179 }
7180 } else if (FormatIsDepthOrStencil(img_format)) {
Nathaniel Cesario8c80f352021-07-15 15:06:48 -06007181 if ((sub_aspect != VK_IMAGE_ASPECT_DEPTH_BIT) && (sub_aspect != VK_IMAGE_ASPECT_STENCIL_BIT)) {
Mark Lobodzinski9824cac2019-10-02 13:19:38 -06007182 }
Dave Houlton1d960ff2018-01-19 12:17:05 -07007183 }
ziga-lunarg4ecbd5b2021-07-15 20:48:30 +02007184 if (!FormatIsDepthAndStencil(img_format) && !FormatIsDepthOnly(img_format)) {
7185 if (sub_aspect & VK_IMAGE_ASPECT_DEPTH_BIT) {
7186 skip |= LogError(image, "VUID-vkGetImageSubresourceLayout-format-04464",
7187 "vkGetImageSubresourceLayout(): Image format (%s) does not contain a depth component, "
7188 "but VkImageSubresource.aspectMask contains VK_IMAGE_ASPECT_DEPTH_BIT.",
7189 string_VkFormat(img_format));
7190 }
7191 } else {
7192 if ((sub_aspect & VK_IMAGE_ASPECT_DEPTH_BIT) == 0) {
7193 skip |= LogError(image, "VUID-vkGetImageSubresourceLayout-format-04462",
7194 "vkGetImageSubresourceLayout(): Image format (%s) contains a depth component, "
7195 "but VkImageSubresource.aspectMask does not contain VK_IMAGE_ASPECT_DEPTH_BIT.",
7196 string_VkFormat(img_format));
7197 }
7198 }
7199 if (!FormatIsDepthAndStencil(img_format) && !FormatIsStencilOnly(img_format)) {
7200 if (sub_aspect & VK_IMAGE_ASPECT_STENCIL_BIT) {
7201 skip |= LogError(image, "VUID-vkGetImageSubresourceLayout-format-04464",
7202 "vkGetImageSubresourceLayout(): Image format (%s) does not contain a stencil component, "
7203 "but VkImageSubresource.aspectMask contains VK_IMAGE_ASPECT_STENCIL_BIT.",
7204 string_VkFormat(img_format));
7205 }
7206 } else {
7207 if ((sub_aspect & VK_IMAGE_ASPECT_STENCIL_BIT) == 0) {
7208 skip |= LogError(image, "VUID-vkGetImageSubresourceLayout-format-04463",
7209 "vkGetImageSubresourceLayout(): Image format (%s) contains a stencil component, "
7210 "but VkImageSubresource.aspectMask does not contain VK_IMAGE_ASPECT_STENCIL_BIT.",
7211 string_VkFormat(img_format));
7212 }
7213 }
Mark Lobodzinski9824cac2019-10-02 13:19:38 -06007214 } else if (image_entry->createInfo.tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT) {
7215 if ((sub_aspect != VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT) && (sub_aspect != VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT) &&
7216 (sub_aspect != VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT) && (sub_aspect != VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT)) {
Aitor Camacho0e4aad32022-05-20 19:22:02 +02007217 skip |= LogError(
7218 image, "VUID-vkGetImageSubresourceLayout-tiling-02271",
7219 "vkGetImageSubresourceLayout(): VkImageSubresource.aspectMask (%s) must be VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT.",
7220 string_VkImageAspectFlags(sub_aspect).c_str());
7221 } else {
7222 // Parameter validation should catch if this is used without VK_EXT_image_drm_format_modifier
7223 assert(IsExtEnabled(device_extensions.vk_ext_image_drm_format_modifier));
7224 VkImageDrmFormatModifierPropertiesEXT drm_format_properties = LvlInitStruct<VkImageDrmFormatModifierPropertiesEXT>();
7225 DispatchGetImageDrmFormatModifierPropertiesEXT(device, image, &drm_format_properties);
7226
7227 auto fmt_drm_props = LvlInitStruct<VkDrmFormatModifierPropertiesListEXT>();
7228 auto fmt_props_2 = LvlInitStruct<VkFormatProperties2>(&fmt_drm_props);
7229 DispatchGetPhysicalDeviceFormatProperties2(physical_device, image_entry->createInfo.format, &fmt_props_2);
7230 std::vector<VkDrmFormatModifierPropertiesEXT> drm_properties{fmt_drm_props.drmFormatModifierCount};
7231 fmt_drm_props.pDrmFormatModifierProperties = drm_properties.data();
7232 DispatchGetPhysicalDeviceFormatProperties2(physical_device, image_entry->createInfo.format, &fmt_props_2);
7233
7234 uint32_t max_plane_count = 0u;
7235
7236 for (auto const &drm_property : drm_properties) {
7237 if (drm_format_properties.drmFormatModifier == drm_property.drmFormatModifier) {
7238 max_plane_count = drm_property.drmFormatModifierPlaneCount;
7239 break;
7240 }
7241 }
7242
7243 VkImageAspectFlagBits allowed_plane_indices[] = {
7244 VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT, VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT,
7245 VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT, VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT};
7246
7247 bool is_valid = false;
7248
7249 for (uint32_t i = 0u; i < max_plane_count; ++i) {
7250 if (sub_aspect == allowed_plane_indices[i]) {
7251 is_valid = true;
7252 break;
7253 }
7254 }
7255
7256 if (!is_valid) {
7257 skip |= LogError(image, "VUID-vkGetImageSubresourceLayout-tiling-02271",
7258 "vkGetImageSubresourceLayout(): VkImageSubresource.aspectMask (%s) must be "
7259 "VK_IMAGE_ASPECT_MEMORY_PLANE_i_BIT_EXT, with i being less than the "
7260 "VkDrmFormatModifierPropertiesEXT::drmFormatModifierPlaneCount (%" PRIu32
7261 ") associated with the image's format (%s) and "
7262 "VkImageDrmFormatModifierPropertiesEXT::drmFormatModifier (%" PRIu64 ").",
7263 string_VkImageAspectFlags(sub_aspect).c_str(), max_plane_count,
7264 string_VkFormat(image_entry->createInfo.format), drm_format_properties.drmFormatModifier);
7265 }
Mike Weiblen672b58b2017-02-21 14:32:53 -07007266 }
7267 }
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06007268
sfricke-samsung45996a42021-09-16 13:45:27 -07007269 if (IsExtEnabled(device_extensions.vk_android_external_memory_android_hardware_buffer)) {
Mark Lobodzinskie9b99792019-03-07 16:34:29 -07007270 skip |= ValidateGetImageSubresourceLayoutANDROID(image);
Dave Houlton0d4ad6f2018-09-05 14:53:34 -06007271 }
7272
Mike Weiblen672b58b2017-02-21 14:32:53 -07007273 return skip;
7274}
sfricke-samsung022fa252020-07-24 03:26:16 -07007275
7276// Validates the image is allowed to be protected
7277bool CoreChecks::ValidateProtectedImage(const CMD_BUFFER_STATE *cb_state, const IMAGE_STATE *image_state, const char *cmd_name,
locke-lunarg351c9d82020-10-23 14:43:21 -06007278 const char *vuid, const char *more_message) const {
sfricke-samsung022fa252020-07-24 03:26:16 -07007279 bool skip = false;
sfricke-samsung21286f82021-11-16 08:21:46 -08007280
7281 // if driver supports protectedNoFault the operation is valid, just has undefined values
7282 if ((!phys_dev_props_core11.protectedNoFault) && (cb_state->unprotected == true) && (image_state->unprotected == false)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06007283 LogObjectList objlist(cb_state->commandBuffer());
7284 objlist.add(image_state->image());
locke-lunarg351c9d82020-10-23 14:43:21 -06007285 skip |= LogError(objlist, vuid, "%s: command buffer %s is unprotected while image %s is a protected image.%s", cmd_name,
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06007286 report_data->FormatHandle(cb_state->commandBuffer()).c_str(),
7287 report_data->FormatHandle(image_state->image()).c_str(), more_message);
sfricke-samsung022fa252020-07-24 03:26:16 -07007288 }
7289 return skip;
7290}
7291
7292// Validates the image is allowed to be unprotected
7293bool CoreChecks::ValidateUnprotectedImage(const CMD_BUFFER_STATE *cb_state, const IMAGE_STATE *image_state, const char *cmd_name,
locke-lunarg351c9d82020-10-23 14:43:21 -06007294 const char *vuid, const char *more_message) const {
sfricke-samsung022fa252020-07-24 03:26:16 -07007295 bool skip = false;
sfricke-samsung21286f82021-11-16 08:21:46 -08007296
7297 // if driver supports protectedNoFault the operation is valid, just has undefined values
7298 if ((!phys_dev_props_core11.protectedNoFault) && (cb_state->unprotected == false) && (image_state->unprotected == true)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06007299 LogObjectList objlist(cb_state->commandBuffer());
7300 objlist.add(image_state->image());
locke-lunarg351c9d82020-10-23 14:43:21 -06007301 skip |= LogError(objlist, vuid, "%s: command buffer %s is protected while image %s is an unprotected image.%s", cmd_name,
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06007302 report_data->FormatHandle(cb_state->commandBuffer()).c_str(),
7303 report_data->FormatHandle(image_state->image()).c_str(), more_message);
sfricke-samsung022fa252020-07-24 03:26:16 -07007304 }
7305 return skip;
7306}
7307
7308// Validates the buffer is allowed to be protected
7309bool CoreChecks::ValidateProtectedBuffer(const CMD_BUFFER_STATE *cb_state, const BUFFER_STATE *buffer_state, const char *cmd_name,
locke-lunarg351c9d82020-10-23 14:43:21 -06007310 const char *vuid, const char *more_message) const {
sfricke-samsung022fa252020-07-24 03:26:16 -07007311 bool skip = false;
sfricke-samsung21286f82021-11-16 08:21:46 -08007312
7313 // if driver supports protectedNoFault the operation is valid, just has undefined values
7314 if ((!phys_dev_props_core11.protectedNoFault) && (cb_state->unprotected == true) && (buffer_state->unprotected == false)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06007315 LogObjectList objlist(cb_state->commandBuffer());
7316 objlist.add(buffer_state->buffer());
locke-lunarg351c9d82020-10-23 14:43:21 -06007317 skip |= LogError(objlist, vuid, "%s: command buffer %s is unprotected while buffer %s is a protected buffer.%s", cmd_name,
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06007318 report_data->FormatHandle(cb_state->commandBuffer()).c_str(),
7319 report_data->FormatHandle(buffer_state->buffer()).c_str(), more_message);
sfricke-samsung022fa252020-07-24 03:26:16 -07007320 }
7321 return skip;
7322}
7323
7324// Validates the buffer is allowed to be unprotected
7325bool CoreChecks::ValidateUnprotectedBuffer(const CMD_BUFFER_STATE *cb_state, const BUFFER_STATE *buffer_state, const char *cmd_name,
locke-lunarg351c9d82020-10-23 14:43:21 -06007326 const char *vuid, const char *more_message) const {
sfricke-samsung022fa252020-07-24 03:26:16 -07007327 bool skip = false;
sfricke-samsung21286f82021-11-16 08:21:46 -08007328
7329 // if driver supports protectedNoFault the operation is valid, just has undefined values
7330 if ((!phys_dev_props_core11.protectedNoFault) && (cb_state->unprotected == false) && (buffer_state->unprotected == true)) {
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06007331 LogObjectList objlist(cb_state->commandBuffer());
7332 objlist.add(buffer_state->buffer());
locke-lunarg351c9d82020-10-23 14:43:21 -06007333 skip |= LogError(objlist, vuid, "%s: command buffer %s is protected while buffer %s is an unprotected buffer.%s", cmd_name,
Jeremy Gebben14b0d1a2021-05-15 20:15:41 -06007334 report_data->FormatHandle(cb_state->commandBuffer()).c_str(),
7335 report_data->FormatHandle(buffer_state->buffer()).c_str(), more_message);
sfricke-samsung022fa252020-07-24 03:26:16 -07007336 }
7337 return skip;
7338}