1 /*-------------------------------------------------------------------------
2 * Vulkan CTS Framework
3 * --------------------
4 *
5 * Copyright (c) 2015 The Khronos Group Inc.
6 * Copyright (c) 2015 Imagination Technologies Ltd.
7 * Copyright (c) 2015 Google Inc.
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 *
21 *//*!
22 * \file
23 * \brief Utilities for images.
24 *//*--------------------------------------------------------------------*/
25
26 #include "vkImageUtil.hpp"
27 #include "vkRefUtil.hpp"
28 #include "vkQueryUtil.hpp"
29 #include "vkTypeUtil.hpp"
30 #include "vkCmdUtil.hpp"
31 #include "tcuTextureUtil.hpp"
32 #include "deMath.h"
33 #include "vkMemUtil.hpp"
34 #include "vkObjUtil.hpp"
35
36 #include <map>
37 #include <assert.h>
38
39 namespace vk
40 {
41
isFloatFormat(VkFormat format)42 bool isFloatFormat(VkFormat format)
43 {
44 return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_FLOATING_POINT;
45 }
46
isUnormFormat(VkFormat format)47 bool isUnormFormat(VkFormat format)
48 {
49 return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
50 }
51
isSnormFormat(VkFormat format)52 bool isSnormFormat(VkFormat format)
53 {
54 return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT;
55 }
56
isIntFormat(VkFormat format)57 bool isIntFormat(VkFormat format)
58 {
59 return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER;
60 }
61
isUintFormat(VkFormat format)62 bool isUintFormat(VkFormat format)
63 {
64 return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
65 }
66
isScaledFormat(VkFormat format)67 bool isScaledFormat(VkFormat format)
68 {
69 // update this mapping if VkFormat changes
70 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
71
72 switch (format)
73 {
74 case VK_FORMAT_R8_USCALED:
75 case VK_FORMAT_R8_SSCALED:
76 case VK_FORMAT_R8G8_USCALED:
77 case VK_FORMAT_R8G8_SSCALED:
78 case VK_FORMAT_R8G8B8_USCALED:
79 case VK_FORMAT_R8G8B8_SSCALED:
80 case VK_FORMAT_R8G8B8A8_USCALED:
81 case VK_FORMAT_R8G8B8A8_SSCALED:
82 case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
83 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
84 case VK_FORMAT_R16_USCALED:
85 case VK_FORMAT_R16_SSCALED:
86 case VK_FORMAT_R16G16_USCALED:
87 case VK_FORMAT_R16G16_SSCALED:
88 case VK_FORMAT_R16G16B16_USCALED:
89 case VK_FORMAT_R16G16B16_SSCALED:
90 case VK_FORMAT_R16G16B16A16_USCALED:
91 case VK_FORMAT_R16G16B16A16_SSCALED:
92 case VK_FORMAT_B8G8R8_USCALED:
93 case VK_FORMAT_B8G8R8_SSCALED:
94 case VK_FORMAT_B8G8R8A8_USCALED:
95 case VK_FORMAT_B8G8R8A8_SSCALED:
96 case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
97 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
98 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
99 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
100 return true;
101
102 default:
103 return false;
104 }
105 }
106
isDepthStencilFormat(VkFormat format)107 bool isDepthStencilFormat(VkFormat format)
108 {
109 if (isCompressedFormat(format))
110 return false;
111
112 if (isYCbCrFormat(format))
113 return false;
114
115 const tcu::TextureFormat tcuFormat = mapVkFormat(format);
116 return tcuFormat.order == tcu::TextureFormat::D || tcuFormat.order == tcu::TextureFormat::S ||
117 tcuFormat.order == tcu::TextureFormat::DS;
118 }
119
isSrgbFormat(VkFormat format)120 bool isSrgbFormat(VkFormat format)
121 {
122 switch (mapVkFormat(format).order)
123 {
124 case tcu::TextureFormat::sR:
125 case tcu::TextureFormat::sRG:
126 case tcu::TextureFormat::sRGB:
127 case tcu::TextureFormat::sRGBA:
128 case tcu::TextureFormat::sBGR:
129 case tcu::TextureFormat::sBGRA:
130 return true;
131
132 default:
133 return false;
134 }
135 }
136
137 // Returns true if the format has padding bits.
isPaddedFormat(VkFormat format)138 bool isPaddedFormat(VkFormat format)
139 {
140 bool isPadded = false;
141
142 switch (format)
143 {
144 case VK_FORMAT_X8_D24_UNORM_PACK32:
145 case VK_FORMAT_R10X6_UNORM_PACK16:
146 case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
147 case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
148 case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
149 case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
150 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
151 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
152 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
153 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
154 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
155 case VK_FORMAT_R12X4_UNORM_PACK16:
156 case VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
157 case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
158 case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
159 case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
160 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
161 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
162 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
163 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
164 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
165 #ifndef CTS_USES_VULKANSC
166 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16:
167 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16:
168 #endif // CTS_USES_VULKANSC
169 isPadded = true;
170 break;
171 default:
172 break;
173 }
174
175 return isPadded;
176 }
177
isAlphaOnlyFormat(VkFormat format)178 bool isAlphaOnlyFormat(VkFormat format)
179 {
180 if (isCompressedFormat(format))
181 return false;
182
183 if (isYCbCrFormat(format))
184 return false;
185
186 return (mapVkFormat(format).order == tcu::TextureFormat::A);
187 }
188
isUfloatFormat(VkFormat format)189 bool isUfloatFormat(VkFormat format)
190 {
191 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
192
193 switch (format)
194 {
195 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
196 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
197 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
198 return true;
199
200 default:
201 return false;
202 }
203 }
204
isSfloatFormat(VkFormat format)205 bool isSfloatFormat(VkFormat format)
206 {
207 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
208
209 switch (format)
210 {
211 case VK_FORMAT_R16_SFLOAT:
212 case VK_FORMAT_R16G16_SFLOAT:
213 case VK_FORMAT_R16G16B16_SFLOAT:
214 case VK_FORMAT_R16G16B16A16_SFLOAT:
215 case VK_FORMAT_R32_SFLOAT:
216 case VK_FORMAT_R32G32_SFLOAT:
217 case VK_FORMAT_R32G32B32_SFLOAT:
218 case VK_FORMAT_R32G32B32A32_SFLOAT:
219 case VK_FORMAT_R64_SFLOAT:
220 case VK_FORMAT_R64G64_SFLOAT:
221 case VK_FORMAT_R64G64B64_SFLOAT:
222 case VK_FORMAT_R64G64B64A64_SFLOAT:
223 case VK_FORMAT_D32_SFLOAT:
224 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
225 return true;
226
227 default:
228 return false;
229 }
230 }
231
isCompressedFormat(VkFormat format)232 bool isCompressedFormat(VkFormat format)
233 {
234 // update this mapping if VkFormat changes
235 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
236
237 switch (format)
238 {
239 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
240 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
241 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
242 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
243 case VK_FORMAT_BC2_UNORM_BLOCK:
244 case VK_FORMAT_BC2_SRGB_BLOCK:
245 case VK_FORMAT_BC3_UNORM_BLOCK:
246 case VK_FORMAT_BC3_SRGB_BLOCK:
247 case VK_FORMAT_BC4_UNORM_BLOCK:
248 case VK_FORMAT_BC4_SNORM_BLOCK:
249 case VK_FORMAT_BC5_UNORM_BLOCK:
250 case VK_FORMAT_BC5_SNORM_BLOCK:
251 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
252 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
253 case VK_FORMAT_BC7_UNORM_BLOCK:
254 case VK_FORMAT_BC7_SRGB_BLOCK:
255 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
256 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
257 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
258 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
259 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
260 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
261 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
262 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
263 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
264 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
265 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
266 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
267 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
268 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
269 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
270 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
271 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
272 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
273 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
274 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
275 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
276 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
277 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
278 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
279 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
280 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
281 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
282 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
283 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
284 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
285 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
286 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
287 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
288 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
289 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
290 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
291 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
292 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
293 return true;
294
295 default:
296 return false;
297 }
298 }
299
isYCbCrFormat(VkFormat format)300 bool isYCbCrFormat(VkFormat format)
301 {
302 switch (format)
303 {
304 case VK_FORMAT_G8B8G8R8_422_UNORM:
305 case VK_FORMAT_B8G8R8G8_422_UNORM:
306 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
307 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
308 case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
309 case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
310 case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
311 case VK_FORMAT_R10X6_UNORM_PACK16:
312 case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
313 case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
314 case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
315 case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
316 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
317 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
318 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
319 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
320 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
321 case VK_FORMAT_R12X4_UNORM_PACK16:
322 case VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
323 case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
324 case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
325 case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
326 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
327 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
328 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
329 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
330 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
331 case VK_FORMAT_G16B16G16R16_422_UNORM:
332 case VK_FORMAT_B16G16R16G16_422_UNORM:
333 case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
334 case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
335 case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
336 case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
337 case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
338 case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT:
339 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT:
340 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT:
341 case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT:
342 return true;
343
344 default:
345 return false;
346 }
347 }
348
isYCbCrExtensionFormat(VkFormat format)349 bool isYCbCrExtensionFormat(VkFormat format)
350 {
351 switch (format)
352 {
353 case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT:
354 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT:
355 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT:
356 case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT:
357 return true;
358
359 default:
360 return false;
361 }
362 }
363
isYCbCrConversionFormat(VkFormat format)364 bool isYCbCrConversionFormat(VkFormat format)
365 {
366 switch (format)
367 {
368 case VK_FORMAT_G8B8G8R8_422_UNORM:
369 case VK_FORMAT_B8G8R8G8_422_UNORM:
370 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
371 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
372 case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
373 case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
374 case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
375 case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
376 case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
377 case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
378 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
379 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
380 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
381 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
382 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
383 case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
384 case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
385 case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
386 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
387 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
388 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
389 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
390 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
391 case VK_FORMAT_G16B16G16R16_422_UNORM:
392 case VK_FORMAT_B16G16R16G16_422_UNORM:
393 case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
394 case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
395 case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
396 case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
397 case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
398 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT:
399 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT:
400 case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT:
401 case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT:
402 return true;
403
404 default:
405 return false;
406 }
407 }
408
isYCbCr420Format(VkFormat format)409 bool isYCbCr420Format(VkFormat format)
410 {
411 switch (format)
412 {
413 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
414 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
415 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
416 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
417 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
418 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
419 case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
420 case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
421 return true;
422
423 default:
424 return false;
425 }
426 }
427
isYCbCr422Format(VkFormat format)428 bool isYCbCr422Format(VkFormat format)
429 {
430 switch (format)
431 {
432 case VK_FORMAT_G8B8G8R8_422_UNORM:
433 case VK_FORMAT_B8G8R8G8_422_UNORM:
434 case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
435 case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
436 case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
437 case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
438 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
439 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
440 case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
441 case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
442 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
443 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
444 case VK_FORMAT_G16B16G16R16_422_UNORM:
445 case VK_FORMAT_B16G16R16G16_422_UNORM:
446 case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
447 case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
448 return true;
449
450 default:
451 return false;
452 }
453 }
454
isPvrtcFormat(VkFormat format)455 bool isPvrtcFormat(VkFormat format)
456 {
457 #ifndef CTS_USES_VULKANSC
458 switch (format)
459 {
460 case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG:
461 case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG:
462 case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG:
463 case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG:
464 case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG:
465 case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG:
466 case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG:
467 case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG:
468 return true;
469 default:
470 return false;
471 }
472 #else
473 DE_UNREF(format);
474 #endif
475 return false;
476 }
477
478 const std::map<VkFormat, std::string> spirvFormats = {
479 {VK_FORMAT_R32G32B32A32_SFLOAT, "Rgba32f"},
480 {VK_FORMAT_R32G32_SFLOAT, "Rg32f"},
481 {VK_FORMAT_R32_SFLOAT, "R32f"},
482 {VK_FORMAT_R16G16B16A16_SFLOAT, "Rgba16f"},
483 {VK_FORMAT_R16G16_SFLOAT, "Rg16f"},
484 {VK_FORMAT_R16_SFLOAT, "R16f"},
485 {VK_FORMAT_R16G16B16A16_UNORM, "Rgba16"},
486 {VK_FORMAT_R16G16_UNORM, "Rg16"},
487 {VK_FORMAT_R16_UNORM, "R16"},
488 {VK_FORMAT_R16G16B16A16_SNORM, "Rgba16Snorm"},
489 {VK_FORMAT_R16G16_SNORM, "Rg16Snorm"},
490 {VK_FORMAT_R16_SNORM, "R16Snorm"},
491 {VK_FORMAT_A2B10G10R10_UNORM_PACK32, "Rgb10A2"},
492 {VK_FORMAT_B10G11R11_UFLOAT_PACK32, "R11fG11fB10f"},
493 {VK_FORMAT_R8G8B8A8_UNORM, "Rgba8"},
494 {VK_FORMAT_R8G8_UNORM, "Rg8"},
495 {VK_FORMAT_R8_UNORM, "R8"},
496
497 {VK_FORMAT_R8G8B8A8_SNORM, "Rgba8Snorm"},
498 {VK_FORMAT_R8G8_SNORM, "Rg8Snorm"},
499 {VK_FORMAT_R8_SNORM, "R8Snorm"},
500 {VK_FORMAT_R32G32B32A32_SINT, "Rgba32i"},
501 {VK_FORMAT_R32G32_SINT, "Rg32i"},
502 {VK_FORMAT_R32_SINT, "R32i"},
503 {VK_FORMAT_R16G16B16A16_SINT, "Rgba16i"},
504 {VK_FORMAT_R16G16_SINT, "Rg16i"},
505 {VK_FORMAT_R16_SINT, "R16i"},
506 {VK_FORMAT_R8G8B8A8_SINT, "Rgba8i"},
507 {VK_FORMAT_R8G8_SINT, "Rg8i"},
508 {VK_FORMAT_R8_SINT, "R8i"},
509 {VK_FORMAT_R32G32B32A32_UINT, "Rgba32ui"},
510 {VK_FORMAT_R32G32_UINT, "Rg32ui"},
511 {VK_FORMAT_R32_UINT, "R32ui"},
512 {VK_FORMAT_R16G16B16A16_UINT, "Rgba16ui"},
513 {VK_FORMAT_R16G16_UINT, "Rg16ui"},
514 {VK_FORMAT_R16_UINT, "R16ui"},
515 {VK_FORMAT_A2B10G10R10_UINT_PACK32, "Rgb10a2ui"},
516 {VK_FORMAT_R8G8B8A8_UINT, "Rgba8ui"},
517 {VK_FORMAT_R8G8_UINT, "Rg8ui"},
518 {VK_FORMAT_R8_UINT, "R8ui"},
519
520 {VK_FORMAT_R64_SINT, "R64i"},
521 {VK_FORMAT_R64_UINT, "R64ui"},
522 };
523
hasSpirvFormat(VkFormat fmt)524 bool hasSpirvFormat(VkFormat fmt)
525 {
526 auto iter = spirvFormats.find(fmt);
527 return (iter != spirvFormats.end());
528 }
529
getSpirvFormat(VkFormat fmt)530 const std::string getSpirvFormat(VkFormat fmt)
531 {
532 auto iter = spirvFormats.find(fmt);
533 assert(iter != spirvFormats.end());
534 return iter->second;
535 }
536
is64BitIntegerFormat(VkFormat format)537 bool is64BitIntegerFormat(VkFormat format)
538 {
539 const auto tcuFormat = mapVkFormat(format);
540 return (tcuFormat.type == tcu::TextureFormat::UNSIGNED_INT64 || tcuFormat.type == tcu::TextureFormat::SIGNED_INT64);
541 }
542
getYCbCrPlanarFormatDescription(VkFormat format)543 const PlanarFormatDescription &getYCbCrPlanarFormatDescription(VkFormat format)
544 {
545 using tcu::TextureFormat;
546
547 const uint32_t chanR = PlanarFormatDescription::CHANNEL_R;
548 const uint32_t chanG = PlanarFormatDescription::CHANNEL_G;
549 const uint32_t chanB = PlanarFormatDescription::CHANNEL_B;
550 const uint32_t chanA = PlanarFormatDescription::CHANNEL_A;
551
552 const uint8_t unorm = (uint8_t)tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
553
554 if (format >= VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT && format <= VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT)
555 {
556 static const PlanarFormatDescription s_formatInfo[] = {
557 // VK_FORMAT_G8_B8R8_2PLANE_444_UNORM
558 {2, // planes
559 chanR | chanG | chanB,
560 1,
561 1,
562 {
563 // Size WDiv HDiv planeCompatibleFormat
564 {1, 1, 1, VK_FORMAT_R8_UNORM},
565 {2, 1, 1, VK_FORMAT_R8G8_UNORM},
566 {0, 0, 0, VK_FORMAT_UNDEFINED},
567 },
568 { // Plane Type Offs Size Stride
569 {1, unorm, 8, 8, 2}, // R
570 {0, unorm, 0, 8, 1}, // G
571 {1, unorm, 0, 8, 2}, // B
572 {0, 0, 0, 0, 0}}},
573 // VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT
574 {2, // planes
575 chanR | chanG | chanB,
576 1,
577 1,
578 {
579 // Size WDiv HDiv planeCompatibleFormat
580 {2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16},
581 {4, 1, 1, VK_FORMAT_R10X6G10X6_UNORM_2PACK16},
582 {0, 0, 0, VK_FORMAT_UNDEFINED},
583 },
584 { // Plane Type Offs Size Stride
585 {1, unorm, 22, 10, 4}, // R
586 {0, unorm, 6, 10, 2}, // G
587 {1, unorm, 6, 10, 4}, // B
588 {0, 0, 0, 0, 0}}},
589 // VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT
590 {2, // planes
591 chanR | chanG | chanB,
592 1,
593 1,
594 {
595 // Size WDiv HDiv planeCompatibleFormat
596 {2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16},
597 {4, 1, 1, VK_FORMAT_R12X4G12X4_UNORM_2PACK16},
598 {0, 0, 0, VK_FORMAT_UNDEFINED},
599 },
600 { // Plane Type Offs Size Stride
601 {1, unorm, 20, 12, 4}, // R
602 {0, unorm, 4, 12, 2}, // G
603 {1, unorm, 4, 12, 4}, // B
604 {0, 0, 0, 0, 0}}},
605 // VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT
606 {2, // planes
607 chanR | chanG | chanB,
608 1,
609 1,
610 {
611 // Size WDiv HDiv planeCompatibleFormat
612 {2, 1, 1, VK_FORMAT_R16_UNORM},
613 {4, 1, 1, VK_FORMAT_R16G16_UNORM},
614 {0, 0, 0, VK_FORMAT_UNDEFINED},
615 },
616 { // Plane Type Offs Size Stride
617 {1, unorm, 16, 16, 4}, // R
618 {0, unorm, 0, 16, 2}, // G
619 {1, unorm, 0, 16, 4}, // B
620 {0, 0, 0, 0, 0}}},
621 };
622
623 const size_t offset = (size_t)VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT;
624
625 DE_ASSERT(de::inBounds<size_t>((size_t)format, offset, offset + (size_t)DE_LENGTH_OF_ARRAY(s_formatInfo)));
626
627 return s_formatInfo[(size_t)format - offset];
628 }
629
630 static const PlanarFormatDescription s_formatInfo[] = {
631 // VK_FORMAT_G8B8G8R8_422_UNORM
632 {1, // planes
633 chanR | chanG | chanB,
634 2,
635 1,
636 {
637 // Size WDiv HDiv planeCompatibleFormat
638 {4, 1, 1, VK_FORMAT_G8B8G8R8_422_UNORM},
639 {0, 0, 0, VK_FORMAT_UNDEFINED},
640 {0, 0, 0, VK_FORMAT_UNDEFINED},
641 },
642 { // Plane Type Offs Size Stride
643 {0, unorm, 24, 8, 4}, // R
644 {0, unorm, 0, 8, 2}, // G
645 {0, unorm, 8, 8, 4}, // B
646 {0, 0, 0, 0, 0}}},
647 // VK_FORMAT_B8G8R8G8_422_UNORM
648 {1, // planes
649 chanR | chanG | chanB,
650 2,
651 1,
652 {
653 // Size WDiv HDiv planeCompatibleFormat
654 {4, 1, 1, VK_FORMAT_B8G8R8G8_422_UNORM},
655 {0, 0, 0, VK_FORMAT_UNDEFINED},
656 {0, 0, 0, VK_FORMAT_UNDEFINED},
657 },
658 { // Plane Type Offs Size Stride
659 {0, unorm, 16, 8, 4}, // R
660 {0, unorm, 8, 8, 2}, // G
661 {0, unorm, 0, 8, 4}, // B
662 {0, 0, 0, 0, 0}}},
663 // VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM
664 {3, // planes
665 chanR | chanG | chanB,
666 1,
667 1,
668 {
669 // Size WDiv HDiv planeCompatibleFormat
670 {1, 1, 1, VK_FORMAT_R8_UNORM},
671 {1, 2, 2, VK_FORMAT_R8_UNORM},
672 {1, 2, 2, VK_FORMAT_R8_UNORM},
673 },
674 { // Plane Type Offs Size Stride
675 {2, unorm, 0, 8, 1}, // R
676 {0, unorm, 0, 8, 1}, // G
677 {1, unorm, 0, 8, 1}, // B
678 {0, 0, 0, 0, 0}}},
679 // VK_FORMAT_G8_B8R8_2PLANE_420_UNORM
680 {2, // planes
681 chanR | chanG | chanB,
682 1,
683 1,
684 {
685 // Size WDiv HDiv planeCompatibleFormat
686 {1, 1, 1, VK_FORMAT_R8_UNORM},
687 {2, 2, 2, VK_FORMAT_R8G8_UNORM},
688 {0, 0, 0, VK_FORMAT_UNDEFINED},
689 },
690 { // Plane Type Offs Size Stride
691 {1, unorm, 8, 8, 2}, // R
692 {0, unorm, 0, 8, 1}, // G
693 {1, unorm, 0, 8, 2}, // B
694 {0, 0, 0, 0, 0}}},
695 // VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM
696 {3, // planes
697 chanR | chanG | chanB,
698 1,
699 1,
700 {
701 // Size WDiv HDiv planeCompatibleFormat
702 {1, 1, 1, VK_FORMAT_R8_UNORM},
703 {1, 2, 1, VK_FORMAT_R8_UNORM},
704 {1, 2, 1, VK_FORMAT_R8_UNORM},
705 },
706 { // Plane Type Offs Size Stride
707 {2, unorm, 0, 8, 1}, // R
708 {0, unorm, 0, 8, 1}, // G
709 {1, unorm, 0, 8, 1}, // B
710 {0, 0, 0, 0, 0}}},
711 // VK_FORMAT_G8_B8R8_2PLANE_422_UNORM
712 {2, // planes
713 chanR | chanG | chanB,
714 1,
715 1,
716 {
717 // Size WDiv HDiv planeCompatibleFormat
718 {1, 1, 1, VK_FORMAT_R8_UNORM},
719 {2, 2, 1, VK_FORMAT_R8G8_UNORM},
720 {0, 0, 0, VK_FORMAT_UNDEFINED},
721 },
722 { // Plane Type Offs Size Stride
723 {1, unorm, 8, 8, 2}, // R
724 {0, unorm, 0, 8, 1}, // G
725 {1, unorm, 0, 8, 2}, // B
726 {0, 0, 0, 0, 0}}},
727 // VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM
728 {3, // planes
729 chanR | chanG | chanB,
730 1,
731 1,
732 {
733 // Size WDiv HDiv planeCompatibleFormat
734 {1, 1, 1, VK_FORMAT_R8_UNORM},
735 {1, 1, 1, VK_FORMAT_R8_UNORM},
736 {1, 1, 1, VK_FORMAT_R8_UNORM},
737 },
738 { // Plane Type Offs Size Stride
739 {2, unorm, 0, 8, 1}, // R
740 {0, unorm, 0, 8, 1}, // G
741 {1, unorm, 0, 8, 1}, // B
742 {0, 0, 0, 0, 0}}},
743 // VK_FORMAT_R10X6_UNORM_PACK16
744 {1, // planes
745 chanR,
746 1,
747 1,
748 {
749 // Size WDiv HDiv planeCompatibleFormat
750 {2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16},
751 {0, 0, 0, VK_FORMAT_UNDEFINED},
752 {0, 0, 0, VK_FORMAT_UNDEFINED},
753 },
754 {
755 // Plane Type Offs Size Stride
756 {0, unorm, 6, 10, 2}, // R
757 {0, 0, 0, 0, 0},
758 {0, 0, 0, 0, 0},
759 {0, 0, 0, 0, 0},
760 }},
761 // VK_FORMAT_R10X6G10X6_UNORM_2PACK16
762 {1, // planes
763 chanR | chanG,
764 1,
765 1,
766 {
767 // Size WDiv HDiv planeCompatibleFormat
768 {4, 1, 1, VK_FORMAT_R10X6G10X6_UNORM_2PACK16},
769 {0, 0, 0, VK_FORMAT_UNDEFINED},
770 {0, 0, 0, VK_FORMAT_UNDEFINED},
771 },
772 {
773 // Plane Type Offs Size Stride
774 {0, unorm, 6, 10, 4}, // R
775 {0, unorm, 22, 10, 4}, // G
776 {0, 0, 0, 0, 0},
777 {0, 0, 0, 0, 0},
778 }},
779 // VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16
780 {1, // planes
781 chanR | chanG | chanB | chanA,
782 1,
783 1,
784 {
785 // Size WDiv HDiv planeCompatibleFormat
786 {8, 1, 1, VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16},
787 {0, 0, 0, VK_FORMAT_UNDEFINED},
788 {0, 0, 0, VK_FORMAT_UNDEFINED},
789 },
790 {
791 // Plane Type Offs Size Stride
792 {0, unorm, 6, 10, 8}, // R
793 {0, unorm, 22, 10, 8}, // G
794 {0, unorm, 38, 10, 8}, // B
795 {0, unorm, 54, 10, 8}, // A
796 }},
797 // VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16
798 {1, // planes
799 chanR | chanG | chanB,
800 2,
801 1,
802 {
803 // Size WDiv HDiv planeCompatibleFormat
804 {8, 1, 1, VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16},
805 {0, 0, 0, VK_FORMAT_UNDEFINED},
806 {0, 0, 0, VK_FORMAT_UNDEFINED},
807 },
808 { // Plane Type Offs Size Stride
809 {0, unorm, 54, 10, 8}, // R
810 {0, unorm, 6, 10, 4}, // G
811 {0, unorm, 22, 10, 8}, // B
812 {0, 0, 0, 0, 0}}},
813 // VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16
814 {1, // planes
815 chanR | chanG | chanB,
816 2,
817 1,
818 {
819 // Size WDiv HDiv planeCompatibleFormat
820 {8, 1, 1, VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16},
821 {0, 0, 0, VK_FORMAT_UNDEFINED},
822 {0, 0, 0, VK_FORMAT_UNDEFINED},
823 },
824 { // Plane Type Offs Size Stride
825 {0, unorm, 38, 10, 8}, // R
826 {0, unorm, 22, 10, 4}, // G
827 {0, unorm, 6, 10, 8}, // B
828 {0, 0, 0, 0, 0}}},
829 // VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16
830 {3, // planes
831 chanR | chanG | chanB,
832 1,
833 1,
834 {
835 // Size WDiv HDiv planeCompatibleFormat
836 {2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16},
837 {2, 2, 2, VK_FORMAT_R10X6_UNORM_PACK16},
838 {2, 2, 2, VK_FORMAT_R10X6_UNORM_PACK16},
839 },
840 { // Plane Type Offs Size Stride
841 {2, unorm, 6, 10, 2}, // R
842 {0, unorm, 6, 10, 2}, // G
843 {1, unorm, 6, 10, 2}, // B
844 {0, 0, 0, 0, 0}}},
845 // VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16
846 {2, // planes
847 chanR | chanG | chanB,
848 1,
849 1,
850 {
851 // Size WDiv HDiv planeCompatibleFormat
852 {2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16},
853 {4, 2, 2, VK_FORMAT_R10X6G10X6_UNORM_2PACK16},
854 {0, 0, 0, VK_FORMAT_UNDEFINED},
855 },
856 { // Plane Type Offs Size Stride
857 {1, unorm, 22, 10, 4}, // R
858 {0, unorm, 6, 10, 2}, // G
859 {1, unorm, 6, 10, 4}, // B
860 {0, 0, 0, 0, 0}}},
861 // VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16
862 {3, // planes
863 chanR | chanG | chanB,
864 1,
865 1,
866 {
867 // Size WDiv HDiv planeCompatibleFormat
868 {2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16},
869 {2, 2, 1, VK_FORMAT_R10X6_UNORM_PACK16},
870 {2, 2, 1, VK_FORMAT_R10X6_UNORM_PACK16},
871 },
872 { // Plane Type Offs Size Stride
873 {2, unorm, 6, 10, 2}, // R
874 {0, unorm, 6, 10, 2}, // G
875 {1, unorm, 6, 10, 2}, // B
876 {0, 0, 0, 0, 0}}},
877 // VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16
878 {2, // planes
879 chanR | chanG | chanB,
880 1,
881 1,
882 {
883 // Size WDiv HDiv planeCompatibleFormat
884 {2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16},
885 {4, 2, 1, VK_FORMAT_R10X6G10X6_UNORM_2PACK16},
886 {0, 0, 0, VK_FORMAT_UNDEFINED},
887 },
888 { // Plane Type Offs Size Stride
889 {1, unorm, 22, 10, 4}, // R
890 {0, unorm, 6, 10, 2}, // G
891 {1, unorm, 6, 10, 4}, // B
892 {0, 0, 0, 0, 0}}},
893 // VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16
894 {3, // planes
895 chanR | chanG | chanB,
896 1,
897 1,
898 {
899 // Size WDiv HDiv planeCompatibleFormat
900 {2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16},
901 {2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16},
902 {2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16},
903 },
904 { // Plane Type Offs Size Stride
905 {2, unorm, 6, 10, 2}, // R
906 {0, unorm, 6, 10, 2}, // G
907 {1, unorm, 6, 10, 2}, // B
908 {0, 0, 0, 0, 0}}},
909 // VK_FORMAT_R12X4_UNORM_PACK16
910 {1, // planes
911 chanR,
912 1,
913 1,
914 {
915 // Size WDiv HDiv planeCompatibleFormat
916 {2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16},
917 {0, 0, 0, VK_FORMAT_UNDEFINED},
918 {0, 0, 0, VK_FORMAT_UNDEFINED},
919 },
920 {
921 // Plane Type Offs Size Stride
922 {0, unorm, 4, 12, 2}, // R
923 {0, 0, 0, 0, 0},
924 {0, 0, 0, 0, 0},
925 {0, 0, 0, 0, 0},
926 }},
927 // VK_FORMAT_R12X4G12X4_UNORM_2PACK16
928 {1, // planes
929 chanR | chanG,
930 1,
931 1,
932 {
933 // Size WDiv HDiv planeCompatibleFormat
934 {4, 1, 1, VK_FORMAT_R12X4G12X4_UNORM_2PACK16},
935 {0, 0, 0, VK_FORMAT_UNDEFINED},
936 {0, 0, 0, VK_FORMAT_UNDEFINED},
937 },
938 {
939 // Plane Type Offs Size Stride
940 {0, unorm, 4, 12, 4}, // R
941 {0, unorm, 20, 12, 4}, // G
942 {0, 0, 0, 0, 0},
943 {0, 0, 0, 0, 0},
944 }},
945 // VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16
946 {1, // planes
947 chanR | chanG | chanB | chanA,
948 1,
949 1,
950 {
951 // Size WDiv HDiv planeCompatibleFormat
952 {8, 1, 1, VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16},
953 {0, 0, 0, VK_FORMAT_UNDEFINED},
954 {0, 0, 0, VK_FORMAT_UNDEFINED},
955 },
956 {
957 // Plane Type Offs Size Stride
958 {0, unorm, 4, 12, 8}, // R
959 {0, unorm, 20, 12, 8}, // G
960 {0, unorm, 36, 12, 8}, // B
961 {0, unorm, 52, 12, 8}, // A
962 }},
963 // VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16
964 {1, // planes
965 chanR | chanG | chanB,
966 2,
967 1,
968 {
969 // Size WDiv HDiv planeCompatibleFormat
970 {8, 1, 1, VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16},
971 {0, 0, 0, VK_FORMAT_UNDEFINED},
972 {0, 0, 0, VK_FORMAT_UNDEFINED},
973 },
974 { // Plane Type Offs Size Stride
975 {0, unorm, 52, 12, 8}, // R
976 {0, unorm, 4, 12, 4}, // G
977 {0, unorm, 20, 12, 8}, // B
978 {0, 0, 0, 0, 0}}},
979 // VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16
980 {1, // planes
981 chanR | chanG | chanB,
982 2,
983 1,
984 {
985 // Size WDiv HDiv planeCompatibleFormat
986 {8, 1, 1, VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16},
987 {0, 0, 0, VK_FORMAT_UNDEFINED},
988 {0, 0, 0, VK_FORMAT_UNDEFINED},
989 },
990 { // Plane Type Offs Size Stride
991 {0, unorm, 36, 12, 8}, // R
992 {0, unorm, 20, 12, 4}, // G
993 {0, unorm, 4, 12, 8}, // B
994 {0, 0, 0, 0, 0}}},
995 // VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16
996 {3, // planes
997 chanR | chanG | chanB,
998 1,
999 1,
1000 {
1001 // Size WDiv HDiv planeCompatibleFormat
1002 {2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16},
1003 {2, 2, 2, VK_FORMAT_R12X4_UNORM_PACK16},
1004 {2, 2, 2, VK_FORMAT_R12X4_UNORM_PACK16},
1005 },
1006 { // Plane Type Offs Size Stride
1007 {2, unorm, 4, 12, 2}, // R
1008 {0, unorm, 4, 12, 2}, // G
1009 {1, unorm, 4, 12, 2}, // B
1010 {0, 0, 0, 0, 0}}},
1011 // VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16
1012 {2, // planes
1013 chanR | chanG | chanB,
1014 1,
1015 1,
1016 {
1017 // Size WDiv HDiv planeCompatibleFormat
1018 {2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16},
1019 {4, 2, 2, VK_FORMAT_R12X4G12X4_UNORM_2PACK16},
1020 {0, 0, 0, VK_FORMAT_UNDEFINED},
1021 },
1022 { // Plane Type Offs Size Stride
1023 {1, unorm, 20, 12, 4}, // R
1024 {0, unorm, 4, 12, 2}, // G
1025 {1, unorm, 4, 12, 4}, // B
1026 {0, 0, 0, 0, 0}}},
1027 // VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16
1028 {3, // planes
1029 chanR | chanG | chanB,
1030 1,
1031 1,
1032 {
1033 // Size WDiv HDiv planeCompatibleFormat
1034 {2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16},
1035 {2, 2, 1, VK_FORMAT_R12X4_UNORM_PACK16},
1036 {2, 2, 1, VK_FORMAT_R12X4_UNORM_PACK16},
1037 },
1038 { // Plane Type Offs Size Stride
1039 {2, unorm, 4, 12, 2}, // R
1040 {0, unorm, 4, 12, 2}, // G
1041 {1, unorm, 4, 12, 2}, // B
1042 {0, 0, 0, 0, 0}}},
1043 // VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16
1044 {2, // planes
1045 chanR | chanG | chanB,
1046 1,
1047 1,
1048 {
1049 // Size WDiv HDiv planeCompatibleFormat
1050 {2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16},
1051 {4, 2, 1, VK_FORMAT_R12X4G12X4_UNORM_2PACK16},
1052 {0, 0, 0, VK_FORMAT_UNDEFINED},
1053 },
1054 { // Plane Type Offs Size Stride
1055 {1, unorm, 20, 12, 4}, // R
1056 {0, unorm, 4, 12, 2}, // G
1057 {1, unorm, 4, 12, 4}, // B
1058 {0, 0, 0, 0, 0}}},
1059 // VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16
1060 {3, // planes
1061 chanR | chanG | chanB,
1062 1,
1063 1,
1064 {
1065 // Size WDiv HDiv planeCompatibleFormat
1066 {2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16},
1067 {2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16},
1068 {2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16},
1069 },
1070 { // Plane Type Offs Size Stride
1071 {2, unorm, 4, 12, 2}, // R
1072 {0, unorm, 4, 12, 2}, // G
1073 {1, unorm, 4, 12, 2}, // B
1074 {0, 0, 0, 0, 0}}},
1075 // VK_FORMAT_G16B16G16R16_422_UNORM
1076 {1, // planes
1077 chanR | chanG | chanB,
1078 2,
1079 1,
1080 {
1081 // Size WDiv HDiv planeCompatibleFormat
1082 {8, 1, 1, VK_FORMAT_G16B16G16R16_422_UNORM},
1083 {0, 0, 0, VK_FORMAT_UNDEFINED},
1084 {0, 0, 0, VK_FORMAT_UNDEFINED},
1085 },
1086 { // Plane Type Offs Size Stride
1087 {0, unorm, 48, 16, 8}, // R
1088 {0, unorm, 0, 16, 4}, // G
1089 {0, unorm, 16, 16, 8}, // B
1090 {0, 0, 0, 0, 0}}},
1091 // VK_FORMAT_B16G16R16G16_422_UNORM
1092 {1, // planes
1093 chanR | chanG | chanB,
1094 2,
1095 1,
1096 {
1097 // Size WDiv HDiv planeCompatibleFormat
1098 {8, 1, 1, VK_FORMAT_B16G16R16G16_422_UNORM},
1099 {0, 0, 0, VK_FORMAT_UNDEFINED},
1100 {0, 0, 0, VK_FORMAT_UNDEFINED},
1101 },
1102 { // Plane Type Offs Size Stride
1103 {0, unorm, 32, 16, 8}, // R
1104 {0, unorm, 16, 16, 4}, // G
1105 {0, unorm, 0, 16, 8}, // B
1106 {0, 0, 0, 0, 0}}},
1107 // VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM
1108 {3, // planes
1109 chanR | chanG | chanB,
1110 1,
1111 1,
1112 {
1113 // Size WDiv HDiv planeCompatibleFormat
1114 {2, 1, 1, VK_FORMAT_R16_UNORM},
1115 {2, 2, 2, VK_FORMAT_R16_UNORM},
1116 {2, 2, 2, VK_FORMAT_R16_UNORM},
1117 },
1118 { // Plane Type Offs Size Stride
1119 {2, unorm, 0, 16, 2}, // R
1120 {0, unorm, 0, 16, 2}, // G
1121 {1, unorm, 0, 16, 2}, // B
1122 {0, 0, 0, 0, 0}}},
1123 // VK_FORMAT_G16_B16R16_2PLANE_420_UNORM
1124 {2, // planes
1125 chanR | chanG | chanB,
1126 1,
1127 1,
1128 {
1129 // Size WDiv HDiv planeCompatibleFormat
1130 {2, 1, 1, VK_FORMAT_R16_UNORM},
1131 {4, 2, 2, VK_FORMAT_R16G16_UNORM},
1132 {0, 0, 0, VK_FORMAT_UNDEFINED},
1133 },
1134 { // Plane Type Offs Size Stride
1135 {1, unorm, 16, 16, 4}, // R
1136 {0, unorm, 0, 16, 2}, // G
1137 {1, unorm, 0, 16, 4}, // B
1138 {0, 0, 0, 0, 0}}},
1139 // VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM
1140 {3, // planes
1141 chanR | chanG | chanB,
1142 1,
1143 1,
1144 {
1145 // Size WDiv HDiv planeCompatibleFormat
1146 {2, 1, 1, VK_FORMAT_R16_UNORM},
1147 {2, 2, 1, VK_FORMAT_R16_UNORM},
1148 {2, 2, 1, VK_FORMAT_R16_UNORM},
1149 },
1150 { // Plane Type Offs Size Stride
1151 {2, unorm, 0, 16, 2}, // R
1152 {0, unorm, 0, 16, 2}, // G
1153 {1, unorm, 0, 16, 2}, // B
1154 {0, 0, 0, 0, 0}}},
1155 // VK_FORMAT_G16_B16R16_2PLANE_422_UNORM
1156 {2, // planes
1157 chanR | chanG | chanB,
1158 1,
1159 1,
1160 {
1161 // Size WDiv HDiv planeCompatibleFormat
1162 {2, 1, 1, VK_FORMAT_R16_UNORM},
1163 {4, 2, 1, VK_FORMAT_R16G16_UNORM},
1164 {0, 0, 0, VK_FORMAT_UNDEFINED},
1165 },
1166 { // Plane Type Offs Size Stride
1167 {1, unorm, 16, 16, 4}, // R
1168 {0, unorm, 0, 16, 2}, // G
1169 {1, unorm, 0, 16, 4}, // B
1170 {0, 0, 0, 0, 0}}},
1171 // VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM
1172 {3, // planes
1173 chanR | chanG | chanB,
1174 1,
1175 1,
1176 {
1177 // Size WDiv HDiv planeCompatibleFormat
1178 {2, 1, 1, VK_FORMAT_R16_UNORM},
1179 {2, 1, 1, VK_FORMAT_R16_UNORM},
1180 {2, 1, 1, VK_FORMAT_R16_UNORM},
1181 },
1182 { // Plane Type Offs Size Stride
1183 {2, unorm, 0, 16, 2}, // R
1184 {0, unorm, 0, 16, 2}, // G
1185 {1, unorm, 0, 16, 2}, // B
1186 {0, 0, 0, 0, 0}}},
1187 };
1188
1189 const size_t offset = (size_t)VK_FORMAT_G8B8G8R8_422_UNORM;
1190
1191 DE_ASSERT(de::inBounds<size_t>((size_t)format, offset, offset + (size_t)DE_LENGTH_OF_ARRAY(s_formatInfo)));
1192
1193 return s_formatInfo[(size_t)format - offset];
1194 }
1195
getCorePlanarFormatDescription(VkFormat format)1196 PlanarFormatDescription getCorePlanarFormatDescription(VkFormat format)
1197 {
1198 const uint8_t snorm = (uint8_t)tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT;
1199 const uint8_t unorm = (uint8_t)tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
1200 const uint8_t sint = (uint8_t)tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER;
1201 const uint8_t uint = (uint8_t)tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
1202 const uint8_t sfloat = (uint8_t)tcu::TEXTURECHANNELCLASS_FLOATING_POINT;
1203
1204 const uint8_t chanR = (uint8_t)PlanarFormatDescription::CHANNEL_R;
1205 const uint8_t chanG = (uint8_t)PlanarFormatDescription::CHANNEL_G;
1206 const uint8_t chanB = (uint8_t)PlanarFormatDescription::CHANNEL_B;
1207 const uint8_t chanA = (uint8_t)PlanarFormatDescription::CHANNEL_A;
1208
1209 DE_ASSERT(de::inBounds<uint32_t>(format, VK_FORMAT_UNDEFINED + 1, VK_CORE_FORMAT_LAST));
1210
1211 #if (DE_ENDIANNESS != DE_LITTLE_ENDIAN)
1212 #error "Big-endian is not supported"
1213 #endif
1214
1215 switch (format)
1216 {
1217 case VK_FORMAT_R8_UNORM:
1218 {
1219 const PlanarFormatDescription desc = {1, // planes
1220 chanR,
1221 1,
1222 1,
1223 {
1224 // Size WDiv HDiv planeCompatibleFormat
1225 {1, 1, 1, VK_FORMAT_R8_UNORM},
1226 {0, 0, 0, VK_FORMAT_UNDEFINED},
1227 {0, 0, 0, VK_FORMAT_UNDEFINED},
1228 },
1229 {
1230 // Plane Type Offs Size Stride
1231 {0, unorm, 0, 8, 1}, // R
1232 {0, 0, 0, 0, 0}, // G
1233 {0, 0, 0, 0, 0}, // B
1234 {0, 0, 0, 0, 0} // A
1235 }};
1236 return desc;
1237 }
1238
1239 case VK_FORMAT_R8_SNORM:
1240 {
1241 const PlanarFormatDescription desc = {1, // planes
1242 chanR,
1243 1,
1244 1,
1245 {
1246 // Size WDiv HDiv planeCompatibleFormat
1247 {1, 1, 1, VK_FORMAT_R8_SNORM},
1248 {0, 0, 0, VK_FORMAT_UNDEFINED},
1249 {0, 0, 0, VK_FORMAT_UNDEFINED},
1250 },
1251 {
1252 // Plane Type Offs Size Stride
1253 {0, snorm, 0, 8, 1}, // R
1254 {0, 0, 0, 0, 0}, // G
1255 {0, 0, 0, 0, 0}, // B
1256 {0, 0, 0, 0, 0} // A
1257 }};
1258 return desc;
1259 }
1260
1261 case VK_FORMAT_R8G8_UNORM:
1262 {
1263 const PlanarFormatDescription desc = {1, // planes
1264 chanR | chanG,
1265 1,
1266 1,
1267 {
1268 // Size WDiv HDiv planeCompatibleFormat
1269 {2, 1, 1, VK_FORMAT_R8G8_UNORM},
1270 {0, 0, 0, VK_FORMAT_UNDEFINED},
1271 {0, 0, 0, VK_FORMAT_UNDEFINED},
1272 },
1273 {
1274 // Plane Type Offs Size Stride
1275 {0, unorm, 0, 8, 2}, // R
1276 {0, unorm, 8, 8, 2}, // G
1277 {0, 0, 0, 0, 0}, // B
1278 {0, 0, 0, 0, 0} // A
1279 }};
1280 return desc;
1281 }
1282
1283 case VK_FORMAT_R8G8_SNORM:
1284 {
1285 const PlanarFormatDescription desc = {1, // planes
1286 chanR | chanG,
1287 1,
1288 1,
1289 {
1290 // Size WDiv HDiv planeCompatibleFormat
1291 {2, 1, 1, VK_FORMAT_R8G8_SNORM},
1292 {0, 0, 0, VK_FORMAT_UNDEFINED},
1293 {0, 0, 0, VK_FORMAT_UNDEFINED},
1294 },
1295 {
1296 // Plane Type Offs Size Stride
1297 {0, snorm, 0, 8, 2}, // R
1298 {0, snorm, 8, 8, 2}, // G
1299 {0, 0, 0, 0, 0}, // B
1300 {0, 0, 0, 0, 0} // A
1301 }};
1302 return desc;
1303 }
1304
1305 case VK_FORMAT_R16_UNORM:
1306 {
1307 const PlanarFormatDescription desc = {1, // planes
1308 chanR,
1309 1,
1310 1,
1311 {
1312 // Size WDiv HDiv planeCompatibleFormat
1313 {2, 1, 1, VK_FORMAT_R16_UNORM},
1314 {0, 0, 0, VK_FORMAT_UNDEFINED},
1315 {0, 0, 0, VK_FORMAT_UNDEFINED},
1316 },
1317 {
1318 // Plane Type Offs Size Stride
1319 {0, unorm, 0, 16, 2}, // R
1320 {0, 0, 0, 0, 0}, // G
1321 {0, 0, 0, 0, 0}, // B
1322 {0, 0, 0, 0, 0} // A
1323 }};
1324 return desc;
1325 }
1326
1327 case VK_FORMAT_R16_SNORM:
1328 {
1329 const PlanarFormatDescription desc = {1, // planes
1330 chanR,
1331 1,
1332 1,
1333 {
1334 // Size WDiv HDiv planeCompatibleFormat
1335 {2, 1, 1, VK_FORMAT_R16_SNORM},
1336 {0, 0, 0, VK_FORMAT_UNDEFINED},
1337 {0, 0, 0, VK_FORMAT_UNDEFINED},
1338 },
1339 {
1340 // Plane Type Offs Size Stride
1341 {0, snorm, 0, 16, 2}, // R
1342 {0, 0, 0, 0, 0}, // G
1343 {0, 0, 0, 0, 0}, // B
1344 {0, 0, 0, 0, 0} // A
1345 }};
1346 return desc;
1347 }
1348
1349 case VK_FORMAT_R16G16_UNORM:
1350 {
1351 const PlanarFormatDescription desc = {1, // planes
1352 chanR | chanG,
1353 1,
1354 1,
1355 {
1356 // Size WDiv HDiv planeCompatibleFormat
1357 {4, 1, 1, VK_FORMAT_R16G16_UNORM},
1358 {0, 0, 0, VK_FORMAT_UNDEFINED},
1359 {0, 0, 0, VK_FORMAT_UNDEFINED},
1360 },
1361 {
1362 // Plane Type Offs Size Stride
1363 {0, unorm, 0, 16, 4}, // R
1364 {0, unorm, 16, 16, 4}, // G
1365 {0, 0, 0, 0, 0}, // B
1366 {0, 0, 0, 0, 0} // A
1367 }};
1368 return desc;
1369 }
1370
1371 case VK_FORMAT_R16G16_SNORM:
1372 {
1373 const PlanarFormatDescription desc = {1, // planes
1374 chanR | chanG,
1375 1,
1376 1,
1377 {
1378 // Size WDiv HDiv planeCompatibleFormat
1379 {4, 1, 1, VK_FORMAT_R16G16_SNORM},
1380 {0, 0, 0, VK_FORMAT_UNDEFINED},
1381 {0, 0, 0, VK_FORMAT_UNDEFINED},
1382 },
1383 {
1384 // Plane Type Offs Size Stride
1385 {0, snorm, 0, 16, 4}, // R
1386 {0, snorm, 16, 16, 4}, // G
1387 {0, 0, 0, 0, 0}, // B
1388 {0, 0, 0, 0, 0} // A
1389 }};
1390 return desc;
1391 }
1392
1393 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
1394 {
1395 const PlanarFormatDescription desc = {1, // planes
1396 chanR | chanG | chanB,
1397 1,
1398 1,
1399 {
1400 // Size WDiv HDiv planeCompatibleFormat
1401 {4, 1, 1, VK_FORMAT_B10G11R11_UFLOAT_PACK32},
1402 {0, 0, 0, VK_FORMAT_UNDEFINED},
1403 {0, 0, 0, VK_FORMAT_UNDEFINED},
1404 },
1405 {
1406 // Plane Type Offs Size Stride
1407 {0, unorm, 0, 11, 4}, // R
1408 {0, unorm, 11, 11, 4}, // G
1409 {0, unorm, 22, 10, 4}, // B
1410 {0, 0, 0, 0, 0} // A
1411 }};
1412 return desc;
1413 }
1414
1415 case VK_FORMAT_R4G4_UNORM_PACK8:
1416 {
1417 const PlanarFormatDescription desc = {1, // planes
1418 chanR | chanG,
1419 1,
1420 1,
1421 {
1422 // Size WDiv HDiv planeCompatibleFormat
1423 {1, 1, 1, VK_FORMAT_R4G4_UNORM_PACK8},
1424 {0, 0, 0, VK_FORMAT_UNDEFINED},
1425 {0, 0, 0, VK_FORMAT_UNDEFINED},
1426 },
1427 {
1428 // Plane Type Offs Size Stride
1429 {0, unorm, 4, 4, 1}, // R
1430 {0, unorm, 0, 4, 1}, // G
1431 {0, 0, 0, 0, 0}, // B
1432 {0, 0, 0, 0, 0} // A
1433 }};
1434 return desc;
1435 }
1436
1437 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
1438 {
1439 const PlanarFormatDescription desc = {1, // planes
1440 chanR | chanG | chanB | chanA,
1441 1,
1442 1,
1443 {
1444 // Size WDiv HDiv planeCompatibleFormat
1445 {2, 1, 1, VK_FORMAT_R4G4B4A4_UNORM_PACK16},
1446 {0, 0, 0, VK_FORMAT_UNDEFINED},
1447 {0, 0, 0, VK_FORMAT_UNDEFINED},
1448 },
1449 {
1450 // Plane Type Offs Size Stride
1451 {0, unorm, 12, 4, 2}, // R
1452 {0, unorm, 8, 4, 2}, // G
1453 {0, unorm, 4, 4, 2}, // B
1454 {0, unorm, 0, 4, 2} // A
1455 }};
1456 return desc;
1457 }
1458
1459 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
1460 {
1461 const PlanarFormatDescription desc = {1, // planes
1462 chanR | chanG | chanB | chanA,
1463 1,
1464 1,
1465 {
1466 // Size WDiv HDiv planeCompatibleFormat
1467 {2, 1, 1, VK_FORMAT_B4G4R4A4_UNORM_PACK16},
1468 {0, 0, 0, VK_FORMAT_UNDEFINED},
1469 {0, 0, 0, VK_FORMAT_UNDEFINED},
1470 },
1471 {
1472 // Plane Type Offs Size Stride
1473 {0, unorm, 4, 4, 2}, // R
1474 {0, unorm, 8, 4, 2}, // G
1475 {0, unorm, 12, 4, 2}, // B
1476 {0, unorm, 0, 4, 2} // A
1477 }};
1478 return desc;
1479 }
1480
1481 case VK_FORMAT_R5G6B5_UNORM_PACK16:
1482 {
1483 const PlanarFormatDescription desc = {1, // planes
1484 chanR | chanG | chanB,
1485 1,
1486 1,
1487 {
1488 // Size WDiv HDiv planeCompatibleFormat
1489 {2, 1, 1, VK_FORMAT_R5G6B5_UNORM_PACK16},
1490 {0, 0, 0, VK_FORMAT_UNDEFINED},
1491 {0, 0, 0, VK_FORMAT_UNDEFINED},
1492 },
1493 {
1494 // Plane Type Offs Size Stride
1495 {0, unorm, 11, 5, 2}, // R
1496 {0, unorm, 5, 6, 2}, // G
1497 {0, unorm, 0, 5, 2}, // B
1498 {0, 0, 0, 0, 0} // A
1499 }};
1500 return desc;
1501 }
1502
1503 case VK_FORMAT_B5G6R5_UNORM_PACK16:
1504 {
1505 const PlanarFormatDescription desc = {1, // planes
1506 chanR | chanG | chanB,
1507 1,
1508 1,
1509 {
1510 // Size WDiv HDiv planeCompatibleFormat
1511 {2, 1, 1, VK_FORMAT_B5G6R5_UNORM_PACK16},
1512 {0, 0, 0, VK_FORMAT_UNDEFINED},
1513 {0, 0, 0, VK_FORMAT_UNDEFINED},
1514 },
1515 {
1516 // Plane Type Offs Size Stride
1517 {0, unorm, 0, 5, 2}, // R
1518 {0, unorm, 5, 6, 2}, // G
1519 {0, unorm, 11, 5, 2}, // B
1520 {0, 0, 0, 0, 0} // A
1521 }};
1522 return desc;
1523 }
1524
1525 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
1526 {
1527 const PlanarFormatDescription desc = {1, // planes
1528 chanR | chanG | chanB | chanA,
1529 1,
1530 1,
1531 {
1532 // Size WDiv HDiv planeCompatibleFormat
1533 {2, 1, 1, VK_FORMAT_R5G5B5A1_UNORM_PACK16},
1534 {0, 0, 0, VK_FORMAT_UNDEFINED},
1535 {0, 0, 0, VK_FORMAT_UNDEFINED},
1536 },
1537 {
1538 // Plane Type Offs Size Stride
1539 {0, unorm, 11, 5, 2}, // R
1540 {0, unorm, 6, 5, 2}, // G
1541 {0, unorm, 1, 5, 2}, // B
1542 {0, unorm, 0, 1, 2} // A
1543 }};
1544 return desc;
1545 }
1546
1547 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
1548 {
1549 const PlanarFormatDescription desc = {1, // planes
1550 chanR | chanG | chanB | chanA,
1551 1,
1552 1,
1553 {
1554 // Size WDiv HDiv planeCompatibleFormat
1555 {2, 1, 1, VK_FORMAT_B5G5R5A1_UNORM_PACK16},
1556 {0, 0, 0, VK_FORMAT_UNDEFINED},
1557 {0, 0, 0, VK_FORMAT_UNDEFINED},
1558 },
1559 {
1560 // Plane Type Offs Size Stride
1561 {0, unorm, 1, 5, 2}, // R
1562 {0, unorm, 6, 5, 2}, // G
1563 {0, unorm, 11, 5, 2}, // B
1564 {0, unorm, 0, 1, 2} // A
1565 }};
1566 return desc;
1567 }
1568
1569 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
1570 {
1571 const PlanarFormatDescription desc = {1, // planes
1572 chanR | chanG | chanB | chanA,
1573 1,
1574 1,
1575 {
1576 // Size WDiv HDiv planeCompatibleFormat
1577 {2, 1, 1, VK_FORMAT_A1R5G5B5_UNORM_PACK16},
1578 {0, 0, 0, VK_FORMAT_UNDEFINED},
1579 {0, 0, 0, VK_FORMAT_UNDEFINED},
1580 },
1581 {
1582 // Plane Type Offs Size Stride
1583 {0, unorm, 10, 5, 2}, // R
1584 {0, unorm, 5, 5, 2}, // G
1585 {0, unorm, 0, 5, 2}, // B
1586 {0, unorm, 15, 1, 2} // A
1587 }};
1588 return desc;
1589 }
1590
1591 case VK_FORMAT_R8G8B8_UNORM:
1592 {
1593 const PlanarFormatDescription desc = {1, // planes
1594 chanR | chanG | chanB,
1595 1,
1596 1,
1597 {
1598 // Size WDiv HDiv planeCompatibleFormat
1599 {3, 1, 1, VK_FORMAT_R8G8B8_UNORM},
1600 {0, 0, 0, VK_FORMAT_UNDEFINED},
1601 {0, 0, 0, VK_FORMAT_UNDEFINED},
1602 },
1603 {
1604 // Plane Type Offs Size Stride
1605 {0, unorm, 0, 8, 3}, // R
1606 {0, unorm, 8, 8, 3}, // G
1607 {0, unorm, 16, 8, 3}, // B
1608 {0, 0, 0, 0, 0} // A
1609 }};
1610 return desc;
1611 }
1612
1613 case VK_FORMAT_B8G8R8_UNORM:
1614 {
1615 const PlanarFormatDescription desc = {1, // planes
1616 chanR | chanG | chanB,
1617 1,
1618 1,
1619 {
1620 // Size WDiv HDiv planeCompatibleFormat
1621 {3, 1, 1, VK_FORMAT_B8G8R8_UNORM},
1622 {0, 0, 0, VK_FORMAT_UNDEFINED},
1623 {0, 0, 0, VK_FORMAT_UNDEFINED},
1624 },
1625 {
1626 // Plane Type Offs Size Stride
1627 {0, unorm, 16, 8, 3}, // R
1628 {0, unorm, 8, 8, 3}, // G
1629 {0, unorm, 0, 8, 3}, // B
1630 {0, 0, 0, 0, 0} // A
1631 }};
1632 return desc;
1633 }
1634
1635 case VK_FORMAT_R8G8B8A8_UNORM:
1636 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
1637 {
1638 const PlanarFormatDescription desc = {1, // planes
1639 chanR | chanG | chanB | chanA,
1640 1,
1641 1,
1642 {
1643 // Size WDiv HDiv planeCompatibleFormat
1644 {4, 1, 1, VK_FORMAT_R8G8B8A8_UNORM},
1645 {0, 0, 0, VK_FORMAT_UNDEFINED},
1646 {0, 0, 0, VK_FORMAT_UNDEFINED},
1647 },
1648 {
1649 // Plane Type Offs Size Stride
1650 {0, unorm, 0, 8, 4}, // R
1651 {0, unorm, 8, 8, 4}, // G
1652 {0, unorm, 16, 8, 4}, // B
1653 {0, unorm, 24, 8, 4} // A
1654 }};
1655 return desc;
1656 }
1657
1658 case VK_FORMAT_B8G8R8A8_UNORM:
1659 {
1660 const PlanarFormatDescription desc = {1, // planes
1661 chanR | chanG | chanB | chanA,
1662 1,
1663 1,
1664 {
1665 // Size WDiv HDiv planeCompatibleFormat
1666 {4, 1, 1, VK_FORMAT_B8G8R8A8_UNORM},
1667 {0, 0, 0, VK_FORMAT_UNDEFINED},
1668 {0, 0, 0, VK_FORMAT_UNDEFINED},
1669 },
1670 {
1671 // Plane Type Offs Size Stride
1672 {0, unorm, 16, 8, 4}, // R
1673 {0, unorm, 8, 8, 4}, // G
1674 {0, unorm, 0, 8, 4}, // B
1675 {0, unorm, 24, 8, 4} // A
1676 }};
1677 return desc;
1678 }
1679
1680 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
1681 {
1682 const PlanarFormatDescription desc = {1, // planes
1683 chanR | chanG | chanB | chanA,
1684 1,
1685 1,
1686 {
1687 // Size WDiv HDiv planeCompatibleFormat
1688 {4, 1, 1, VK_FORMAT_A2R10G10B10_UNORM_PACK32},
1689 {0, 0, 0, VK_FORMAT_UNDEFINED},
1690 {0, 0, 0, VK_FORMAT_UNDEFINED},
1691 },
1692 {
1693 // Plane Type Offs Size Stride
1694 {0, unorm, 20, 10, 4}, // R
1695 {0, unorm, 10, 10, 4}, // G
1696 {0, unorm, 0, 10, 4}, // B
1697 {0, unorm, 30, 2, 4} // A
1698 }};
1699 return desc;
1700 }
1701
1702 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
1703 {
1704 const PlanarFormatDescription desc = {1, // planes
1705 chanR | chanG | chanB | chanA,
1706 1,
1707 1,
1708 {
1709 // Size WDiv HDiv planeCompatibleFormat
1710 {4, 1, 1, VK_FORMAT_A2B10G10R10_UNORM_PACK32},
1711 {0, 0, 0, VK_FORMAT_UNDEFINED},
1712 {0, 0, 0, VK_FORMAT_UNDEFINED},
1713 },
1714 {
1715 // Plane Type Offs Size Stride
1716 {0, unorm, 0, 10, 4}, // R
1717 {0, unorm, 10, 10, 4}, // G
1718 {0, unorm, 20, 10, 4}, // B
1719 {0, unorm, 30, 2, 4} // A
1720 }};
1721 return desc;
1722 }
1723
1724 case VK_FORMAT_R16G16B16_UNORM:
1725 {
1726 const PlanarFormatDescription desc = {1, // planes
1727 chanR | chanG | chanB,
1728 1,
1729 1,
1730 {
1731 // Size WDiv HDiv planeCompatibleFormat
1732 {6, 1, 1, VK_FORMAT_R16G16B16_UNORM},
1733 {0, 0, 0, VK_FORMAT_UNDEFINED},
1734 {0, 0, 0, VK_FORMAT_UNDEFINED},
1735 },
1736 {
1737 // Plane Type Offs Size Stride
1738 {0, unorm, 0, 16, 6}, // R
1739 {0, unorm, 16, 16, 6}, // G
1740 {0, unorm, 32, 16, 6}, // B
1741 {0, 0, 0, 0, 0} // A
1742 }};
1743 return desc;
1744 }
1745
1746 case VK_FORMAT_R16G16B16A16_UNORM:
1747 {
1748 const PlanarFormatDescription desc = {1, // planes
1749 chanR | chanG | chanB | chanA,
1750 1,
1751 1,
1752 {
1753 // Size WDiv HDiv planeCompatibleFormat
1754 {8, 1, 1, VK_FORMAT_R16G16B16A16_UNORM},
1755 {0, 0, 0, VK_FORMAT_UNDEFINED},
1756 {0, 0, 0, VK_FORMAT_UNDEFINED},
1757 },
1758 {
1759 // Plane Type Offs Size Stride
1760 {0, unorm, 0, 16, 8}, // R
1761 {0, unorm, 16, 16, 8}, // G
1762 {0, unorm, 32, 16, 8}, // B
1763 {0, unorm, 48, 16, 8} // A
1764 }};
1765 return desc;
1766 }
1767
1768 case VK_FORMAT_R8_SINT:
1769 {
1770 const PlanarFormatDescription desc = {1, // planes
1771 chanR,
1772 1,
1773 1,
1774 {
1775 // Size WDiv HDiv planeCompatibleFormat
1776 {1, 1, 1, VK_FORMAT_R8_SINT},
1777 {0, 0, 0, VK_FORMAT_UNDEFINED},
1778 {0, 0, 0, VK_FORMAT_UNDEFINED},
1779 },
1780 {
1781 // Plane Type Offs Size Stride
1782 {0, sint, 0, 8, 1}, // R
1783 {0, 0, 0, 0, 0}, // G
1784 {0, 0, 0, 0, 0}, // B
1785 {0, 0, 0, 0, 0} // A
1786 }};
1787 return desc;
1788 }
1789
1790 case VK_FORMAT_R16_SINT:
1791 {
1792 const PlanarFormatDescription desc = {1, // planes
1793 chanR,
1794 1,
1795 1,
1796 {
1797 // Size WDiv HDiv planeCompatibleFormat
1798 {2, 1, 1, VK_FORMAT_R16_SINT},
1799 {0, 0, 0, VK_FORMAT_UNDEFINED},
1800 {0, 0, 0, VK_FORMAT_UNDEFINED},
1801 },
1802 {
1803 // Plane Type Offs Size Stride
1804 {0, sint, 0, 16, 2}, // R
1805 {0, 0, 0, 0, 0}, // G
1806 {0, 0, 0, 0, 0}, // B
1807 {0, 0, 0, 0, 0} // A
1808 }};
1809 return desc;
1810 }
1811
1812 case VK_FORMAT_R32_SINT:
1813 {
1814 const PlanarFormatDescription desc = {1, // planes
1815 chanR,
1816 1,
1817 1,
1818 {
1819 // Size WDiv HDiv planeCompatibleFormat
1820 {4, 1, 1, VK_FORMAT_R32_SINT},
1821 {0, 0, 0, VK_FORMAT_UNDEFINED},
1822 {0, 0, 0, VK_FORMAT_UNDEFINED},
1823 },
1824 {
1825 // Plane Type Offs Size Stride
1826 {0, sint, 0, 32, 4}, // R
1827 {0, 0, 0, 0, 0}, // G
1828 {0, 0, 0, 0, 0}, // B
1829 {0, 0, 0, 0, 0} // A
1830 }};
1831 return desc;
1832 }
1833
1834 case VK_FORMAT_R64_SINT:
1835 {
1836 const PlanarFormatDescription desc = {1, // planes
1837 chanR,
1838 1,
1839 1,
1840 {
1841 // Size WDiv HDiv planeCompatibleFormat
1842 {8, 1, 1, VK_FORMAT_R64_SINT},
1843 {0, 0, 0, VK_FORMAT_UNDEFINED},
1844 {0, 0, 0, VK_FORMAT_UNDEFINED},
1845 },
1846 {
1847 // Plane Type Offs Size Stride
1848 {0, sint, 0, 64, 8}, // R
1849 {0, 0, 0, 0, 0}, // G
1850 {0, 0, 0, 0, 0}, // B
1851 {0, 0, 0, 0, 0} // A
1852 }};
1853 return desc;
1854 }
1855
1856 case VK_FORMAT_R8G8_SINT:
1857 {
1858 const PlanarFormatDescription desc = {1, // planes
1859 chanR | chanG,
1860 1,
1861 1,
1862 {
1863 // Size WDiv HDiv planeCompatibleFormat
1864 {2, 1, 1, VK_FORMAT_R8G8_SINT},
1865 {0, 0, 0, VK_FORMAT_UNDEFINED},
1866 {0, 0, 0, VK_FORMAT_UNDEFINED},
1867 },
1868 {
1869 // Plane Type Offs Size Stride
1870 {0, sint, 0, 8, 2}, // R
1871 {0, sint, 8, 8, 2}, // G
1872 {0, 0, 0, 0, 0}, // B
1873 {0, 0, 0, 0, 0} // A
1874 }};
1875 return desc;
1876 }
1877
1878 case VK_FORMAT_R16G16_SINT:
1879 {
1880 const PlanarFormatDescription desc = {1, // planes
1881 chanR | chanG,
1882 1,
1883 1,
1884 {
1885 // Size WDiv HDiv planeCompatibleFormat
1886 {4, 1, 1, VK_FORMAT_R16G16_SINT},
1887 {0, 0, 0, VK_FORMAT_UNDEFINED},
1888 {0, 0, 0, VK_FORMAT_UNDEFINED},
1889 },
1890 {
1891 // Plane Type Offs Size Stride
1892 {0, sint, 0, 16, 4}, // R
1893 {0, sint, 16, 16, 4}, // G
1894 {0, 0, 0, 0, 0}, // B
1895 {0, 0, 0, 0, 0} // A
1896 }};
1897 return desc;
1898 }
1899
1900 case VK_FORMAT_R32G32_SINT:
1901 {
1902 const PlanarFormatDescription desc = {1, // planes
1903 chanR | chanG,
1904 1,
1905 1,
1906 {
1907 // Size WDiv HDiv planeCompatibleFormat
1908 {8, 1, 1, VK_FORMAT_R32G32_SINT},
1909 {0, 0, 0, VK_FORMAT_UNDEFINED},
1910 {0, 0, 0, VK_FORMAT_UNDEFINED},
1911 },
1912 {
1913 // Plane Type Offs Size Stride
1914 {0, sint, 0, 32, 8}, // R
1915 {0, sint, 32, 32, 8}, // G
1916 {0, 0, 0, 0, 0}, // B
1917 {0, 0, 0, 0, 0} // A
1918 }};
1919 return desc;
1920 }
1921
1922 case VK_FORMAT_R8G8B8A8_SINT:
1923 {
1924 const PlanarFormatDescription desc = {1, // planes
1925 chanR | chanG | chanB | chanA,
1926 1,
1927 1,
1928 {
1929 // Size WDiv HDiv planeCompatibleFormat
1930 {4, 1, 1, VK_FORMAT_R8G8B8A8_SINT},
1931 {0, 0, 0, VK_FORMAT_UNDEFINED},
1932 {0, 0, 0, VK_FORMAT_UNDEFINED},
1933 },
1934 {
1935 // Plane Type Offs Size Stride
1936 {0, sint, 0, 8, 4}, // R
1937 {0, sint, 8, 8, 4}, // G
1938 {0, sint, 16, 8, 4}, // B
1939 {0, sint, 24, 8, 4} // A
1940 }};
1941 return desc;
1942 }
1943
1944 case VK_FORMAT_R16G16B16A16_SINT:
1945 {
1946 const PlanarFormatDescription desc = {1, // planes
1947 chanR | chanG | chanB | chanA,
1948 1,
1949 1,
1950 {
1951 // Size WDiv HDiv planeCompatibleFormat
1952 {8, 1, 1, VK_FORMAT_R16G16B16A16_SINT},
1953 {0, 0, 0, VK_FORMAT_UNDEFINED},
1954 {0, 0, 0, VK_FORMAT_UNDEFINED},
1955 },
1956 {
1957 // Plane Type Offs Size Stride
1958 {0, sint, 0, 16, 8}, // R
1959 {0, sint, 16, 16, 8}, // G
1960 {0, sint, 32, 16, 8}, // B
1961 {0, sint, 48, 16, 8} // A
1962 }};
1963 return desc;
1964 }
1965
1966 case VK_FORMAT_R32G32B32A32_SINT:
1967 {
1968 const PlanarFormatDescription desc = {1, // planes
1969 chanR | chanG | chanB | chanA,
1970 1,
1971 1,
1972 {
1973 // Size WDiv HDiv planeCompatibleFormat
1974 {16, 1, 1, VK_FORMAT_R32G32B32A32_SINT},
1975 {0, 0, 0, VK_FORMAT_UNDEFINED},
1976 {0, 0, 0, VK_FORMAT_UNDEFINED},
1977 },
1978 {
1979 // Plane Type Offs Size Stride
1980 {0, sint, 0, 32, 16}, // R
1981 {0, sint, 32, 32, 16}, // G
1982 {0, sint, 64, 32, 16}, // B
1983 {0, sint, 96, 32, 16} // A
1984 }};
1985 return desc;
1986 }
1987
1988 case VK_FORMAT_R8_UINT:
1989 {
1990 const PlanarFormatDescription desc = {1, // planes
1991 chanR,
1992 1,
1993 1,
1994 {
1995 // Size WDiv HDiv planeCompatibleFormat
1996 {1, 1, 1, VK_FORMAT_R8_UINT},
1997 {0, 0, 0, VK_FORMAT_UNDEFINED},
1998 {0, 0, 0, VK_FORMAT_UNDEFINED},
1999 },
2000 {
2001 // Plane Type Offs Size Stride
2002 {0, uint, 0, 8, 1}, // R
2003 {0, 0, 0, 0, 0}, // G
2004 {0, 0, 0, 0, 0}, // B
2005 {0, 0, 0, 0, 0} // A
2006 }};
2007 return desc;
2008 }
2009
2010 case VK_FORMAT_R16_UINT:
2011 {
2012 const PlanarFormatDescription desc = {1, // planes
2013 chanR,
2014 1,
2015 1,
2016 {
2017 // Size WDiv HDiv planeCompatibleFormat
2018 {2, 1, 1, VK_FORMAT_R16_UINT},
2019 {0, 0, 0, VK_FORMAT_UNDEFINED},
2020 {0, 0, 0, VK_FORMAT_UNDEFINED},
2021 },
2022 {
2023 // Plane Type Offs Size Stride
2024 {0, uint, 0, 16, 2}, // R
2025 {0, 0, 0, 0, 0}, // G
2026 {0, 0, 0, 0, 0}, // B
2027 {0, 0, 0, 0, 0} // A
2028 }};
2029 return desc;
2030 }
2031
2032 case VK_FORMAT_R32_UINT:
2033 {
2034 const PlanarFormatDescription desc = {1, // planes
2035 chanR,
2036 1,
2037 1,
2038 {
2039 // Size WDiv HDiv planeCompatibleFormat
2040 {4, 1, 1, VK_FORMAT_R32_UINT},
2041 {0, 0, 0, VK_FORMAT_UNDEFINED},
2042 {0, 0, 0, VK_FORMAT_UNDEFINED},
2043 },
2044 {
2045 // Plane Type Offs Size Stride
2046 {0, uint, 0, 32, 4}, // R
2047 {0, 0, 0, 0, 0}, // G
2048 {0, 0, 0, 0, 0}, // B
2049 {0, 0, 0, 0, 0} // A
2050 }};
2051 return desc;
2052 }
2053
2054 case VK_FORMAT_R64_UINT:
2055 {
2056 const PlanarFormatDescription desc = {1, // planes
2057 chanR,
2058 1,
2059 1,
2060 {
2061 // Size WDiv HDiv planeCompatibleFormat
2062 {8, 1, 1, VK_FORMAT_R64_UINT},
2063 {0, 0, 0, VK_FORMAT_UNDEFINED},
2064 {0, 0, 0, VK_FORMAT_UNDEFINED},
2065 },
2066 {
2067 // Plane Type Offs Size Stride
2068 {0, uint, 0, 64, 8}, // R
2069 {0, 0, 0, 0, 0}, // G
2070 {0, 0, 0, 0, 0}, // B
2071 {0, 0, 0, 0, 0} // A
2072 }};
2073 return desc;
2074 }
2075
2076 case VK_FORMAT_R8G8_UINT:
2077 {
2078 const PlanarFormatDescription desc = {1, // planes
2079 chanR | chanG,
2080 1,
2081 1,
2082 {
2083 // Size WDiv HDiv planeCompatibleFormat
2084 {2, 1, 1, VK_FORMAT_R8G8_UINT},
2085 {0, 0, 0, VK_FORMAT_UNDEFINED},
2086 {0, 0, 0, VK_FORMAT_UNDEFINED},
2087 },
2088 {
2089 // Plane Type Offs Size Stride
2090 {0, uint, 0, 8, 2}, // R
2091 {0, uint, 8, 8, 2}, // G
2092 {0, 0, 0, 0, 0}, // B
2093 {0, 0, 0, 0, 0} // A
2094 }};
2095 return desc;
2096 }
2097
2098 case VK_FORMAT_R16G16_UINT:
2099 {
2100 const PlanarFormatDescription desc = {1, // planes
2101 chanR | chanG,
2102 1,
2103 1,
2104 {
2105 // Size WDiv HDiv planeCompatibleFormat
2106 {4, 1, 1, VK_FORMAT_R16G16_UINT},
2107 {0, 0, 0, VK_FORMAT_UNDEFINED},
2108 {0, 0, 0, VK_FORMAT_UNDEFINED},
2109 },
2110 {
2111 // Plane Type Offs Size Stride
2112 {0, uint, 0, 16, 4}, // R
2113 {0, uint, 16, 16, 4}, // G
2114 {0, 0, 0, 0, 0}, // B
2115 {0, 0, 0, 0, 0} // A
2116 }};
2117 return desc;
2118 }
2119
2120 case VK_FORMAT_R32G32_UINT:
2121 {
2122 const PlanarFormatDescription desc = {1, // planes
2123 chanR | chanG,
2124 1,
2125 1,
2126 {
2127 // Size WDiv HDiv planeCompatibleFormat
2128 {8, 1, 1, VK_FORMAT_R32G32_UINT},
2129 {0, 0, 0, VK_FORMAT_UNDEFINED},
2130 {0, 0, 0, VK_FORMAT_UNDEFINED},
2131 },
2132 {
2133 // Plane Type Offs Size Stride
2134 {0, uint, 0, 32, 8}, // R
2135 {0, uint, 32, 32, 8}, // G
2136 {0, 0, 0, 0, 0}, // B
2137 {0, 0, 0, 0, 0} // A
2138 }};
2139 return desc;
2140 }
2141
2142 case VK_FORMAT_R8G8B8A8_UINT:
2143 {
2144 const PlanarFormatDescription desc = {1, // planes
2145 chanR | chanG | chanB | chanA,
2146 1,
2147 1,
2148 {
2149 // Size WDiv HDiv planeCompatibleFormat
2150 {4, 1, 1, VK_FORMAT_R8G8B8A8_UINT},
2151 {0, 0, 0, VK_FORMAT_UNDEFINED},
2152 {0, 0, 0, VK_FORMAT_UNDEFINED},
2153 },
2154 {
2155 // Plane Type Offs Size Stride
2156 {0, uint, 0, 8, 4}, // R
2157 {0, uint, 8, 8, 4}, // G
2158 {0, uint, 16, 8, 4}, // B
2159 {0, uint, 24, 8, 4} // A
2160 }};
2161 return desc;
2162 }
2163
2164 case VK_FORMAT_R16G16B16A16_UINT:
2165 {
2166 const PlanarFormatDescription desc = {1, // planes
2167 chanR | chanG | chanB | chanA,
2168 1,
2169 1,
2170 {
2171 // Size WDiv HDiv planeCompatibleFormat
2172 {8, 1, 1, VK_FORMAT_R16G16B16A16_UINT},
2173 {0, 0, 0, VK_FORMAT_UNDEFINED},
2174 {0, 0, 0, VK_FORMAT_UNDEFINED},
2175 },
2176 {
2177 // Plane Type Offs Size Stride
2178 {0, uint, 0, 16, 8}, // R
2179 {0, uint, 16, 16, 8}, // G
2180 {0, uint, 32, 16, 8}, // B
2181 {0, uint, 48, 16, 8} // A
2182 }};
2183 return desc;
2184 }
2185
2186 case VK_FORMAT_R32G32B32A32_UINT:
2187 {
2188 const PlanarFormatDescription desc = {1, // planes
2189 chanR | chanG | chanB | chanA,
2190 1,
2191 1,
2192 {
2193 // Size WDiv HDiv planeCompatibleFormat
2194 {16, 1, 1, VK_FORMAT_R32G32B32A32_UINT},
2195 {0, 0, 0, VK_FORMAT_UNDEFINED},
2196 {0, 0, 0, VK_FORMAT_UNDEFINED},
2197 },
2198 {
2199 // Plane Type Offs Size Stride
2200 {0, uint, 0, 32, 16}, // R
2201 {0, uint, 32, 32, 16}, // G
2202 {0, uint, 64, 32, 16}, // B
2203 {0, uint, 96, 32, 16} // A
2204 }};
2205 return desc;
2206 }
2207
2208 case VK_FORMAT_R8G8B8A8_SNORM:
2209 {
2210 const PlanarFormatDescription desc = {1, // planes
2211 chanR | chanG | chanB | chanA,
2212 1,
2213 1,
2214 {
2215 // Size WDiv HDiv planeCompatibleFormat
2216 {4, 1, 1, VK_FORMAT_R8G8B8A8_SNORM},
2217 {0, 0, 0, VK_FORMAT_UNDEFINED},
2218 {0, 0, 0, VK_FORMAT_UNDEFINED},
2219 },
2220 {
2221 // Plane Type Offs Size Stride
2222 {0, snorm, 0, 8, 4}, // R
2223 {0, snorm, 8, 8, 4}, // G
2224 {0, snorm, 16, 8, 4}, // B
2225 {0, snorm, 24, 8, 4} // A
2226 }};
2227 return desc;
2228 }
2229
2230 case VK_FORMAT_R16G16B16A16_SNORM:
2231 {
2232 const PlanarFormatDescription desc = {1, // planes
2233 chanR | chanG | chanB | chanA,
2234 1,
2235 1,
2236 {
2237 // Size WDiv HDiv planeCompatibleFormat
2238 {8, 1, 1, VK_FORMAT_R16G16B16A16_SNORM},
2239 {0, 0, 0, VK_FORMAT_UNDEFINED},
2240 {0, 0, 0, VK_FORMAT_UNDEFINED},
2241 },
2242 {
2243 // Plane Type Offs Size Stride
2244 {0, snorm, 0, 16, 8}, // R
2245 {0, snorm, 16, 16, 8}, // G
2246 {0, snorm, 32, 16, 8}, // B
2247 {0, snorm, 48, 16, 8} // A
2248 }};
2249 return desc;
2250 }
2251 case VK_FORMAT_R32_SFLOAT:
2252 case VK_FORMAT_D32_SFLOAT:
2253 {
2254 const PlanarFormatDescription desc = {1, // planes
2255 chanR,
2256 1,
2257 1,
2258 {
2259 // Size WDiv HDiv planeCompatibleFormat
2260 {4, 1, 1, VK_FORMAT_R32_SFLOAT},
2261 {0, 0, 0, VK_FORMAT_UNDEFINED},
2262 {0, 0, 0, VK_FORMAT_UNDEFINED},
2263 },
2264 {
2265 // Plane Type Offs Size Stride
2266 {0, sfloat, 0, 32, 4}, // R
2267 {0, 0, 0, 0, 0}, // G
2268 {0, 0, 0, 0, 0}, // B
2269 {0, 0, 0, 0, 0} // A
2270 }};
2271 return desc;
2272 }
2273
2274 case VK_FORMAT_D16_UNORM:
2275 {
2276 const PlanarFormatDescription desc = {1, // planes
2277 chanR,
2278 1,
2279 1,
2280 {
2281 // Size WDiv HDiv planeCompatibleFormat
2282 {2, 1, 1, VK_FORMAT_D16_UNORM},
2283 {0, 0, 0, VK_FORMAT_UNDEFINED},
2284 {0, 0, 0, VK_FORMAT_UNDEFINED},
2285 },
2286 {
2287 // Plane Type Offs Size Stride
2288 {0, unorm, 0, 16, 2}, // R
2289 {0, 0, 0, 0, 0}, // G
2290 {0, 0, 0, 0, 0}, // B
2291 {0, 0, 0, 0, 0} // A
2292 }};
2293 return desc;
2294 }
2295
2296 case VK_FORMAT_S8_UINT:
2297 {
2298 const PlanarFormatDescription desc = {1, // planes
2299 chanR,
2300 1,
2301 1,
2302 {
2303 // Size WDiv HDiv planeCompatibleFormat
2304 {1, 1, 1, VK_FORMAT_S8_UINT},
2305 {0, 0, 0, VK_FORMAT_UNDEFINED},
2306 {0, 0, 0, VK_FORMAT_UNDEFINED},
2307 },
2308 {
2309 // Plane Type Offs Size Stride
2310 {0, uint, 0, 8, 1}, // R
2311 {0, 0, 0, 0, 0}, // G
2312 {0, 0, 0, 0, 0}, // B
2313 {0, 0, 0, 0, 0} // A
2314 }};
2315 return desc;
2316 }
2317
2318 case VK_FORMAT_R32G32B32A32_SFLOAT:
2319 {
2320 const PlanarFormatDescription desc = {1, // planes
2321 chanR | chanG | chanB | chanA,
2322 1,
2323 1,
2324 {
2325 // Size WDiv HDiv planeCompatibleFormat
2326 {16, 1, 1, VK_FORMAT_R32G32B32A32_SFLOAT},
2327 {0, 0, 0, VK_FORMAT_UNDEFINED},
2328 {0, 0, 0, VK_FORMAT_UNDEFINED},
2329 },
2330 {
2331 // Plane Type Offs Size Stride
2332 {0, sfloat, 0, 32, 16}, // R
2333 {0, sfloat, 32, 32, 16}, // G
2334 {0, sfloat, 64, 32, 16}, // B
2335 {0, sfloat, 96, 32, 16}, // A
2336 }};
2337 return desc;
2338 }
2339
2340 case VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT:
2341 {
2342 const PlanarFormatDescription desc = {1, // planes
2343 chanR | chanG | chanB | chanA,
2344 1,
2345 1,
2346 {
2347 // Size WDiv HDiv planeCompatibleFormat
2348 {2, 1, 1, VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT},
2349 {0, 0, 0, VK_FORMAT_UNDEFINED},
2350 {0, 0, 0, VK_FORMAT_UNDEFINED},
2351 },
2352 {
2353 // Plane Type Offs Size Stride
2354 {0, unorm, 8, 4, 2}, // R
2355 {0, unorm, 4, 4, 2}, // G
2356 {0, unorm, 0, 4, 2}, // B
2357 {0, unorm, 12, 4, 2} // A
2358 }};
2359 return desc;
2360 }
2361
2362 case VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT:
2363 {
2364 const PlanarFormatDescription desc = {1, // planes
2365 chanR | chanG | chanB | chanA,
2366 1,
2367 1,
2368 {
2369 // Size WDiv HDiv planeCompatibleFormat
2370 {2, 1, 1, VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT},
2371 {0, 0, 0, VK_FORMAT_UNDEFINED},
2372 {0, 0, 0, VK_FORMAT_UNDEFINED},
2373 },
2374 {
2375 // Plane Type Offs Size Stride
2376 {0, unorm, 0, 4, 2}, // R
2377 {0, unorm, 4, 4, 2}, // G
2378 {0, unorm, 8, 4, 2}, // B
2379 {0, unorm, 12, 4, 2} // A
2380 }};
2381 return desc;
2382 }
2383
2384 #ifndef CTS_USES_VULKANSC
2385 case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR:
2386 {
2387 const PlanarFormatDescription desc{1, // planes
2388 chanR | chanG | chanB | chanA,
2389 1,
2390 1,
2391 {
2392 // Size WDiv HDiv planeCompatibleFormat
2393 {2, 1, 1, VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR},
2394 {0, 0, 0, VK_FORMAT_UNDEFINED},
2395 {0, 0, 0, VK_FORMAT_UNDEFINED},
2396 },
2397 {
2398 // Plane Type Offs Size Stride
2399 {0, unorm, 11, 5, 2}, // R
2400 {0, unorm, 6, 5, 2}, // G
2401 {0, unorm, 1, 5, 2}, // B
2402 {0, unorm, 0, 1, 2} // A
2403 }};
2404 return desc;
2405 }
2406 #endif // CTS_USES_VULKANSC
2407
2408 default:
2409 TCU_THROW(InternalError, "Not implemented");
2410 }
2411 }
2412
getPlanarFormatDescription(VkFormat format)2413 PlanarFormatDescription getPlanarFormatDescription(VkFormat format)
2414 {
2415 if (isYCbCrFormat(format))
2416 return getYCbCrPlanarFormatDescription(format);
2417 #ifndef CTS_USES_VULKANSC
2418 else if (format == VK_FORMAT_A8_UNORM_KHR)
2419 {
2420 const auto unorm = static_cast<uint8_t>(tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT);
2421 const auto chanA = static_cast<uint8_t>(PlanarFormatDescription::CHANNEL_A);
2422
2423 const PlanarFormatDescription desc = {1, // planes
2424 chanA,
2425 1,
2426 1,
2427 {
2428 // Size WDiv HDiv planeCompatibleFormat
2429 {1, 1, 1, VK_FORMAT_A8_UNORM_KHR},
2430 {0, 0, 0, VK_FORMAT_UNDEFINED},
2431 {0, 0, 0, VK_FORMAT_UNDEFINED},
2432 },
2433 {
2434 // Plane Type Offs Size Stride
2435 {0, 0, 0, 0, 0}, // R
2436 {0, 0, 0, 0, 0}, // G
2437 {0, 0, 0, 0, 0}, // B
2438 {0, unorm, 0, 8, 1}, // A
2439 }};
2440
2441 return desc;
2442 }
2443 #endif // CTS_USES_VULKANSC
2444 else
2445 return getCorePlanarFormatDescription(format);
2446 }
2447
getPlaneCount(VkFormat format)2448 int getPlaneCount(VkFormat format)
2449 {
2450 switch (format)
2451 {
2452 case VK_FORMAT_G8B8G8R8_422_UNORM:
2453 case VK_FORMAT_B8G8R8G8_422_UNORM:
2454 case VK_FORMAT_R10X6_UNORM_PACK16:
2455 case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
2456 case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
2457 case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
2458 case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
2459 case VK_FORMAT_R12X4_UNORM_PACK16:
2460 case VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
2461 case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
2462 case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
2463 case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
2464 case VK_FORMAT_G16B16G16R16_422_UNORM:
2465 case VK_FORMAT_B16G16R16G16_422_UNORM:
2466 return 1;
2467
2468 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
2469 case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
2470 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
2471 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
2472 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
2473 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
2474 case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
2475 case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
2476 case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT:
2477 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT:
2478 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT:
2479 case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT:
2480 return 2;
2481
2482 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
2483 case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
2484 case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
2485 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
2486 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
2487 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
2488 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
2489 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
2490 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
2491 case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
2492 case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
2493 case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
2494 return 3;
2495
2496 default:
2497 DE_FATAL("Not YCbCr format");
2498 return 0;
2499 }
2500 }
2501
getMipmapCount(VkFormat format,const vk::PlanarFormatDescription & formatDescription,const VkImageFormatProperties & imageFormatProperties,const VkExtent3D & extent)2502 uint32_t getMipmapCount(VkFormat format, const vk::PlanarFormatDescription &formatDescription,
2503 const VkImageFormatProperties &imageFormatProperties, const VkExtent3D &extent)
2504 {
2505 if (isYCbCrFormat(format))
2506 return 1;
2507 tcu::UVec3 imageAlignment = getImageSizeAlignment(formatDescription);
2508 uint32_t mipmapEdge = std::max(std::max(extent.width, extent.height), extent.depth);
2509 if (imageAlignment.x() > 1)
2510 mipmapEdge = std::min(mipmapEdge, extent.width / imageAlignment.x());
2511 if (imageAlignment.y() > 1)
2512 mipmapEdge = std::min(mipmapEdge, extent.height / imageAlignment.y());
2513 if (imageAlignment.z() > 1)
2514 mipmapEdge = std::min(mipmapEdge, extent.depth / imageAlignment.z());
2515 return std::min(static_cast<uint32_t>(deFloatLog2(static_cast<float>(mipmapEdge))) + 1u,
2516 imageFormatProperties.maxMipLevels);
2517 }
2518
getPlaneSizeInBytes(const PlanarFormatDescription & formatInfo,const VkExtent3D & baseExtents,const uint32_t planeNdx,const uint32_t mipmapLevel,const uint32_t mipmapMemoryAlignment)2519 uint32_t getPlaneSizeInBytes(const PlanarFormatDescription &formatInfo, const VkExtent3D &baseExtents,
2520 const uint32_t planeNdx, const uint32_t mipmapLevel, const uint32_t mipmapMemoryAlignment)
2521 {
2522 VkExtent3D imageExtent = getPlaneExtent(formatInfo, baseExtents, planeNdx, mipmapLevel);
2523 imageExtent.width /= formatInfo.blockWidth;
2524 imageExtent.height /= formatInfo.blockHeight;
2525 return deAlign32(formatInfo.planes[planeNdx].elementSizeBytes * imageExtent.width * imageExtent.height *
2526 imageExtent.depth,
2527 mipmapMemoryAlignment);
2528 }
2529
getPlaneSizeInBytes(const PlanarFormatDescription & formatInfo,const tcu::UVec2 & baseExtents,const uint32_t planeNdx,const uint32_t mipmapLevel,const uint32_t mipmapMemoryAlignment)2530 uint32_t getPlaneSizeInBytes(const PlanarFormatDescription &formatInfo, const tcu::UVec2 &baseExtents,
2531 const uint32_t planeNdx, const uint32_t mipmapLevel, const uint32_t mipmapMemoryAlignment)
2532 {
2533 tcu::UVec2 mipExtents = getPlaneExtent(formatInfo, baseExtents, planeNdx, mipmapLevel) /
2534 tcu::UVec2(formatInfo.blockWidth, formatInfo.blockHeight);
2535 return deAlign32(formatInfo.planes[planeNdx].elementSizeBytes * mipExtents.x() * mipExtents.y(),
2536 mipmapMemoryAlignment);
2537 }
2538
getPlaneExtent(const PlanarFormatDescription & formatInfo,const VkExtent3D & baseExtents,const uint32_t planeNdx,const uint32_t mipmapLevel)2539 VkExtent3D getPlaneExtent(const PlanarFormatDescription &formatInfo, const VkExtent3D &baseExtents,
2540 const uint32_t planeNdx, const uint32_t mipmapLevel)
2541 {
2542 uint32_t widthDivisor = formatInfo.planes[planeNdx].widthDivisor;
2543 uint32_t heightDivisor = formatInfo.planes[planeNdx].heightDivisor;
2544 uint32_t depthDivisor = 1u;
2545 VkExtent3D mip0Extents{baseExtents.width / widthDivisor, baseExtents.height / heightDivisor,
2546 baseExtents.depth / depthDivisor};
2547
2548 return mipLevelExtents(mip0Extents, mipmapLevel);
2549 }
2550
getPlaneExtent(const PlanarFormatDescription & formatInfo,const tcu::UVec2 & baseExtents,const uint32_t planeNdx,const uint32_t mipmapLevel)2551 tcu::UVec2 getPlaneExtent(const PlanarFormatDescription &formatInfo, const tcu::UVec2 &baseExtents,
2552 const uint32_t planeNdx, const uint32_t mipmapLevel)
2553 {
2554 uint32_t widthDivisor = formatInfo.planes[planeNdx].widthDivisor;
2555 uint32_t heightDivisor = formatInfo.planes[planeNdx].heightDivisor;
2556 tcu::UVec2 mip0Extents{baseExtents.x() / widthDivisor, baseExtents.y() / heightDivisor};
2557
2558 return tcu::UVec2{std::max(mip0Extents.x() >> mipmapLevel, 1u), std::max(mip0Extents.y() >> mipmapLevel, 1u)};
2559 }
2560
getImageSizeAlignment(VkFormat format)2561 tcu::UVec3 getImageSizeAlignment(VkFormat format)
2562 {
2563 return getImageSizeAlignment(getPlanarFormatDescription(format));
2564 }
2565
getImageSizeAlignment(const PlanarFormatDescription & formatInfo)2566 tcu::UVec3 getImageSizeAlignment(const PlanarFormatDescription &formatInfo)
2567 {
2568 tcu::UVec3 imgAlignment{formatInfo.blockWidth, formatInfo.blockHeight, 1};
2569 for (uint32_t planeNdx = 0; planeNdx < formatInfo.numPlanes; ++planeNdx)
2570 {
2571 imgAlignment.x() = std::max(imgAlignment.x(), static_cast<uint32_t>(formatInfo.planes[planeNdx].widthDivisor));
2572 imgAlignment.y() = std::max(imgAlignment.y(), static_cast<uint32_t>(formatInfo.planes[planeNdx].heightDivisor));
2573 }
2574 return imgAlignment;
2575 }
2576
getBlockExtent(VkFormat format)2577 tcu::UVec2 getBlockExtent(VkFormat format)
2578 {
2579 return getBlockExtent(getPlanarFormatDescription(format));
2580 }
2581
getBlockExtent(const PlanarFormatDescription & formatInfo)2582 tcu::UVec2 getBlockExtent(const PlanarFormatDescription &formatInfo)
2583 {
2584 return tcu::UVec2{formatInfo.blockWidth, formatInfo.blockHeight};
2585 }
2586
getPlaneCompatibleFormat(VkFormat format,uint32_t planeNdx)2587 VkFormat getPlaneCompatibleFormat(VkFormat format, uint32_t planeNdx)
2588 {
2589 return getPlaneCompatibleFormat(getPlanarFormatDescription(format), planeNdx);
2590 }
2591
getPlaneCompatibleFormat(const PlanarFormatDescription & formatInfo,uint32_t planeNdx)2592 VkFormat getPlaneCompatibleFormat(const PlanarFormatDescription &formatInfo, uint32_t planeNdx)
2593 {
2594 DE_ASSERT(planeNdx < formatInfo.numPlanes);
2595 return formatInfo.planes[planeNdx].planeCompatibleFormat;
2596 }
2597
getPlaneAspect(uint32_t planeNdx)2598 VkImageAspectFlagBits getPlaneAspect(uint32_t planeNdx)
2599 {
2600 DE_ASSERT(de::inBounds(planeNdx, 0u, 3u));
2601 return (VkImageAspectFlagBits)(VK_IMAGE_ASPECT_PLANE_0_BIT << planeNdx);
2602 }
2603
getAspectPlaneNdx(VkImageAspectFlagBits flags)2604 uint32_t getAspectPlaneNdx(VkImageAspectFlagBits flags)
2605 {
2606 switch (flags)
2607 {
2608 case VK_IMAGE_ASPECT_PLANE_0_BIT:
2609 return 0;
2610 case VK_IMAGE_ASPECT_PLANE_1_BIT:
2611 return 1;
2612 case VK_IMAGE_ASPECT_PLANE_2_BIT:
2613 return 2;
2614 default:
2615 DE_FATAL("Invalid plane aspect");
2616 return 0;
2617 }
2618 }
2619
isChromaSubsampled(VkFormat format)2620 bool isChromaSubsampled(VkFormat format)
2621 {
2622 switch (format)
2623 {
2624 case VK_FORMAT_G8B8G8R8_422_UNORM:
2625 case VK_FORMAT_B8G8R8G8_422_UNORM:
2626 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
2627 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
2628 case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
2629 case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
2630 case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
2631 case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
2632 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
2633 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
2634 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
2635 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
2636 case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
2637 case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
2638 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
2639 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
2640 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
2641 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
2642 case VK_FORMAT_G16B16G16R16_422_UNORM:
2643 case VK_FORMAT_B16G16R16G16_422_UNORM:
2644 case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
2645 case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
2646 case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
2647 case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
2648 return true;
2649
2650 default:
2651 return false;
2652 }
2653 }
2654
isSupportedByFramework(VkFormat format)2655 bool isSupportedByFramework(VkFormat format)
2656 {
2657 #ifndef CTS_USES_VULKANSC
2658 if (format == VK_FORMAT_A8_UNORM_KHR || format == VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR)
2659 return true;
2660 #endif // CTS_USES_VULKANSC
2661
2662 if (format == VK_FORMAT_UNDEFINED || format > VK_CORE_FORMAT_LAST)
2663 return false;
2664
2665 switch (format)
2666 {
2667 case VK_FORMAT_R64_UINT:
2668 case VK_FORMAT_R64_SINT:
2669 case VK_FORMAT_R64_SFLOAT:
2670 case VK_FORMAT_R64G64_UINT:
2671 case VK_FORMAT_R64G64_SINT:
2672 case VK_FORMAT_R64G64_SFLOAT:
2673 case VK_FORMAT_R64G64B64_UINT:
2674 case VK_FORMAT_R64G64B64_SINT:
2675 case VK_FORMAT_R64G64B64_SFLOAT:
2676 case VK_FORMAT_R64G64B64A64_UINT:
2677 case VK_FORMAT_R64G64B64A64_SINT:
2678 case VK_FORMAT_R64G64B64A64_SFLOAT:
2679 // \todo [2016-12-01 pyry] Support 64-bit channel types
2680 return false;
2681
2682 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
2683 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
2684 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
2685 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
2686 case VK_FORMAT_BC2_UNORM_BLOCK:
2687 case VK_FORMAT_BC2_SRGB_BLOCK:
2688 case VK_FORMAT_BC3_UNORM_BLOCK:
2689 case VK_FORMAT_BC3_SRGB_BLOCK:
2690 case VK_FORMAT_BC4_UNORM_BLOCK:
2691 case VK_FORMAT_BC4_SNORM_BLOCK:
2692 case VK_FORMAT_BC5_UNORM_BLOCK:
2693 case VK_FORMAT_BC5_SNORM_BLOCK:
2694 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
2695 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
2696 case VK_FORMAT_BC7_UNORM_BLOCK:
2697 case VK_FORMAT_BC7_SRGB_BLOCK:
2698 return false;
2699
2700 default:
2701 return true;
2702 }
2703 }
2704
checkImageSupport(const InstanceInterface & vki,VkPhysicalDevice physicalDevice,const VkImageCreateInfo & imageCreateInfo)2705 void checkImageSupport(const InstanceInterface &vki, VkPhysicalDevice physicalDevice,
2706 const VkImageCreateInfo &imageCreateInfo)
2707 {
2708 VkImageFormatProperties imageFormatProperties;
2709
2710 if (vki.getPhysicalDeviceImageFormatProperties(physicalDevice, imageCreateInfo.format, imageCreateInfo.imageType,
2711 imageCreateInfo.tiling, imageCreateInfo.usage, imageCreateInfo.flags,
2712 &imageFormatProperties))
2713 {
2714 TCU_THROW(NotSupportedError, "Image format not supported.");
2715 }
2716 if (((VkSampleCountFlagBits)imageFormatProperties.sampleCounts & imageCreateInfo.samples) == 0)
2717 {
2718 TCU_THROW(NotSupportedError, "Sample count not supported.");
2719 }
2720 if (imageFormatProperties.maxArrayLayers < imageCreateInfo.arrayLayers)
2721 {
2722 TCU_THROW(NotSupportedError, "Layer count not supported.");
2723 }
2724 }
2725
mapTextureFormat(const tcu::TextureFormat & format)2726 VkFormat mapTextureFormat(const tcu::TextureFormat &format)
2727 {
2728 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST < (1 << 16));
2729 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELTYPE_LAST < (1 << 16));
2730
2731 #define PACK_FMT(ORDER, TYPE) ((int(ORDER) << 16) | int(TYPE))
2732 #define FMT_CASE(ORDER, TYPE) PACK_FMT(tcu::TextureFormat::ORDER, tcu::TextureFormat::TYPE)
2733
2734 // update this mapping if VkFormat changes
2735 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
2736
2737 switch (PACK_FMT(format.order, format.type))
2738 {
2739 case FMT_CASE(RG, UNORM_BYTE_44):
2740 return VK_FORMAT_R4G4_UNORM_PACK8;
2741 case FMT_CASE(RGB, UNORM_SHORT_565):
2742 return VK_FORMAT_R5G6B5_UNORM_PACK16;
2743 case FMT_CASE(RGBA, UNORM_SHORT_4444):
2744 return VK_FORMAT_R4G4B4A4_UNORM_PACK16;
2745 case FMT_CASE(RGBA, UNORM_SHORT_5551):
2746 return VK_FORMAT_R5G5B5A1_UNORM_PACK16;
2747 #ifndef CTS_USES_VULKANSC
2748 case FMT_CASE(ABGR, UNORM_SHORT_1555):
2749 return VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR;
2750 #endif // CTS_USES_VULKANSC
2751
2752 case FMT_CASE(BGR, UNORM_SHORT_565):
2753 return VK_FORMAT_B5G6R5_UNORM_PACK16;
2754 case FMT_CASE(BGRA, UNORM_SHORT_4444):
2755 return VK_FORMAT_B4G4R4A4_UNORM_PACK16;
2756 case FMT_CASE(BGRA, UNORM_SHORT_5551):
2757 return VK_FORMAT_B5G5R5A1_UNORM_PACK16;
2758
2759 case FMT_CASE(ARGB, UNORM_SHORT_1555):
2760 return VK_FORMAT_A1R5G5B5_UNORM_PACK16;
2761
2762 case FMT_CASE(R, UNORM_INT8):
2763 return VK_FORMAT_R8_UNORM;
2764 case FMT_CASE(R, SNORM_INT8):
2765 return VK_FORMAT_R8_SNORM;
2766 case FMT_CASE(R, UNSIGNED_INT8):
2767 return VK_FORMAT_R8_UINT;
2768 case FMT_CASE(R, SIGNED_INT8):
2769 return VK_FORMAT_R8_SINT;
2770 case FMT_CASE(sR, UNORM_INT8):
2771 return VK_FORMAT_R8_SRGB;
2772 #ifndef CTS_USES_VULKANSC
2773 case FMT_CASE(A, UNORM_INT8):
2774 return VK_FORMAT_A8_UNORM_KHR;
2775 #endif // CTS_USES_VULKANSC
2776
2777 case FMT_CASE(RG, UNORM_INT8):
2778 return VK_FORMAT_R8G8_UNORM;
2779 case FMT_CASE(RG, SNORM_INT8):
2780 return VK_FORMAT_R8G8_SNORM;
2781 case FMT_CASE(RG, UNSIGNED_INT8):
2782 return VK_FORMAT_R8G8_UINT;
2783 case FMT_CASE(RG, SIGNED_INT8):
2784 return VK_FORMAT_R8G8_SINT;
2785 case FMT_CASE(sRG, UNORM_INT8):
2786 return VK_FORMAT_R8G8_SRGB;
2787
2788 case FMT_CASE(RGB, UNORM_INT8):
2789 return VK_FORMAT_R8G8B8_UNORM;
2790 case FMT_CASE(RGB, SNORM_INT8):
2791 return VK_FORMAT_R8G8B8_SNORM;
2792 case FMT_CASE(RGB, UNSIGNED_INT8):
2793 return VK_FORMAT_R8G8B8_UINT;
2794 case FMT_CASE(RGB, SIGNED_INT8):
2795 return VK_FORMAT_R8G8B8_SINT;
2796 case FMT_CASE(sRGB, UNORM_INT8):
2797 return VK_FORMAT_R8G8B8_SRGB;
2798
2799 case FMT_CASE(RGBA, UNORM_INT8):
2800 return VK_FORMAT_R8G8B8A8_UNORM;
2801 case FMT_CASE(RGBA, SNORM_INT8):
2802 return VK_FORMAT_R8G8B8A8_SNORM;
2803 case FMT_CASE(RGBA, UNSIGNED_INT8):
2804 return VK_FORMAT_R8G8B8A8_UINT;
2805 case FMT_CASE(RGBA, SIGNED_INT8):
2806 return VK_FORMAT_R8G8B8A8_SINT;
2807 case FMT_CASE(sRGBA, UNORM_INT8):
2808 return VK_FORMAT_R8G8B8A8_SRGB;
2809
2810 case FMT_CASE(RGBA, UNORM_INT_1010102_REV):
2811 return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
2812 case FMT_CASE(RGBA, SNORM_INT_1010102_REV):
2813 return VK_FORMAT_A2B10G10R10_SNORM_PACK32;
2814 case FMT_CASE(RGBA, UNSIGNED_INT_1010102_REV):
2815 return VK_FORMAT_A2B10G10R10_UINT_PACK32;
2816 case FMT_CASE(RGBA, SIGNED_INT_1010102_REV):
2817 return VK_FORMAT_A2B10G10R10_SINT_PACK32;
2818
2819 case FMT_CASE(R, UNORM_INT16):
2820 return VK_FORMAT_R16_UNORM;
2821 case FMT_CASE(R, SNORM_INT16):
2822 return VK_FORMAT_R16_SNORM;
2823 case FMT_CASE(R, UNSIGNED_INT16):
2824 return VK_FORMAT_R16_UINT;
2825 case FMT_CASE(R, SIGNED_INT16):
2826 return VK_FORMAT_R16_SINT;
2827 case FMT_CASE(R, HALF_FLOAT):
2828 return VK_FORMAT_R16_SFLOAT;
2829
2830 case FMT_CASE(RG, UNORM_INT16):
2831 return VK_FORMAT_R16G16_UNORM;
2832 case FMT_CASE(RG, SNORM_INT16):
2833 return VK_FORMAT_R16G16_SNORM;
2834 case FMT_CASE(RG, UNSIGNED_INT16):
2835 return VK_FORMAT_R16G16_UINT;
2836 case FMT_CASE(RG, SIGNED_INT16):
2837 return VK_FORMAT_R16G16_SINT;
2838 case FMT_CASE(RG, HALF_FLOAT):
2839 return VK_FORMAT_R16G16_SFLOAT;
2840
2841 case FMT_CASE(RGB, UNORM_INT16):
2842 return VK_FORMAT_R16G16B16_UNORM;
2843 case FMT_CASE(RGB, SNORM_INT16):
2844 return VK_FORMAT_R16G16B16_SNORM;
2845 case FMT_CASE(RGB, UNSIGNED_INT16):
2846 return VK_FORMAT_R16G16B16_UINT;
2847 case FMT_CASE(RGB, SIGNED_INT16):
2848 return VK_FORMAT_R16G16B16_SINT;
2849 case FMT_CASE(RGB, HALF_FLOAT):
2850 return VK_FORMAT_R16G16B16_SFLOAT;
2851
2852 case FMT_CASE(RGBA, UNORM_INT16):
2853 return VK_FORMAT_R16G16B16A16_UNORM;
2854 case FMT_CASE(RGBA, SNORM_INT16):
2855 return VK_FORMAT_R16G16B16A16_SNORM;
2856 case FMT_CASE(RGBA, UNSIGNED_INT16):
2857 return VK_FORMAT_R16G16B16A16_UINT;
2858 case FMT_CASE(RGBA, SIGNED_INT16):
2859 return VK_FORMAT_R16G16B16A16_SINT;
2860 case FMT_CASE(RGBA, HALF_FLOAT):
2861 return VK_FORMAT_R16G16B16A16_SFLOAT;
2862
2863 case FMT_CASE(R, UNSIGNED_INT32):
2864 return VK_FORMAT_R32_UINT;
2865 case FMT_CASE(R, SIGNED_INT32):
2866 return VK_FORMAT_R32_SINT;
2867 case FMT_CASE(R, UNSIGNED_INT64):
2868 return VK_FORMAT_R64_UINT;
2869 case FMT_CASE(R, SIGNED_INT64):
2870 return VK_FORMAT_R64_SINT;
2871 case FMT_CASE(R, FLOAT):
2872 return VK_FORMAT_R32_SFLOAT;
2873
2874 case FMT_CASE(RG, UNSIGNED_INT32):
2875 return VK_FORMAT_R32G32_UINT;
2876 case FMT_CASE(RG, SIGNED_INT32):
2877 return VK_FORMAT_R32G32_SINT;
2878 case FMT_CASE(RG, FLOAT):
2879 return VK_FORMAT_R32G32_SFLOAT;
2880
2881 case FMT_CASE(RGB, UNSIGNED_INT32):
2882 return VK_FORMAT_R32G32B32_UINT;
2883 case FMT_CASE(RGB, SIGNED_INT32):
2884 return VK_FORMAT_R32G32B32_SINT;
2885 case FMT_CASE(RGB, FLOAT):
2886 return VK_FORMAT_R32G32B32_SFLOAT;
2887
2888 case FMT_CASE(RGBA, UNSIGNED_INT32):
2889 return VK_FORMAT_R32G32B32A32_UINT;
2890 case FMT_CASE(RGBA, SIGNED_INT32):
2891 return VK_FORMAT_R32G32B32A32_SINT;
2892 case FMT_CASE(RGBA, FLOAT):
2893 return VK_FORMAT_R32G32B32A32_SFLOAT;
2894
2895 case FMT_CASE(R, FLOAT64):
2896 return VK_FORMAT_R64_SFLOAT;
2897 case FMT_CASE(RG, FLOAT64):
2898 return VK_FORMAT_R64G64_SFLOAT;
2899 case FMT_CASE(RGB, FLOAT64):
2900 return VK_FORMAT_R64G64B64_SFLOAT;
2901 case FMT_CASE(RGBA, FLOAT64):
2902 return VK_FORMAT_R64G64B64A64_SFLOAT;
2903
2904 case FMT_CASE(RGB, UNSIGNED_INT_11F_11F_10F_REV):
2905 return VK_FORMAT_B10G11R11_UFLOAT_PACK32;
2906 case FMT_CASE(RGB, UNSIGNED_INT_999_E5_REV):
2907 return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
2908
2909 case FMT_CASE(BGR, UNORM_INT8):
2910 return VK_FORMAT_B8G8R8_UNORM;
2911 case FMT_CASE(BGR, SNORM_INT8):
2912 return VK_FORMAT_B8G8R8_SNORM;
2913 case FMT_CASE(BGR, UNSIGNED_INT8):
2914 return VK_FORMAT_B8G8R8_UINT;
2915 case FMT_CASE(BGR, SIGNED_INT8):
2916 return VK_FORMAT_B8G8R8_SINT;
2917 case FMT_CASE(BGR, USCALED_INT8):
2918 return VK_FORMAT_B8G8R8_USCALED;
2919 case FMT_CASE(BGR, SSCALED_INT8):
2920 return VK_FORMAT_B8G8R8_SSCALED;
2921 case FMT_CASE(sBGR, UNORM_INT8):
2922 return VK_FORMAT_B8G8R8_SRGB;
2923
2924 case FMT_CASE(BGRA, UNORM_INT8):
2925 return VK_FORMAT_B8G8R8A8_UNORM;
2926 case FMT_CASE(BGRA, SNORM_INT8):
2927 return VK_FORMAT_B8G8R8A8_SNORM;
2928 case FMT_CASE(BGRA, UNSIGNED_INT8):
2929 return VK_FORMAT_B8G8R8A8_UINT;
2930 case FMT_CASE(BGRA, SIGNED_INT8):
2931 return VK_FORMAT_B8G8R8A8_SINT;
2932 case FMT_CASE(BGRA, USCALED_INT8):
2933 return VK_FORMAT_B8G8R8A8_USCALED;
2934 case FMT_CASE(BGRA, SSCALED_INT8):
2935 return VK_FORMAT_B8G8R8A8_SSCALED;
2936 case FMT_CASE(sBGRA, UNORM_INT8):
2937 return VK_FORMAT_B8G8R8A8_SRGB;
2938
2939 case FMT_CASE(BGRA, UNORM_INT_1010102_REV):
2940 return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
2941 case FMT_CASE(BGRA, SNORM_INT_1010102_REV):
2942 return VK_FORMAT_A2R10G10B10_SNORM_PACK32;
2943 case FMT_CASE(BGRA, UNSIGNED_INT_1010102_REV):
2944 return VK_FORMAT_A2R10G10B10_UINT_PACK32;
2945 case FMT_CASE(BGRA, SIGNED_INT_1010102_REV):
2946 return VK_FORMAT_A2R10G10B10_SINT_PACK32;
2947
2948 case FMT_CASE(D, UNORM_INT16):
2949 return VK_FORMAT_D16_UNORM;
2950 case FMT_CASE(D, UNSIGNED_INT_24_8_REV):
2951 return VK_FORMAT_X8_D24_UNORM_PACK32;
2952 case FMT_CASE(D, FLOAT):
2953 return VK_FORMAT_D32_SFLOAT;
2954 case FMT_CASE(D, UNORM_INT24):
2955 return VK_FORMAT_D24_UNORM_S8_UINT;
2956
2957 case FMT_CASE(S, UNSIGNED_INT8):
2958 return VK_FORMAT_S8_UINT;
2959
2960 case FMT_CASE(DS, UNSIGNED_INT_16_8_8):
2961 return VK_FORMAT_D16_UNORM_S8_UINT;
2962 case FMT_CASE(DS, UNSIGNED_INT_24_8_REV):
2963 return VK_FORMAT_D24_UNORM_S8_UINT;
2964 case FMT_CASE(DS, FLOAT_UNSIGNED_INT_24_8_REV):
2965 return VK_FORMAT_D32_SFLOAT_S8_UINT;
2966
2967 case FMT_CASE(R, UNORM_SHORT_10):
2968 return VK_FORMAT_R10X6_UNORM_PACK16;
2969 case FMT_CASE(RG, UNORM_SHORT_10):
2970 return VK_FORMAT_R10X6G10X6_UNORM_2PACK16;
2971 case FMT_CASE(RGBA, UNORM_SHORT_10):
2972 return VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16;
2973
2974 case FMT_CASE(R, UNORM_SHORT_12):
2975 return VK_FORMAT_R12X4_UNORM_PACK16;
2976 case FMT_CASE(RG, UNORM_SHORT_12):
2977 return VK_FORMAT_R12X4G12X4_UNORM_2PACK16;
2978 case FMT_CASE(RGBA, UNORM_SHORT_12):
2979 return VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16;
2980
2981 case FMT_CASE(R, USCALED_INT8):
2982 return VK_FORMAT_R8_USCALED;
2983 case FMT_CASE(RG, USCALED_INT8):
2984 return VK_FORMAT_R8G8_USCALED;
2985 case FMT_CASE(RGB, USCALED_INT8):
2986 return VK_FORMAT_R8G8B8_USCALED;
2987 case FMT_CASE(RGBA, USCALED_INT8):
2988 return VK_FORMAT_R8G8B8A8_USCALED;
2989
2990 case FMT_CASE(R, USCALED_INT16):
2991 return VK_FORMAT_R16_USCALED;
2992 case FMT_CASE(RG, USCALED_INT16):
2993 return VK_FORMAT_R16G16_USCALED;
2994 case FMT_CASE(RGB, USCALED_INT16):
2995 return VK_FORMAT_R16G16B16_USCALED;
2996 case FMT_CASE(RGBA, USCALED_INT16):
2997 return VK_FORMAT_R16G16B16A16_USCALED;
2998
2999 case FMT_CASE(R, SSCALED_INT8):
3000 return VK_FORMAT_R8_SSCALED;
3001 case FMT_CASE(RG, SSCALED_INT8):
3002 return VK_FORMAT_R8G8_SSCALED;
3003 case FMT_CASE(RGB, SSCALED_INT8):
3004 return VK_FORMAT_R8G8B8_SSCALED;
3005 case FMT_CASE(RGBA, SSCALED_INT8):
3006 return VK_FORMAT_R8G8B8A8_SSCALED;
3007
3008 case FMT_CASE(R, SSCALED_INT16):
3009 return VK_FORMAT_R16_SSCALED;
3010 case FMT_CASE(RG, SSCALED_INT16):
3011 return VK_FORMAT_R16G16_SSCALED;
3012 case FMT_CASE(RGB, SSCALED_INT16):
3013 return VK_FORMAT_R16G16B16_SSCALED;
3014 case FMT_CASE(RGBA, SSCALED_INT16):
3015 return VK_FORMAT_R16G16B16A16_SSCALED;
3016
3017 case FMT_CASE(RGBA, USCALED_INT_1010102_REV):
3018 return VK_FORMAT_A2B10G10R10_USCALED_PACK32;
3019 case FMT_CASE(RGBA, SSCALED_INT_1010102_REV):
3020 return VK_FORMAT_A2B10G10R10_SSCALED_PACK32;
3021
3022 case FMT_CASE(BGRA, USCALED_INT_1010102_REV):
3023 return VK_FORMAT_A2R10G10B10_USCALED_PACK32;
3024 case FMT_CASE(BGRA, SSCALED_INT_1010102_REV):
3025 return VK_FORMAT_A2R10G10B10_SSCALED_PACK32;
3026
3027 case FMT_CASE(ARGB, UNORM_SHORT_4444):
3028 return VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT;
3029 case FMT_CASE(ABGR, UNORM_SHORT_4444):
3030 return VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT;
3031
3032 default:
3033 TCU_THROW(InternalError, "Unknown texture format");
3034 }
3035
3036 #undef PACK_FMT
3037 #undef FMT_CASE
3038 }
3039
mapCompressedTextureFormat(const tcu::CompressedTexFormat format)3040 VkFormat mapCompressedTextureFormat(const tcu::CompressedTexFormat format)
3041 {
3042 // update this mapping if CompressedTexFormat changes
3043 // 55 needed for Vulkan and 2 for AHB that won't have mapping here
3044 DE_STATIC_ASSERT(tcu::COMPRESSEDTEXFORMAT_LAST == 57);
3045
3046 switch (format)
3047 {
3048 case tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8:
3049 return VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
3050 case tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8:
3051 return VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK;
3052 case tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
3053 return VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK;
3054 case tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
3055 return VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK;
3056 case tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8:
3057 return VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
3058 case tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8:
3059 return VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK;
3060
3061 case tcu::COMPRESSEDTEXFORMAT_EAC_R11:
3062 return VK_FORMAT_EAC_R11_UNORM_BLOCK;
3063 case tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_R11:
3064 return VK_FORMAT_EAC_R11_SNORM_BLOCK;
3065 case tcu::COMPRESSEDTEXFORMAT_EAC_RG11:
3066 return VK_FORMAT_EAC_R11G11_UNORM_BLOCK;
3067 case tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11:
3068 return VK_FORMAT_EAC_R11G11_SNORM_BLOCK;
3069
3070 case tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_RGBA:
3071 return VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
3072 case tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_SRGB8_ALPHA8:
3073 return VK_FORMAT_ASTC_4x4_SRGB_BLOCK;
3074 case tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_RGBA:
3075 return VK_FORMAT_ASTC_5x4_UNORM_BLOCK;
3076 case tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_SRGB8_ALPHA8:
3077 return VK_FORMAT_ASTC_5x4_SRGB_BLOCK;
3078 case tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_RGBA:
3079 return VK_FORMAT_ASTC_5x5_UNORM_BLOCK;
3080 case tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8:
3081 return VK_FORMAT_ASTC_5x5_SRGB_BLOCK;
3082 case tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_RGBA:
3083 return VK_FORMAT_ASTC_6x5_UNORM_BLOCK;
3084 case tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_SRGB8_ALPHA8:
3085 return VK_FORMAT_ASTC_6x5_SRGB_BLOCK;
3086 case tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_RGBA:
3087 return VK_FORMAT_ASTC_6x6_UNORM_BLOCK;
3088 case tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_SRGB8_ALPHA8:
3089 return VK_FORMAT_ASTC_6x6_SRGB_BLOCK;
3090 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_RGBA:
3091 return VK_FORMAT_ASTC_8x5_UNORM_BLOCK;
3092 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_SRGB8_ALPHA8:
3093 return VK_FORMAT_ASTC_8x5_SRGB_BLOCK;
3094 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_RGBA:
3095 return VK_FORMAT_ASTC_8x6_UNORM_BLOCK;
3096 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8:
3097 return VK_FORMAT_ASTC_8x6_SRGB_BLOCK;
3098 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_RGBA:
3099 return VK_FORMAT_ASTC_8x8_UNORM_BLOCK;
3100 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_SRGB8_ALPHA8:
3101 return VK_FORMAT_ASTC_8x8_SRGB_BLOCK;
3102 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_RGBA:
3103 return VK_FORMAT_ASTC_10x5_UNORM_BLOCK;
3104 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_SRGB8_ALPHA8:
3105 return VK_FORMAT_ASTC_10x5_SRGB_BLOCK;
3106 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_RGBA:
3107 return VK_FORMAT_ASTC_10x6_UNORM_BLOCK;
3108 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_SRGB8_ALPHA8:
3109 return VK_FORMAT_ASTC_10x6_SRGB_BLOCK;
3110 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_RGBA:
3111 return VK_FORMAT_ASTC_10x8_UNORM_BLOCK;
3112 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_SRGB8_ALPHA8:
3113 return VK_FORMAT_ASTC_10x8_SRGB_BLOCK;
3114 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_RGBA:
3115 return VK_FORMAT_ASTC_10x10_UNORM_BLOCK;
3116 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_SRGB8_ALPHA8:
3117 return VK_FORMAT_ASTC_10x10_SRGB_BLOCK;
3118 case tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_RGBA:
3119 return VK_FORMAT_ASTC_12x10_UNORM_BLOCK;
3120 case tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_SRGB8_ALPHA8:
3121 return VK_FORMAT_ASTC_12x10_SRGB_BLOCK;
3122 case tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_RGBA:
3123 return VK_FORMAT_ASTC_12x12_UNORM_BLOCK;
3124 case tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_SRGB8_ALPHA8:
3125 return VK_FORMAT_ASTC_12x12_SRGB_BLOCK;
3126
3127 case tcu::COMPRESSEDTEXFORMAT_BC1_RGB_UNORM_BLOCK:
3128 return VK_FORMAT_BC1_RGB_UNORM_BLOCK;
3129 case tcu::COMPRESSEDTEXFORMAT_BC1_RGB_SRGB_BLOCK:
3130 return VK_FORMAT_BC1_RGB_SRGB_BLOCK;
3131 case tcu::COMPRESSEDTEXFORMAT_BC1_RGBA_UNORM_BLOCK:
3132 return VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
3133 case tcu::COMPRESSEDTEXFORMAT_BC1_RGBA_SRGB_BLOCK:
3134 return VK_FORMAT_BC1_RGBA_SRGB_BLOCK;
3135 case tcu::COMPRESSEDTEXFORMAT_BC2_UNORM_BLOCK:
3136 return VK_FORMAT_BC2_UNORM_BLOCK;
3137 case tcu::COMPRESSEDTEXFORMAT_BC2_SRGB_BLOCK:
3138 return VK_FORMAT_BC2_SRGB_BLOCK;
3139 case tcu::COMPRESSEDTEXFORMAT_BC3_UNORM_BLOCK:
3140 return VK_FORMAT_BC3_UNORM_BLOCK;
3141 case tcu::COMPRESSEDTEXFORMAT_BC3_SRGB_BLOCK:
3142 return VK_FORMAT_BC3_SRGB_BLOCK;
3143 case tcu::COMPRESSEDTEXFORMAT_BC4_UNORM_BLOCK:
3144 return VK_FORMAT_BC4_UNORM_BLOCK;
3145 case tcu::COMPRESSEDTEXFORMAT_BC4_SNORM_BLOCK:
3146 return VK_FORMAT_BC4_SNORM_BLOCK;
3147 case tcu::COMPRESSEDTEXFORMAT_BC5_UNORM_BLOCK:
3148 return VK_FORMAT_BC5_UNORM_BLOCK;
3149 case tcu::COMPRESSEDTEXFORMAT_BC5_SNORM_BLOCK:
3150 return VK_FORMAT_BC5_SNORM_BLOCK;
3151 case tcu::COMPRESSEDTEXFORMAT_BC6H_UFLOAT_BLOCK:
3152 return VK_FORMAT_BC6H_UFLOAT_BLOCK;
3153 case tcu::COMPRESSEDTEXFORMAT_BC6H_SFLOAT_BLOCK:
3154 return VK_FORMAT_BC6H_SFLOAT_BLOCK;
3155 case tcu::COMPRESSEDTEXFORMAT_BC7_UNORM_BLOCK:
3156 return VK_FORMAT_BC7_UNORM_BLOCK;
3157 case tcu::COMPRESSEDTEXFORMAT_BC7_SRGB_BLOCK:
3158 return VK_FORMAT_BC7_SRGB_BLOCK;
3159
3160 default:
3161 TCU_THROW(InternalError, "Unknown texture format");
3162 return VK_FORMAT_UNDEFINED;
3163 }
3164 }
3165
mapVkFormat(VkFormat format)3166 tcu::TextureFormat mapVkFormat(VkFormat format)
3167 {
3168 using tcu::TextureFormat;
3169
3170 // update this mapping if VkFormat changes
3171 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
3172
3173 switch (format)
3174 {
3175 case VK_FORMAT_R4G4_UNORM_PACK8:
3176 return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_BYTE_44);
3177 case VK_FORMAT_R5G6B5_UNORM_PACK16:
3178 return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_SHORT_565);
3179 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
3180 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_4444);
3181 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
3182 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_5551);
3183
3184 case VK_FORMAT_B5G6R5_UNORM_PACK16:
3185 return TextureFormat(TextureFormat::BGR, TextureFormat::UNORM_SHORT_565);
3186 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
3187 return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_SHORT_4444);
3188 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
3189 return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_SHORT_5551);
3190
3191 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
3192 return TextureFormat(TextureFormat::ARGB, TextureFormat::UNORM_SHORT_1555);
3193 #ifndef CTS_USES_VULKANSC
3194 case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR:
3195 return TextureFormat(TextureFormat::ABGR, TextureFormat::UNORM_SHORT_1555);
3196 #endif // CTS_USES_VULKANSC
3197
3198 case VK_FORMAT_R8_UNORM:
3199 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT8);
3200 case VK_FORMAT_R8_SNORM:
3201 return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT8);
3202 case VK_FORMAT_R8_USCALED:
3203 return TextureFormat(TextureFormat::R, TextureFormat::USCALED_INT8);
3204 case VK_FORMAT_R8_SSCALED:
3205 return TextureFormat(TextureFormat::R, TextureFormat::SSCALED_INT8);
3206 case VK_FORMAT_R8_UINT:
3207 return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT8);
3208 case VK_FORMAT_R8_SINT:
3209 return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT8);
3210 case VK_FORMAT_R8_SRGB:
3211 return TextureFormat(TextureFormat::sR, TextureFormat::UNORM_INT8);
3212 #ifndef CTS_USES_VULKANSC
3213 case VK_FORMAT_A8_UNORM_KHR:
3214 return TextureFormat(TextureFormat::A, TextureFormat::UNORM_INT8);
3215 #endif // CTS_USES_VULKANSC
3216
3217 case VK_FORMAT_R8G8_UNORM:
3218 return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT8);
3219 case VK_FORMAT_R8G8_SNORM:
3220 return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT8);
3221 case VK_FORMAT_R8G8_USCALED:
3222 return TextureFormat(TextureFormat::RG, TextureFormat::USCALED_INT8);
3223 case VK_FORMAT_R8G8_SSCALED:
3224 return TextureFormat(TextureFormat::RG, TextureFormat::SSCALED_INT8);
3225 case VK_FORMAT_R8G8_UINT:
3226 return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT8);
3227 case VK_FORMAT_R8G8_SINT:
3228 return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT8);
3229 case VK_FORMAT_R8G8_SRGB:
3230 return TextureFormat(TextureFormat::sRG, TextureFormat::UNORM_INT8);
3231
3232 case VK_FORMAT_R8G8B8_UNORM:
3233 return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8);
3234 case VK_FORMAT_R8G8B8_SNORM:
3235 return TextureFormat(TextureFormat::RGB, TextureFormat::SNORM_INT8);
3236 case VK_FORMAT_R8G8B8_USCALED:
3237 return TextureFormat(TextureFormat::RGB, TextureFormat::USCALED_INT8);
3238 case VK_FORMAT_R8G8B8_SSCALED:
3239 return TextureFormat(TextureFormat::RGB, TextureFormat::SSCALED_INT8);
3240 case VK_FORMAT_R8G8B8_UINT:
3241 return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT8);
3242 case VK_FORMAT_R8G8B8_SINT:
3243 return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT8);
3244 case VK_FORMAT_R8G8B8_SRGB:
3245 return TextureFormat(TextureFormat::sRGB, TextureFormat::UNORM_INT8);
3246
3247 case VK_FORMAT_R8G8B8A8_UNORM:
3248 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
3249 case VK_FORMAT_R8G8B8A8_SNORM:
3250 return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT8);
3251 case VK_FORMAT_R8G8B8A8_USCALED:
3252 return TextureFormat(TextureFormat::RGBA, TextureFormat::USCALED_INT8);
3253 case VK_FORMAT_R8G8B8A8_SSCALED:
3254 return TextureFormat(TextureFormat::RGBA, TextureFormat::SSCALED_INT8);
3255 case VK_FORMAT_R8G8B8A8_UINT:
3256 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8);
3257 case VK_FORMAT_R8G8B8A8_SINT:
3258 return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8);
3259 case VK_FORMAT_R8G8B8A8_SRGB:
3260 return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8);
3261
3262 case VK_FORMAT_R16_UNORM:
3263 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT16);
3264 case VK_FORMAT_R16_SNORM:
3265 return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT16);
3266 case VK_FORMAT_R16_USCALED:
3267 return TextureFormat(TextureFormat::R, TextureFormat::USCALED_INT16);
3268 case VK_FORMAT_R16_SSCALED:
3269 return TextureFormat(TextureFormat::R, TextureFormat::SSCALED_INT16);
3270 case VK_FORMAT_R16_UINT:
3271 return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT16);
3272 case VK_FORMAT_R16_SINT:
3273 return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT16);
3274 case VK_FORMAT_R16_SFLOAT:
3275 return TextureFormat(TextureFormat::R, TextureFormat::HALF_FLOAT);
3276
3277 case VK_FORMAT_R16G16_UNORM:
3278 return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT16);
3279 case VK_FORMAT_R16G16_SNORM:
3280 return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT16);
3281 case VK_FORMAT_R16G16_USCALED:
3282 return TextureFormat(TextureFormat::RG, TextureFormat::USCALED_INT16);
3283 case VK_FORMAT_R16G16_SSCALED:
3284 return TextureFormat(TextureFormat::RG, TextureFormat::SSCALED_INT16);
3285 case VK_FORMAT_R16G16_UINT:
3286 return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT16);
3287 case VK_FORMAT_R16G16_SINT:
3288 return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT16);
3289 case VK_FORMAT_R16G16_SFLOAT:
3290 return TextureFormat(TextureFormat::RG, TextureFormat::HALF_FLOAT);
3291
3292 case VK_FORMAT_R16G16B16_UNORM:
3293 return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT16);
3294 case VK_FORMAT_R16G16B16_SNORM:
3295 return TextureFormat(TextureFormat::RGB, TextureFormat::SNORM_INT16);
3296 case VK_FORMAT_R16G16B16_USCALED:
3297 return TextureFormat(TextureFormat::RGB, TextureFormat::USCALED_INT16);
3298 case VK_FORMAT_R16G16B16_SSCALED:
3299 return TextureFormat(TextureFormat::RGB, TextureFormat::SSCALED_INT16);
3300 case VK_FORMAT_R16G16B16_UINT:
3301 return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT16);
3302 case VK_FORMAT_R16G16B16_SINT:
3303 return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT16);
3304 case VK_FORMAT_R16G16B16_SFLOAT:
3305 return TextureFormat(TextureFormat::RGB, TextureFormat::HALF_FLOAT);
3306
3307 case VK_FORMAT_R16G16B16A16_UNORM:
3308 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT16);
3309 case VK_FORMAT_R16G16B16A16_SNORM:
3310 return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT16);
3311 case VK_FORMAT_R16G16B16A16_USCALED:
3312 return TextureFormat(TextureFormat::RGBA, TextureFormat::USCALED_INT16);
3313 case VK_FORMAT_R16G16B16A16_SSCALED:
3314 return TextureFormat(TextureFormat::RGBA, TextureFormat::SSCALED_INT16);
3315 case VK_FORMAT_R16G16B16A16_UINT:
3316 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT16);
3317 case VK_FORMAT_R16G16B16A16_SINT:
3318 return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT16);
3319 case VK_FORMAT_R16G16B16A16_SFLOAT:
3320 return TextureFormat(TextureFormat::RGBA, TextureFormat::HALF_FLOAT);
3321
3322 case VK_FORMAT_R32_UINT:
3323 return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT32);
3324 case VK_FORMAT_R32_SINT:
3325 return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT32);
3326 case VK_FORMAT_R32_SFLOAT:
3327 return TextureFormat(TextureFormat::R, TextureFormat::FLOAT);
3328
3329 case VK_FORMAT_R32G32_UINT:
3330 return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT32);
3331 case VK_FORMAT_R32G32_SINT:
3332 return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT32);
3333 case VK_FORMAT_R32G32_SFLOAT:
3334 return TextureFormat(TextureFormat::RG, TextureFormat::FLOAT);
3335
3336 case VK_FORMAT_R32G32B32_UINT:
3337 return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT32);
3338 case VK_FORMAT_R32G32B32_SINT:
3339 return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT32);
3340 case VK_FORMAT_R32G32B32_SFLOAT:
3341 return TextureFormat(TextureFormat::RGB, TextureFormat::FLOAT);
3342
3343 case VK_FORMAT_R32G32B32A32_UINT:
3344 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32);
3345 case VK_FORMAT_R32G32B32A32_SINT:
3346 return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT32);
3347 case VK_FORMAT_R32G32B32A32_SFLOAT:
3348 return TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT);
3349
3350 case VK_FORMAT_R64_UINT:
3351 return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT64);
3352 case VK_FORMAT_R64G64_UINT:
3353 return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT64);
3354 case VK_FORMAT_R64G64B64_UINT:
3355 return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT64);
3356 case VK_FORMAT_R64G64B64A64_UINT:
3357 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT64);
3358 case VK_FORMAT_R64_SINT:
3359 return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT64);
3360 case VK_FORMAT_R64G64_SINT:
3361 return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT64);
3362 case VK_FORMAT_R64G64B64_SINT:
3363 return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT64);
3364 case VK_FORMAT_R64G64B64A64_SINT:
3365 return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT64);
3366 case VK_FORMAT_R64_SFLOAT:
3367 return TextureFormat(TextureFormat::R, TextureFormat::FLOAT64);
3368 case VK_FORMAT_R64G64_SFLOAT:
3369 return TextureFormat(TextureFormat::RG, TextureFormat::FLOAT64);
3370 case VK_FORMAT_R64G64B64_SFLOAT:
3371 return TextureFormat(TextureFormat::RGB, TextureFormat::FLOAT64);
3372 case VK_FORMAT_R64G64B64A64_SFLOAT:
3373 return TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT64);
3374
3375 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
3376 return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT_11F_11F_10F_REV);
3377 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
3378 return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT_999_E5_REV);
3379
3380 case VK_FORMAT_B8G8R8_UNORM:
3381 return TextureFormat(TextureFormat::BGR, TextureFormat::UNORM_INT8);
3382 case VK_FORMAT_B8G8R8_SNORM:
3383 return TextureFormat(TextureFormat::BGR, TextureFormat::SNORM_INT8);
3384 case VK_FORMAT_B8G8R8_USCALED:
3385 return TextureFormat(TextureFormat::BGR, TextureFormat::USCALED_INT8);
3386 case VK_FORMAT_B8G8R8_SSCALED:
3387 return TextureFormat(TextureFormat::BGR, TextureFormat::SSCALED_INT8);
3388 case VK_FORMAT_B8G8R8_UINT:
3389 return TextureFormat(TextureFormat::BGR, TextureFormat::UNSIGNED_INT8);
3390 case VK_FORMAT_B8G8R8_SINT:
3391 return TextureFormat(TextureFormat::BGR, TextureFormat::SIGNED_INT8);
3392 case VK_FORMAT_B8G8R8_SRGB:
3393 return TextureFormat(TextureFormat::sBGR, TextureFormat::UNORM_INT8);
3394
3395 case VK_FORMAT_B8G8R8A8_UNORM:
3396 return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_INT8);
3397 case VK_FORMAT_B8G8R8A8_SNORM:
3398 return TextureFormat(TextureFormat::BGRA, TextureFormat::SNORM_INT8);
3399 case VK_FORMAT_B8G8R8A8_USCALED:
3400 return TextureFormat(TextureFormat::BGRA, TextureFormat::USCALED_INT8);
3401 case VK_FORMAT_B8G8R8A8_SSCALED:
3402 return TextureFormat(TextureFormat::BGRA, TextureFormat::SSCALED_INT8);
3403 case VK_FORMAT_B8G8R8A8_UINT:
3404 return TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT8);
3405 case VK_FORMAT_B8G8R8A8_SINT:
3406 return TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT8);
3407 case VK_FORMAT_B8G8R8A8_SRGB:
3408 return TextureFormat(TextureFormat::sBGRA, TextureFormat::UNORM_INT8);
3409
3410 case VK_FORMAT_D16_UNORM:
3411 return TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT16);
3412 case VK_FORMAT_X8_D24_UNORM_PACK32:
3413 return TextureFormat(TextureFormat::D, TextureFormat::UNSIGNED_INT_24_8_REV);
3414 case VK_FORMAT_D32_SFLOAT:
3415 return TextureFormat(TextureFormat::D, TextureFormat::FLOAT);
3416
3417 case VK_FORMAT_S8_UINT:
3418 return TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8);
3419
3420 // \note There is no standard interleaved memory layout for DS formats; buffer-image copies
3421 // will always operate on either D or S aspect only. See Khronos bug 12998
3422 case VK_FORMAT_D16_UNORM_S8_UINT:
3423 return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_16_8_8);
3424 case VK_FORMAT_D24_UNORM_S8_UINT:
3425 return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_24_8_REV);
3426 case VK_FORMAT_D32_SFLOAT_S8_UINT:
3427 return TextureFormat(TextureFormat::DS, TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV);
3428
3429 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN)
3430 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
3431 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
3432 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
3433 return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT8);
3434 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
3435 return TextureFormat(TextureFormat::RGBA, TextureFormat::USCALED_INT8);
3436 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
3437 return TextureFormat(TextureFormat::RGBA, TextureFormat::SSCALED_INT8);
3438 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
3439 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8);
3440 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
3441 return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8);
3442 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
3443 return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8);
3444 #else
3445 #error "Big-endian not supported"
3446 #endif
3447
3448 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
3449 return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_INT_1010102_REV);
3450 case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
3451 return TextureFormat(TextureFormat::BGRA, TextureFormat::SNORM_INT_1010102_REV);
3452 case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
3453 return TextureFormat(TextureFormat::BGRA, TextureFormat::USCALED_INT_1010102_REV);
3454 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
3455 return TextureFormat(TextureFormat::BGRA, TextureFormat::SSCALED_INT_1010102_REV);
3456 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
3457 return TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT_1010102_REV);
3458 case VK_FORMAT_A2R10G10B10_SINT_PACK32:
3459 return TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT_1010102_REV);
3460
3461 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
3462 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT_1010102_REV);
3463 case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
3464 return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT_1010102_REV);
3465 case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
3466 return TextureFormat(TextureFormat::RGBA, TextureFormat::USCALED_INT_1010102_REV);
3467 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
3468 return TextureFormat(TextureFormat::RGBA, TextureFormat::SSCALED_INT_1010102_REV);
3469 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
3470 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT_1010102_REV);
3471 case VK_FORMAT_A2B10G10R10_SINT_PACK32:
3472 return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT_1010102_REV);
3473
3474 // YCbCr formats that can be mapped
3475 case VK_FORMAT_R10X6_UNORM_PACK16:
3476 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_10);
3477 case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
3478 return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_SHORT_10);
3479 case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
3480 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_10);
3481
3482 case VK_FORMAT_R12X4_UNORM_PACK16:
3483 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_12);
3484 case VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
3485 return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_SHORT_12);
3486 case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
3487 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_12);
3488
3489 case VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT:
3490 return TextureFormat(TextureFormat::ARGB, TextureFormat::UNORM_SHORT_4444);
3491 case VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT:
3492 return TextureFormat(TextureFormat::ABGR, TextureFormat::UNORM_SHORT_4444);
3493
3494 default:
3495 TCU_THROW(InternalError, "Unknown image format");
3496 }
3497 }
3498
mapVkCompressedFormat(VkFormat format)3499 tcu::CompressedTexFormat mapVkCompressedFormat(VkFormat format)
3500 {
3501 // update this mapping if VkFormat changes
3502 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
3503
3504 switch (format)
3505 {
3506 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
3507 return tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8;
3508 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
3509 return tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8;
3510 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
3511 return tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1;
3512 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
3513 return tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1;
3514 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
3515 return tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8;
3516 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
3517 return tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8;
3518
3519 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
3520 return tcu::COMPRESSEDTEXFORMAT_EAC_R11;
3521 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
3522 return tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_R11;
3523 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
3524 return tcu::COMPRESSEDTEXFORMAT_EAC_RG11;
3525 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
3526 return tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11;
3527
3528 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
3529 return tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_RGBA;
3530 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
3531 return tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_SRGB8_ALPHA8;
3532 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
3533 return tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_RGBA;
3534 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
3535 return tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_SRGB8_ALPHA8;
3536 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
3537 return tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_RGBA;
3538 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
3539 return tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8;
3540 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
3541 return tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_RGBA;
3542 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
3543 return tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_SRGB8_ALPHA8;
3544 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
3545 return tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_RGBA;
3546 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
3547 return tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_SRGB8_ALPHA8;
3548 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
3549 return tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_RGBA;
3550 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
3551 return tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_SRGB8_ALPHA8;
3552 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
3553 return tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_RGBA;
3554 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
3555 return tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8;
3556 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
3557 return tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_RGBA;
3558 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
3559 return tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_SRGB8_ALPHA8;
3560 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
3561 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_RGBA;
3562 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
3563 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_SRGB8_ALPHA8;
3564 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
3565 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_RGBA;
3566 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
3567 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_SRGB8_ALPHA8;
3568 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
3569 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_RGBA;
3570 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
3571 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_SRGB8_ALPHA8;
3572 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
3573 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_RGBA;
3574 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
3575 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_SRGB8_ALPHA8;
3576 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
3577 return tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_RGBA;
3578 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
3579 return tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_SRGB8_ALPHA8;
3580 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
3581 return tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_RGBA;
3582 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
3583 return tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_SRGB8_ALPHA8;
3584
3585 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
3586 return tcu::COMPRESSEDTEXFORMAT_BC1_RGB_UNORM_BLOCK;
3587 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
3588 return tcu::COMPRESSEDTEXFORMAT_BC1_RGB_SRGB_BLOCK;
3589 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
3590 return tcu::COMPRESSEDTEXFORMAT_BC1_RGBA_UNORM_BLOCK;
3591 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
3592 return tcu::COMPRESSEDTEXFORMAT_BC1_RGBA_SRGB_BLOCK;
3593 case VK_FORMAT_BC2_UNORM_BLOCK:
3594 return tcu::COMPRESSEDTEXFORMAT_BC2_UNORM_BLOCK;
3595 case VK_FORMAT_BC2_SRGB_BLOCK:
3596 return tcu::COMPRESSEDTEXFORMAT_BC2_SRGB_BLOCK;
3597 case VK_FORMAT_BC3_UNORM_BLOCK:
3598 return tcu::COMPRESSEDTEXFORMAT_BC3_UNORM_BLOCK;
3599 case VK_FORMAT_BC3_SRGB_BLOCK:
3600 return tcu::COMPRESSEDTEXFORMAT_BC3_SRGB_BLOCK;
3601 case VK_FORMAT_BC4_UNORM_BLOCK:
3602 return tcu::COMPRESSEDTEXFORMAT_BC4_UNORM_BLOCK;
3603 case VK_FORMAT_BC4_SNORM_BLOCK:
3604 return tcu::COMPRESSEDTEXFORMAT_BC4_SNORM_BLOCK;
3605 case VK_FORMAT_BC5_UNORM_BLOCK:
3606 return tcu::COMPRESSEDTEXFORMAT_BC5_UNORM_BLOCK;
3607 case VK_FORMAT_BC5_SNORM_BLOCK:
3608 return tcu::COMPRESSEDTEXFORMAT_BC5_SNORM_BLOCK;
3609 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
3610 return tcu::COMPRESSEDTEXFORMAT_BC6H_UFLOAT_BLOCK;
3611 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
3612 return tcu::COMPRESSEDTEXFORMAT_BC6H_SFLOAT_BLOCK;
3613 case VK_FORMAT_BC7_UNORM_BLOCK:
3614 return tcu::COMPRESSEDTEXFORMAT_BC7_UNORM_BLOCK;
3615 case VK_FORMAT_BC7_SRGB_BLOCK:
3616 return tcu::COMPRESSEDTEXFORMAT_BC7_SRGB_BLOCK;
3617
3618 default:
3619 TCU_THROW(InternalError, "Unknown image format");
3620 return tcu::COMPRESSEDTEXFORMAT_LAST;
3621 }
3622 }
3623
fullTextureFormatRoundTripSupported(VkFormat format)3624 static bool fullTextureFormatRoundTripSupported(VkFormat format)
3625 {
3626 if (isScaledFormat(format))
3627 {
3628 // *SCALED formats get mapped to correspoding (u)int formats since
3629 // accessing them through (float) getPixel/setPixel has same behavior
3630 // as in shader access in Vulkan.
3631 // Unfortunately full round-trip between tcu::TextureFormat and VkFormat
3632 // for most SCALED formats is not supported though.
3633
3634 const tcu::TextureFormat tcuFormat = mapVkFormat(format);
3635
3636 switch (tcuFormat.type)
3637 {
3638 case tcu::TextureFormat::UNSIGNED_INT8:
3639 case tcu::TextureFormat::UNSIGNED_INT16:
3640 case tcu::TextureFormat::UNSIGNED_INT32:
3641 case tcu::TextureFormat::SIGNED_INT8:
3642 case tcu::TextureFormat::SIGNED_INT16:
3643 case tcu::TextureFormat::SIGNED_INT32:
3644 case tcu::TextureFormat::UNSIGNED_INT_1010102_REV:
3645 case tcu::TextureFormat::SIGNED_INT_1010102_REV:
3646 return false;
3647
3648 default:
3649 return true;
3650 }
3651 }
3652 else
3653 {
3654 switch (format)
3655 {
3656 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
3657 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
3658 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
3659 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
3660 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
3661 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
3662 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
3663 return false; // These map to regular byte array formats
3664
3665 default:
3666 break;
3667 }
3668
3669 return (format != VK_FORMAT_UNDEFINED);
3670 }
3671 }
3672
getChannelAccessFormat(tcu::TextureChannelClass type,uint32_t offsetBits,uint32_t sizeBits)3673 tcu::TextureFormat getChannelAccessFormat(tcu::TextureChannelClass type, uint32_t offsetBits, uint32_t sizeBits)
3674 {
3675 using tcu::TextureFormat;
3676
3677 if (offsetBits == 0)
3678 {
3679 static const TextureFormat::ChannelType s_size8[tcu::TEXTURECHANNELCLASS_LAST] = {
3680 TextureFormat::SNORM_INT8, // snorm
3681 TextureFormat::UNORM_INT8, // unorm
3682 TextureFormat::SIGNED_INT8, // sint
3683 TextureFormat::UNSIGNED_INT8, // uint
3684 TextureFormat::CHANNELTYPE_LAST, // float
3685 };
3686 static const TextureFormat::ChannelType s_size16[tcu::TEXTURECHANNELCLASS_LAST] = {
3687 TextureFormat::SNORM_INT16, // snorm
3688 TextureFormat::UNORM_INT16, // unorm
3689 TextureFormat::SIGNED_INT16, // sint
3690 TextureFormat::UNSIGNED_INT16, // uint
3691 TextureFormat::HALF_FLOAT, // float
3692 };
3693 static const TextureFormat::ChannelType s_size32[tcu::TEXTURECHANNELCLASS_LAST] = {
3694 TextureFormat::SNORM_INT32, // snorm
3695 TextureFormat::UNORM_INT32, // unorm
3696 TextureFormat::SIGNED_INT32, // sint
3697 TextureFormat::UNSIGNED_INT32, // uint
3698 TextureFormat::FLOAT, // float
3699 };
3700
3701 static const TextureFormat::ChannelType s_size64[tcu::TEXTURECHANNELCLASS_LAST] = {
3702 TextureFormat::CHANNELTYPE_LAST, // snorm
3703 TextureFormat::CHANNELTYPE_LAST, // unorm
3704 TextureFormat::SIGNED_INT64, // sint
3705 TextureFormat::UNSIGNED_INT64, // uint
3706 TextureFormat::FLOAT64, // float
3707 };
3708
3709 TextureFormat::ChannelType chnType = TextureFormat::CHANNELTYPE_LAST;
3710
3711 if (sizeBits == 8)
3712 chnType = s_size8[type];
3713 else if (sizeBits == 16)
3714 chnType = s_size16[type];
3715 else if (sizeBits == 32)
3716 chnType = s_size32[type];
3717 else if (sizeBits == 64)
3718 chnType = s_size64[type];
3719
3720 if (chnType != TextureFormat::CHANNELTYPE_LAST)
3721 return TextureFormat(TextureFormat::R, chnType);
3722 }
3723 else
3724 {
3725 if (type == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT && offsetBits == 6 && sizeBits == 10)
3726 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_10);
3727 else if (type == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT && offsetBits == 4 && sizeBits == 12)
3728 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_12);
3729 }
3730
3731 TCU_THROW(InternalError, "Channel access format is not supported");
3732 }
3733
getChannelAccess(const PlanarFormatDescription & formatInfo,const tcu::UVec2 & size,const uint32_t * planeRowPitches,void * const * planePtrs,uint32_t channelNdx)3734 tcu::PixelBufferAccess getChannelAccess(const PlanarFormatDescription &formatInfo, const tcu::UVec2 &size,
3735 const uint32_t *planeRowPitches, void *const *planePtrs, uint32_t channelNdx)
3736 {
3737 DE_ASSERT(formatInfo.hasChannelNdx(channelNdx));
3738
3739 const uint32_t planeNdx = formatInfo.channels[channelNdx].planeNdx;
3740 const uint32_t planeOffsetBytes = formatInfo.channels[channelNdx].offsetBits / 8;
3741 const uint32_t valueOffsetBits = formatInfo.channels[channelNdx].offsetBits % 8;
3742 const uint32_t pixelStrideBytes = formatInfo.channels[channelNdx].strideBytes;
3743
3744 DE_ASSERT(size.x() % (formatInfo.blockWidth * formatInfo.planes[planeNdx].widthDivisor) == 0);
3745 DE_ASSERT(size.y() % (formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor) == 0);
3746
3747 const uint32_t accessHeight = size.y() / (formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor);
3748 const uint32_t elementSizeBytes = formatInfo.planes[planeNdx].elementSizeBytes;
3749 const uint32_t rowPitch = planeRowPitches[planeNdx];
3750
3751 DE_ASSERT(elementSizeBytes % pixelStrideBytes == 0);
3752
3753 tcu::IVec3 texDivider(
3754 std::max(formatInfo.blockWidth * formatInfo.planes[planeNdx].widthDivisor * pixelStrideBytes / elementSizeBytes,
3755 1u),
3756 std::max(formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor * pixelStrideBytes /
3757 elementSizeBytes,
3758 1u),
3759 1);
3760
3761 return tcu::PixelBufferAccess(getChannelAccessFormat((tcu::TextureChannelClass)formatInfo.channels[channelNdx].type,
3762 valueOffsetBits, formatInfo.channels[channelNdx].sizeBits),
3763 tcu::IVec3((int)size.x(), (int)size.y(), 1),
3764 tcu::IVec3((int)pixelStrideBytes, (int)rowPitch, (int)(accessHeight * rowPitch)),
3765 texDivider, (uint8_t *)planePtrs[planeNdx] + planeOffsetBytes);
3766 }
3767
getChannelAccess(const PlanarFormatDescription & formatInfo,const tcu::UVec2 & size,const uint32_t * planeRowPitches,const void * const * planePtrs,uint32_t channelNdx)3768 tcu::ConstPixelBufferAccess getChannelAccess(const PlanarFormatDescription &formatInfo, const tcu::UVec2 &size,
3769 const uint32_t *planeRowPitches, const void *const *planePtrs,
3770 uint32_t channelNdx)
3771 {
3772 return getChannelAccess(formatInfo, size, planeRowPitches, const_cast<void *const *>(planePtrs), channelNdx);
3773 }
3774
getChannelAccess(const PlanarFormatDescription & formatInfo,const tcu::UVec3 & size,const uint32_t * planeRowPitches,void * const * planePtrs,uint32_t channelNdx)3775 tcu::PixelBufferAccess getChannelAccess(const PlanarFormatDescription &formatInfo, const tcu::UVec3 &size,
3776 const uint32_t *planeRowPitches, void *const *planePtrs, uint32_t channelNdx)
3777 {
3778 DE_ASSERT(formatInfo.hasChannelNdx(channelNdx));
3779
3780 const uint32_t planeNdx = formatInfo.channels[channelNdx].planeNdx;
3781 const uint32_t planeOffsetBytes = formatInfo.channels[channelNdx].offsetBits / 8;
3782 const uint32_t valueOffsetBits = formatInfo.channels[channelNdx].offsetBits % 8;
3783 const uint32_t pixelStrideBytes = formatInfo.channels[channelNdx].strideBytes;
3784
3785 DE_ASSERT(size.x() % (formatInfo.blockWidth * formatInfo.planes[planeNdx].widthDivisor) == 0);
3786 DE_ASSERT(size.y() % (formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor) == 0);
3787
3788 const uint32_t accessHeight = size.y() / (formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor);
3789 const uint32_t elementSizeBytes = formatInfo.planes[planeNdx].elementSizeBytes;
3790 const uint32_t rowPitch = planeRowPitches[planeNdx];
3791
3792 DE_ASSERT(elementSizeBytes % pixelStrideBytes == 0);
3793
3794 tcu::IVec3 texDivider(
3795 std::max(formatInfo.blockWidth * formatInfo.planes[planeNdx].widthDivisor * pixelStrideBytes / elementSizeBytes,
3796 1u),
3797 std::max(formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor * pixelStrideBytes /
3798 elementSizeBytes,
3799 1u),
3800 1);
3801
3802 return tcu::PixelBufferAccess(getChannelAccessFormat((tcu::TextureChannelClass)formatInfo.channels[channelNdx].type,
3803 valueOffsetBits, formatInfo.channels[channelNdx].sizeBits),
3804 tcu::IVec3((int)size.x(), (int)size.y(), (int)size.z()),
3805 tcu::IVec3((int)pixelStrideBytes, (int)rowPitch, (int)(accessHeight * rowPitch)),
3806 texDivider, (uint8_t *)planePtrs[planeNdx] + planeOffsetBytes);
3807 }
3808
getChannelAccess(const PlanarFormatDescription & formatInfo,const tcu::UVec3 & size,const uint32_t * planeRowPitches,const void * const * planePtrs,uint32_t channelNdx)3809 tcu::ConstPixelBufferAccess getChannelAccess(const PlanarFormatDescription &formatInfo, const tcu::UVec3 &size,
3810 const uint32_t *planeRowPitches, const void *const *planePtrs,
3811 uint32_t channelNdx)
3812 {
3813 return getChannelAccess(formatInfo, size, planeRowPitches, const_cast<void *const *>(planePtrs), channelNdx);
3814 }
3815
imageUtilSelfTest(void)3816 void imageUtilSelfTest(void)
3817 {
3818 for (int formatNdx = 0; formatNdx < VK_CORE_FORMAT_LAST; formatNdx++)
3819 {
3820 const VkFormat format = (VkFormat)formatNdx;
3821
3822 if (format == VK_FORMAT_R64_UINT || format == VK_FORMAT_R64_SINT || format == VK_FORMAT_R64G64_UINT ||
3823 format == VK_FORMAT_R64G64_SINT || format == VK_FORMAT_R64G64B64_UINT ||
3824 format == VK_FORMAT_R64G64B64_SINT || format == VK_FORMAT_R64G64B64A64_UINT ||
3825 format == VK_FORMAT_R64G64B64A64_SINT)
3826 continue; // \todo [2015-12-05 pyry] Add framework support for (u)int64 channel type
3827
3828 if (format != VK_FORMAT_UNDEFINED && !isCompressedFormat(format))
3829 {
3830 const tcu::TextureFormat tcuFormat = mapVkFormat(format);
3831 const VkFormat remappedFormat = mapTextureFormat(tcuFormat);
3832
3833 DE_TEST_ASSERT(isValid(tcuFormat));
3834
3835 if (fullTextureFormatRoundTripSupported(format))
3836 DE_TEST_ASSERT(format == remappedFormat);
3837 }
3838 }
3839
3840 for (int formatNdx = VK_FORMAT_G8B8G8R8_422_UNORM; formatNdx <= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM; formatNdx++)
3841 {
3842 const VkFormat format = (VkFormat)formatNdx;
3843 const PlanarFormatDescription &info = getPlanarFormatDescription(format);
3844
3845 DE_TEST_ASSERT(isYCbCrFormat(format));
3846 DE_TEST_ASSERT(de::inRange<uint8_t>(info.numPlanes, 1u, 3u));
3847 DE_TEST_ASSERT(info.numPlanes == getPlaneCount(format));
3848 }
3849
3850 for (int formatNdx = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT; formatNdx <= VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT;
3851 formatNdx++)
3852 {
3853 const VkFormat format = (VkFormat)formatNdx;
3854 const PlanarFormatDescription &info = getPlanarFormatDescription(format);
3855
3856 DE_TEST_ASSERT(isYCbCrFormat(format));
3857 DE_TEST_ASSERT(de::inRange<uint8_t>(info.numPlanes, 1u, 3u));
3858 DE_TEST_ASSERT(info.numPlanes == getPlaneCount(format));
3859 }
3860 }
3861
3862 struct CompressedFormatParameters
3863 {
3864 VkFormat format;
3865 uint32_t blockBytes;
3866 uint32_t blockWidth;
3867 uint32_t blockHeight;
3868 };
3869
3870 CompressedFormatParameters compressedFormatParameters[VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_BC1_RGB_UNORM_BLOCK +
3871 1] = {{VK_FORMAT_BC1_RGB_UNORM_BLOCK, 8, 4, 4},
3872 {VK_FORMAT_BC1_RGB_SRGB_BLOCK, 8, 4, 4},
3873 {VK_FORMAT_BC1_RGBA_UNORM_BLOCK, 8, 4, 4},
3874 {VK_FORMAT_BC1_RGBA_SRGB_BLOCK, 8, 4, 4},
3875 {VK_FORMAT_BC2_UNORM_BLOCK, 16, 4, 4},
3876 {VK_FORMAT_BC2_SRGB_BLOCK, 16, 4, 4},
3877 {VK_FORMAT_BC3_UNORM_BLOCK, 16, 4, 4},
3878 {VK_FORMAT_BC3_SRGB_BLOCK, 16, 4, 4},
3879 {VK_FORMAT_BC4_UNORM_BLOCK, 8, 4, 4},
3880 {VK_FORMAT_BC4_SNORM_BLOCK, 8, 4, 4},
3881 {VK_FORMAT_BC5_UNORM_BLOCK, 16, 4, 4},
3882 {VK_FORMAT_BC5_SNORM_BLOCK, 16, 4, 4},
3883 {VK_FORMAT_BC6H_UFLOAT_BLOCK, 16, 4, 4},
3884 {VK_FORMAT_BC6H_SFLOAT_BLOCK, 16, 4, 4},
3885 {VK_FORMAT_BC7_UNORM_BLOCK, 16, 4, 4},
3886 {VK_FORMAT_BC7_SRGB_BLOCK, 16, 4, 4},
3887 {VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, 8, 4, 4},
3888 {VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, 8, 4, 4},
3889 {VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, 8, 4, 4},
3890 {VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, 8, 4, 4},
3891 {VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, 16, 4, 4},
3892 {VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, 16, 4, 4},
3893 {VK_FORMAT_EAC_R11_UNORM_BLOCK, 8, 4, 4},
3894 {VK_FORMAT_EAC_R11_SNORM_BLOCK, 8, 4, 4},
3895 {VK_FORMAT_EAC_R11G11_UNORM_BLOCK, 16, 4, 4},
3896 {VK_FORMAT_EAC_R11G11_SNORM_BLOCK, 16, 4, 4},
3897 {VK_FORMAT_ASTC_4x4_UNORM_BLOCK, 16, 4, 4},
3898 {VK_FORMAT_ASTC_4x4_SRGB_BLOCK, 16, 4, 4},
3899 {VK_FORMAT_ASTC_5x4_UNORM_BLOCK, 16, 5, 4},
3900 {VK_FORMAT_ASTC_5x4_SRGB_BLOCK, 16, 5, 4},
3901 {VK_FORMAT_ASTC_5x5_UNORM_BLOCK, 16, 5, 5},
3902 {VK_FORMAT_ASTC_5x5_SRGB_BLOCK, 16, 5, 5},
3903 {VK_FORMAT_ASTC_6x5_UNORM_BLOCK, 16, 6, 5},
3904 {VK_FORMAT_ASTC_6x5_SRGB_BLOCK, 16, 6, 5},
3905 {VK_FORMAT_ASTC_6x6_UNORM_BLOCK, 16, 6, 6},
3906 {VK_FORMAT_ASTC_6x6_SRGB_BLOCK, 16, 6, 6},
3907 {VK_FORMAT_ASTC_8x5_UNORM_BLOCK, 16, 8, 5},
3908 {VK_FORMAT_ASTC_8x5_SRGB_BLOCK, 16, 8, 5},
3909 {VK_FORMAT_ASTC_8x6_UNORM_BLOCK, 16, 8, 6},
3910 {VK_FORMAT_ASTC_8x6_SRGB_BLOCK, 16, 8, 6},
3911 {VK_FORMAT_ASTC_8x8_UNORM_BLOCK, 16, 8, 8},
3912 {VK_FORMAT_ASTC_8x8_SRGB_BLOCK, 16, 8, 8},
3913 {VK_FORMAT_ASTC_10x5_UNORM_BLOCK, 16, 10, 5},
3914 {VK_FORMAT_ASTC_10x5_SRGB_BLOCK, 16, 10, 5},
3915 {VK_FORMAT_ASTC_10x6_UNORM_BLOCK, 16, 10, 6},
3916 {VK_FORMAT_ASTC_10x6_SRGB_BLOCK, 16, 10, 6},
3917 {VK_FORMAT_ASTC_10x8_UNORM_BLOCK, 16, 10, 8},
3918 {VK_FORMAT_ASTC_10x8_SRGB_BLOCK, 16, 10, 8},
3919 {VK_FORMAT_ASTC_10x10_UNORM_BLOCK, 16, 10, 10},
3920 {VK_FORMAT_ASTC_10x10_SRGB_BLOCK, 16, 10, 10},
3921 {VK_FORMAT_ASTC_12x10_UNORM_BLOCK, 16, 12, 10},
3922 {VK_FORMAT_ASTC_12x10_SRGB_BLOCK, 16, 12, 10},
3923 {VK_FORMAT_ASTC_12x12_UNORM_BLOCK, 16, 12, 12},
3924 {VK_FORMAT_ASTC_12x12_SRGB_BLOCK, 16, 12, 12}};
3925
getFormatComponentWidth(const VkFormat format,const uint32_t componentNdx)3926 uint32_t getFormatComponentWidth(const VkFormat format, const uint32_t componentNdx)
3927 {
3928 const bool isAlphaOnly = isAlphaOnlyFormat(format);
3929 const tcu::TextureFormat tcuFormat(mapVkFormat(format));
3930 const uint32_t componentCount(isAlphaOnly ? 4u : tcu::getNumUsedChannels(tcuFormat.order));
3931
3932 if (isAlphaOnly && componentCount < 3u)
3933 return 0; // RGB has no width for A8_UNORM
3934
3935 if (componentNdx >= componentCount)
3936 DE_FATAL("Component index out of range");
3937 else
3938 {
3939 switch (tcuFormat.type)
3940 {
3941 case tcu::TextureFormat::UNORM_INT8:
3942 case tcu::TextureFormat::SNORM_INT8:
3943 case tcu::TextureFormat::UNSIGNED_INT8:
3944 case tcu::TextureFormat::SIGNED_INT8:
3945 return 8;
3946
3947 case tcu::TextureFormat::UNORM_SHORT_10:
3948 return 10;
3949
3950 case tcu::TextureFormat::UNORM_SHORT_12:
3951 return 12;
3952
3953 case tcu::TextureFormat::UNORM_INT16:
3954 case tcu::TextureFormat::SNORM_INT16:
3955 case tcu::TextureFormat::UNSIGNED_INT16:
3956 case tcu::TextureFormat::SIGNED_INT16:
3957 return 16;
3958
3959 case tcu::TextureFormat::UNORM_INT24:
3960 case tcu::TextureFormat::UNSIGNED_INT24:
3961 return 24;
3962
3963 case tcu::TextureFormat::UNORM_INT32:
3964 case tcu::TextureFormat::SNORM_INT32:
3965 case tcu::TextureFormat::UNSIGNED_INT32:
3966 case tcu::TextureFormat::SIGNED_INT32:
3967 case tcu::TextureFormat::FLOAT:
3968 return 32;
3969
3970 case tcu::TextureFormat::FLOAT64:
3971 case tcu::TextureFormat::UNSIGNED_INT64:
3972 case tcu::TextureFormat::SIGNED_INT64:
3973 return 64;
3974
3975 // Packed formats
3976 case tcu::TextureFormat::UNORM_SHORT_4444:
3977 case tcu::TextureFormat::UNSIGNED_SHORT_4444:
3978 return 4;
3979
3980 case tcu::TextureFormat::UNORM_SHORT_565:
3981 case tcu::TextureFormat::UNSIGNED_SHORT_565:
3982 return (componentNdx == 1 ? 6 : 5);
3983
3984 case tcu::TextureFormat::UNSIGNED_INT_24_8:
3985 case tcu::TextureFormat::UNSIGNED_INT_24_8_REV:
3986 case tcu::TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV:
3987 return (componentNdx == 0 ? 24 : 8);
3988
3989 case tcu::TextureFormat::UNORM_SHORT_1555:
3990 return (componentNdx == 0 ? 1 : 5);
3991
3992 case tcu::TextureFormat::UNORM_INT_1010102_REV:
3993 case tcu::TextureFormat::SNORM_INT_1010102_REV:
3994 case tcu::TextureFormat::UNSIGNED_INT_1010102_REV:
3995 case tcu::TextureFormat::SIGNED_INT_1010102_REV:
3996 return (componentNdx == 3 ? 2 : 10);
3997
3998 default:
3999 DE_FATAL("Format unimplemented");
4000 }
4001 }
4002
4003 return 0;
4004 }
4005
getRepresentableDiffUnorm(const VkFormat format,const uint32_t componentNdx)4006 float getRepresentableDiffUnorm(const VkFormat format, const uint32_t componentNdx)
4007 {
4008 const uint32_t size(getFormatComponentWidth(format, componentNdx));
4009
4010 return 1.0f / float((1 << (size)) - 1);
4011 }
4012
getRepresentableDiffSnorm(const VkFormat format,const uint32_t componentNdx)4013 float getRepresentableDiffSnorm(const VkFormat format, const uint32_t componentNdx)
4014 {
4015 const uint32_t size(getFormatComponentWidth(format, componentNdx));
4016
4017 return 1.0f / float((1 << (size - 1)) - 1);
4018 }
4019
getBlockSizeInBytes(const VkFormat compressedFormat)4020 uint32_t getBlockSizeInBytes(const VkFormat compressedFormat)
4021 {
4022 uint32_t formatNdx = static_cast<uint32_t>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
4023
4024 DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
4025 DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
4026
4027 return compressedFormatParameters[formatNdx].blockBytes;
4028 }
4029
getBlockWidth(const VkFormat compressedFormat)4030 uint32_t getBlockWidth(const VkFormat compressedFormat)
4031 {
4032 uint32_t formatNdx = static_cast<uint32_t>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
4033
4034 DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
4035 DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
4036
4037 return compressedFormatParameters[formatNdx].blockWidth;
4038 }
4039
getBlockHeight(const VkFormat compressedFormat)4040 uint32_t getBlockHeight(const VkFormat compressedFormat)
4041 {
4042 uint32_t formatNdx = static_cast<uint32_t>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
4043
4044 DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
4045 DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
4046
4047 return compressedFormatParameters[formatNdx].blockHeight;
4048 }
4049
mapFilterMode(tcu::Sampler::FilterMode filterMode)4050 VkFilter mapFilterMode(tcu::Sampler::FilterMode filterMode)
4051 {
4052 DE_STATIC_ASSERT(tcu::Sampler::FILTERMODE_LAST == 9);
4053
4054 switch (filterMode)
4055 {
4056 case tcu::Sampler::NEAREST:
4057 return VK_FILTER_NEAREST;
4058 case tcu::Sampler::LINEAR:
4059 return VK_FILTER_LINEAR;
4060 case tcu::Sampler::CUBIC:
4061 return VK_FILTER_CUBIC_EXT;
4062 case tcu::Sampler::NEAREST_MIPMAP_NEAREST:
4063 return VK_FILTER_NEAREST;
4064 case tcu::Sampler::NEAREST_MIPMAP_LINEAR:
4065 return VK_FILTER_NEAREST;
4066 case tcu::Sampler::LINEAR_MIPMAP_NEAREST:
4067 return VK_FILTER_LINEAR;
4068 case tcu::Sampler::LINEAR_MIPMAP_LINEAR:
4069 return VK_FILTER_LINEAR;
4070 case tcu::Sampler::CUBIC_MIPMAP_NEAREST:
4071 return VK_FILTER_CUBIC_EXT;
4072 case tcu::Sampler::CUBIC_MIPMAP_LINEAR:
4073 return VK_FILTER_CUBIC_EXT;
4074 default:
4075 DE_FATAL("Illegal filter mode");
4076 return (VkFilter)0;
4077 }
4078 }
4079
mapMipmapMode(tcu::Sampler::FilterMode filterMode)4080 VkSamplerMipmapMode mapMipmapMode(tcu::Sampler::FilterMode filterMode)
4081 {
4082 DE_STATIC_ASSERT(tcu::Sampler::FILTERMODE_LAST == 9);
4083
4084 // \note VkSamplerCreateInfo doesn't have a flag for disabling mipmapping. Instead
4085 // minLod = 0 and maxLod = 0.25 should be used to match OpenGL NEAREST and LINEAR
4086 // filtering mode behavior.
4087
4088 switch (filterMode)
4089 {
4090 case tcu::Sampler::NEAREST:
4091 return VK_SAMPLER_MIPMAP_MODE_NEAREST;
4092 case tcu::Sampler::LINEAR:
4093 return VK_SAMPLER_MIPMAP_MODE_NEAREST;
4094 case tcu::Sampler::CUBIC:
4095 return VK_SAMPLER_MIPMAP_MODE_NEAREST;
4096 case tcu::Sampler::NEAREST_MIPMAP_NEAREST:
4097 return VK_SAMPLER_MIPMAP_MODE_NEAREST;
4098 case tcu::Sampler::NEAREST_MIPMAP_LINEAR:
4099 return VK_SAMPLER_MIPMAP_MODE_LINEAR;
4100 case tcu::Sampler::LINEAR_MIPMAP_NEAREST:
4101 return VK_SAMPLER_MIPMAP_MODE_NEAREST;
4102 case tcu::Sampler::LINEAR_MIPMAP_LINEAR:
4103 return VK_SAMPLER_MIPMAP_MODE_LINEAR;
4104 case tcu::Sampler::CUBIC_MIPMAP_NEAREST:
4105 return VK_SAMPLER_MIPMAP_MODE_NEAREST;
4106 case tcu::Sampler::CUBIC_MIPMAP_LINEAR:
4107 return VK_SAMPLER_MIPMAP_MODE_LINEAR;
4108 default:
4109 DE_FATAL("Illegal filter mode");
4110 return (VkSamplerMipmapMode)0;
4111 }
4112 }
4113
mapWrapMode(tcu::Sampler::WrapMode wrapMode)4114 VkSamplerAddressMode mapWrapMode(tcu::Sampler::WrapMode wrapMode)
4115 {
4116 switch (wrapMode)
4117 {
4118 case tcu::Sampler::CLAMP_TO_EDGE:
4119 return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
4120 case tcu::Sampler::CLAMP_TO_BORDER:
4121 return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
4122 case tcu::Sampler::REPEAT_GL:
4123 return VK_SAMPLER_ADDRESS_MODE_REPEAT;
4124 case tcu::Sampler::MIRRORED_REPEAT_GL:
4125 return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
4126 case tcu::Sampler::MIRRORED_ONCE:
4127 return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
4128 default:
4129 DE_FATAL("Wrap mode can't be mapped to Vulkan");
4130 return (vk::VkSamplerAddressMode)0;
4131 }
4132 }
4133
mapCompareMode(tcu::Sampler::CompareMode mode)4134 vk::VkCompareOp mapCompareMode(tcu::Sampler::CompareMode mode)
4135 {
4136 switch (mode)
4137 {
4138 case tcu::Sampler::COMPAREMODE_NONE:
4139 return vk::VK_COMPARE_OP_NEVER;
4140 case tcu::Sampler::COMPAREMODE_LESS:
4141 return vk::VK_COMPARE_OP_LESS;
4142 case tcu::Sampler::COMPAREMODE_LESS_OR_EQUAL:
4143 return vk::VK_COMPARE_OP_LESS_OR_EQUAL;
4144 case tcu::Sampler::COMPAREMODE_GREATER:
4145 return vk::VK_COMPARE_OP_GREATER;
4146 case tcu::Sampler::COMPAREMODE_GREATER_OR_EQUAL:
4147 return vk::VK_COMPARE_OP_GREATER_OR_EQUAL;
4148 case tcu::Sampler::COMPAREMODE_EQUAL:
4149 return vk::VK_COMPARE_OP_EQUAL;
4150 case tcu::Sampler::COMPAREMODE_NOT_EQUAL:
4151 return vk::VK_COMPARE_OP_NOT_EQUAL;
4152 case tcu::Sampler::COMPAREMODE_ALWAYS:
4153 return vk::VK_COMPARE_OP_ALWAYS;
4154 case tcu::Sampler::COMPAREMODE_NEVER:
4155 return vk::VK_COMPARE_OP_NEVER;
4156 default:
4157 DE_FATAL("Illegal compare mode");
4158 return (vk::VkCompareOp)0;
4159 }
4160 }
4161
mapBorderColor(tcu::TextureChannelClass channelClass,const rr::GenericVec4 & color)4162 static VkBorderColor mapBorderColor(tcu::TextureChannelClass channelClass, const rr::GenericVec4 &color)
4163 {
4164 if (channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER)
4165 {
4166 const tcu::UVec4 uColor = color.get<uint32_t>();
4167
4168 if (uColor == tcu::UVec4(0, 0, 0, 0))
4169 return VK_BORDER_COLOR_INT_TRANSPARENT_BLACK;
4170 else if (uColor == tcu::UVec4(0, 0, 0, 1))
4171 return VK_BORDER_COLOR_INT_OPAQUE_BLACK;
4172 else if (uColor == tcu::UVec4(1, 1, 1, 1))
4173 return VK_BORDER_COLOR_INT_OPAQUE_WHITE;
4174 else
4175 return VK_BORDER_COLOR_INT_CUSTOM_EXT;
4176 }
4177 else if (channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER)
4178 {
4179 const tcu::IVec4 sColor = color.get<int32_t>();
4180
4181 if (sColor == tcu::IVec4(0, 0, 0, 0))
4182 return VK_BORDER_COLOR_INT_TRANSPARENT_BLACK;
4183 else if (sColor == tcu::IVec4(0, 0, 0, 1))
4184 return VK_BORDER_COLOR_INT_OPAQUE_BLACK;
4185 else if (sColor == tcu::IVec4(1, 1, 1, 1))
4186 return VK_BORDER_COLOR_INT_OPAQUE_WHITE;
4187 else
4188 return VK_BORDER_COLOR_INT_CUSTOM_EXT;
4189 }
4190 else
4191 {
4192 const tcu::Vec4 fColor = color.get<float>();
4193
4194 if (fColor == tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f))
4195 return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
4196 else if (fColor == tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f))
4197 return VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
4198 else if (fColor == tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f))
4199 return VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
4200 else
4201 return VK_BORDER_COLOR_FLOAT_CUSTOM_EXT;
4202 }
4203
4204 // note: never reached
4205 DE_FATAL("Unsupported border color");
4206 return VK_BORDER_COLOR_MAX_ENUM;
4207 }
4208
mapSampler(const tcu::Sampler & sampler,const tcu::TextureFormat & format,float minLod,float maxLod,bool unnormal)4209 VkSamplerCreateInfo mapSampler(const tcu::Sampler &sampler, const tcu::TextureFormat &format, float minLod,
4210 float maxLod, bool unnormal)
4211 {
4212 const bool compareEnabled = (sampler.compare != tcu::Sampler::COMPAREMODE_NONE);
4213 const VkCompareOp compareOp = (compareEnabled) ? (mapCompareMode(sampler.compare)) : (VK_COMPARE_OP_ALWAYS);
4214 const VkBorderColor borderColor = mapBorderColor(getTextureChannelClass(format.type), sampler.borderColor);
4215 const bool isMipmapEnabled =
4216 (sampler.minFilter != tcu::Sampler::NEAREST && sampler.minFilter != tcu::Sampler::LINEAR &&
4217 sampler.minFilter != tcu::Sampler::CUBIC);
4218 #ifndef CTS_USES_VULKANSC
4219 const VkSamplerCreateFlags flags =
4220 sampler.seamlessCubeMap ? 0u : (VkSamplerCreateFlags)VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT;
4221 #else
4222 const VkSamplerCreateFlags flags = 0u;
4223 #endif // CTS_USES_VULKANSC
4224
4225 const VkSamplerCreateInfo createInfo = {
4226 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
4227 DE_NULL,
4228 flags,
4229 mapFilterMode(sampler.magFilter), // magFilter
4230 mapFilterMode(sampler.minFilter), // minFilter
4231 mapMipmapMode(sampler.minFilter), // mipMode
4232 mapWrapMode(sampler.wrapS), // addressU
4233 mapWrapMode(sampler.wrapT), // addressV
4234 mapWrapMode(sampler.wrapR), // addressW
4235 0.0f, // mipLodBias
4236 VK_FALSE, // anisotropyEnable
4237 1.0f, // maxAnisotropy
4238 (VkBool32)(compareEnabled ? VK_TRUE : VK_FALSE), // compareEnable
4239 compareOp, // compareOp
4240 (isMipmapEnabled ? minLod : 0.0f), // minLod
4241 (isMipmapEnabled ? maxLod : (unnormal ? 0.0f : 0.25f)), // maxLod
4242 borderColor, // borderColor
4243 (VkBool32)(sampler.normalizedCoords ? VK_FALSE : VK_TRUE), // unnormalizedCoords
4244 };
4245
4246 return createInfo;
4247 }
4248
mapVkColor(const VkClearColorValue & color)4249 rr::GenericVec4 mapVkColor(const VkClearColorValue &color)
4250 {
4251 rr::GenericVec4 value;
4252
4253 static_assert(sizeof(rr::GenericVec4) == sizeof(VkClearColorValue),
4254 "GenericVec4 and VkClearColorValue size mismatch");
4255 deMemcpy(&value, &color, sizeof(rr::GenericVec4));
4256 return value;
4257 }
4258
mapVkColor(const rr::GenericVec4 & color)4259 VkClearColorValue mapVkColor(const rr::GenericVec4 &color)
4260 {
4261 VkClearColorValue value;
4262
4263 static_assert(sizeof(rr::GenericVec4) == sizeof(VkClearColorValue),
4264 "GenericVec4 and VkClearColorValue size mismatch");
4265 deMemcpy(&value, &color, sizeof(VkClearColorValue));
4266 return value;
4267 }
4268
mapVkSampler(const VkSamplerCreateInfo & samplerCreateInfo)4269 tcu::Sampler mapVkSampler(const VkSamplerCreateInfo &samplerCreateInfo)
4270 {
4271 // \note minLod & maxLod are not supported by tcu::Sampler. LOD must be clamped
4272 // before passing it to tcu::Texture*::sample*()
4273
4274 tcu::Sampler::ReductionMode reductionMode = tcu::Sampler::WEIGHTED_AVERAGE;
4275 rr::GenericVec4 borderColorValue;
4276
4277 void const *pNext = samplerCreateInfo.pNext;
4278 while (pNext != DE_NULL)
4279 {
4280 const VkStructureType nextType = *reinterpret_cast<const VkStructureType *>(pNext);
4281 switch (nextType)
4282 {
4283 case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
4284 {
4285 const VkSamplerReductionModeCreateInfo reductionModeCreateInfo =
4286 *reinterpret_cast<const VkSamplerReductionModeCreateInfo *>(pNext);
4287 reductionMode = mapVkSamplerReductionMode(reductionModeCreateInfo.reductionMode);
4288 pNext = reinterpret_cast<const VkSamplerReductionModeCreateInfo *>(pNext)->pNext;
4289 break;
4290 }
4291 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
4292 pNext = reinterpret_cast<const VkSamplerYcbcrConversionInfo *>(pNext)->pNext;
4293 break;
4294 case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
4295 {
4296 const VkSamplerCustomBorderColorCreateInfoEXT customBorderColorCreateInfo =
4297 *reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT *>(pNext);
4298 borderColorValue = mapVkColor(customBorderColorCreateInfo.customBorderColor);
4299 pNext = reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT *>(pNext)->pNext;
4300 break;
4301 }
4302 default:
4303 TCU_FAIL("Unrecognized sType in chained sampler create info");
4304 }
4305 }
4306
4307 tcu::Sampler sampler(mapVkSamplerAddressMode(samplerCreateInfo.addressModeU),
4308 mapVkSamplerAddressMode(samplerCreateInfo.addressModeV),
4309 mapVkSamplerAddressMode(samplerCreateInfo.addressModeW),
4310 mapVkMinTexFilter(samplerCreateInfo.minFilter, samplerCreateInfo.mipmapMode),
4311 mapVkMagTexFilter(samplerCreateInfo.magFilter), 0.0f,
4312 !samplerCreateInfo.unnormalizedCoordinates,
4313 samplerCreateInfo.compareEnable ? mapVkSamplerCompareOp(samplerCreateInfo.compareOp) :
4314 tcu::Sampler::COMPAREMODE_NONE,
4315 0, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),
4316 #ifndef CTS_USES_VULKANSC
4317 !(samplerCreateInfo.flags & VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT),
4318 #else
4319 true,
4320 #endif // CTS_USES_VULKANSC
4321 tcu::Sampler::MODE_DEPTH, reductionMode);
4322
4323 if (samplerCreateInfo.anisotropyEnable)
4324 TCU_THROW(InternalError, "Anisotropic filtering is not supported by tcu::Sampler");
4325
4326 switch (samplerCreateInfo.borderColor)
4327 {
4328 case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
4329 sampler.borderColor = tcu::UVec4(0, 0, 0, 1);
4330 break;
4331 case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
4332 sampler.borderColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
4333 break;
4334 case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
4335 sampler.borderColor = tcu::UVec4(1, 1, 1, 1);
4336 break;
4337 case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
4338 sampler.borderColor = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f);
4339 break;
4340 case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
4341 sampler.borderColor = tcu::UVec4(0, 0, 0, 0);
4342 break;
4343 case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
4344 sampler.borderColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
4345 break;
4346 case VK_BORDER_COLOR_FLOAT_CUSTOM_EXT:
4347 case VK_BORDER_COLOR_INT_CUSTOM_EXT:
4348 sampler.borderColor = borderColorValue;
4349 break;
4350
4351 default:
4352 DE_ASSERT(false);
4353 break;
4354 }
4355
4356 return sampler;
4357 }
4358
mapVkSamplerCompareOp(VkCompareOp compareOp)4359 tcu::Sampler::CompareMode mapVkSamplerCompareOp(VkCompareOp compareOp)
4360 {
4361 switch (compareOp)
4362 {
4363 case VK_COMPARE_OP_NEVER:
4364 return tcu::Sampler::COMPAREMODE_NEVER;
4365 case VK_COMPARE_OP_LESS:
4366 return tcu::Sampler::COMPAREMODE_LESS;
4367 case VK_COMPARE_OP_EQUAL:
4368 return tcu::Sampler::COMPAREMODE_EQUAL;
4369 case VK_COMPARE_OP_LESS_OR_EQUAL:
4370 return tcu::Sampler::COMPAREMODE_LESS_OR_EQUAL;
4371 case VK_COMPARE_OP_GREATER:
4372 return tcu::Sampler::COMPAREMODE_GREATER;
4373 case VK_COMPARE_OP_NOT_EQUAL:
4374 return tcu::Sampler::COMPAREMODE_NOT_EQUAL;
4375 case VK_COMPARE_OP_GREATER_OR_EQUAL:
4376 return tcu::Sampler::COMPAREMODE_GREATER_OR_EQUAL;
4377 case VK_COMPARE_OP_ALWAYS:
4378 return tcu::Sampler::COMPAREMODE_ALWAYS;
4379 default:
4380 break;
4381 }
4382
4383 DE_ASSERT(false);
4384 return tcu::Sampler::COMPAREMODE_LAST;
4385 }
4386
mapVkSamplerAddressMode(VkSamplerAddressMode addressMode)4387 tcu::Sampler::WrapMode mapVkSamplerAddressMode(VkSamplerAddressMode addressMode)
4388 {
4389 switch (addressMode)
4390 {
4391 case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:
4392 return tcu::Sampler::CLAMP_TO_EDGE;
4393 case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER:
4394 return tcu::Sampler::CLAMP_TO_BORDER;
4395 case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT:
4396 return tcu::Sampler::MIRRORED_REPEAT_GL;
4397 case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE:
4398 return tcu::Sampler::MIRRORED_ONCE;
4399 case VK_SAMPLER_ADDRESS_MODE_REPEAT:
4400 return tcu::Sampler::REPEAT_GL;
4401 default:
4402 break;
4403 }
4404
4405 DE_ASSERT(false);
4406 return tcu::Sampler::WRAPMODE_LAST;
4407 }
4408
mapVkSamplerReductionMode(VkSamplerReductionMode reductionMode)4409 tcu::Sampler::ReductionMode mapVkSamplerReductionMode(VkSamplerReductionMode reductionMode)
4410 {
4411 switch (reductionMode)
4412 {
4413 case VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE:
4414 return tcu::Sampler::WEIGHTED_AVERAGE;
4415 case VK_SAMPLER_REDUCTION_MODE_MIN:
4416 return tcu::Sampler::MIN;
4417 case VK_SAMPLER_REDUCTION_MODE_MAX:
4418 return tcu::Sampler::MAX;
4419 default:
4420 break;
4421 }
4422
4423 DE_ASSERT(false);
4424 return tcu::Sampler::REDUCTIONMODE_LAST;
4425 }
4426
mapVkMinTexFilter(VkFilter filter,VkSamplerMipmapMode mipMode)4427 tcu::Sampler::FilterMode mapVkMinTexFilter(VkFilter filter, VkSamplerMipmapMode mipMode)
4428 {
4429 switch (filter)
4430 {
4431 case VK_FILTER_LINEAR:
4432 switch (mipMode)
4433 {
4434 case VK_SAMPLER_MIPMAP_MODE_LINEAR:
4435 return tcu::Sampler::LINEAR_MIPMAP_LINEAR;
4436 case VK_SAMPLER_MIPMAP_MODE_NEAREST:
4437 return tcu::Sampler::LINEAR_MIPMAP_NEAREST;
4438 default:
4439 break;
4440 }
4441 break;
4442
4443 case VK_FILTER_NEAREST:
4444 switch (mipMode)
4445 {
4446 case VK_SAMPLER_MIPMAP_MODE_LINEAR:
4447 return tcu::Sampler::NEAREST_MIPMAP_LINEAR;
4448 case VK_SAMPLER_MIPMAP_MODE_NEAREST:
4449 return tcu::Sampler::NEAREST_MIPMAP_NEAREST;
4450 default:
4451 break;
4452 }
4453 break;
4454 case VK_FILTER_CUBIC_EXT:
4455 switch (mipMode)
4456 {
4457 case VK_SAMPLER_MIPMAP_MODE_LINEAR:
4458 return tcu::Sampler::CUBIC_MIPMAP_LINEAR;
4459 case VK_SAMPLER_MIPMAP_MODE_NEAREST:
4460 return tcu::Sampler::CUBIC_MIPMAP_NEAREST;
4461 default:
4462 break;
4463 }
4464 break;
4465
4466 default:
4467 break;
4468 }
4469
4470 DE_ASSERT(false);
4471 return tcu::Sampler::FILTERMODE_LAST;
4472 }
4473
mapVkMagTexFilter(VkFilter filter)4474 tcu::Sampler::FilterMode mapVkMagTexFilter(VkFilter filter)
4475 {
4476 switch (filter)
4477 {
4478 case VK_FILTER_LINEAR:
4479 return tcu::Sampler::LINEAR;
4480 case VK_FILTER_NEAREST:
4481 return tcu::Sampler::NEAREST;
4482 case VK_FILTER_CUBIC_EXT:
4483 return tcu::Sampler::CUBIC;
4484 default:
4485 break;
4486 }
4487
4488 DE_ASSERT(false);
4489 return tcu::Sampler::FILTERMODE_LAST;
4490 }
4491
4492 //! Get a format that matches the layout in buffer memory used for a
4493 //! buffer<->image copy on a depth/stencil format.
getDepthCopyFormat(VkFormat combinedFormat)4494 tcu::TextureFormat getDepthCopyFormat(VkFormat combinedFormat)
4495 {
4496 switch (combinedFormat)
4497 {
4498 case VK_FORMAT_D16_UNORM:
4499 case VK_FORMAT_X8_D24_UNORM_PACK32:
4500 case VK_FORMAT_D32_SFLOAT:
4501 return mapVkFormat(combinedFormat);
4502
4503 case VK_FORMAT_D16_UNORM_S8_UINT:
4504 return mapVkFormat(VK_FORMAT_D16_UNORM);
4505 case VK_FORMAT_D24_UNORM_S8_UINT:
4506 return mapVkFormat(VK_FORMAT_X8_D24_UNORM_PACK32);
4507 case VK_FORMAT_D32_SFLOAT_S8_UINT:
4508 return mapVkFormat(VK_FORMAT_D32_SFLOAT);
4509
4510 case VK_FORMAT_S8_UINT:
4511 default:
4512 DE_FATAL("Unexpected depth/stencil format");
4513 return tcu::TextureFormat();
4514 }
4515 }
4516
4517 //! Get a format that matches the layout in buffer memory used for a
4518 //! buffer<->image copy on a depth/stencil format.
getStencilCopyFormat(VkFormat combinedFormat)4519 tcu::TextureFormat getStencilCopyFormat(VkFormat combinedFormat)
4520 {
4521 switch (combinedFormat)
4522 {
4523 case VK_FORMAT_D16_UNORM_S8_UINT:
4524 case VK_FORMAT_D24_UNORM_S8_UINT:
4525 case VK_FORMAT_D32_SFLOAT_S8_UINT:
4526 case VK_FORMAT_S8_UINT:
4527 return mapVkFormat(VK_FORMAT_S8_UINT);
4528
4529 case VK_FORMAT_D16_UNORM:
4530 case VK_FORMAT_X8_D24_UNORM_PACK32:
4531 case VK_FORMAT_D32_SFLOAT:
4532 default:
4533 DE_FATAL("Unexpected depth/stencil format");
4534 return tcu::TextureFormat();
4535 }
4536 }
4537
getImageAspectFlags(const tcu::TextureFormat textureFormat)4538 VkImageAspectFlags getImageAspectFlags(const tcu::TextureFormat textureFormat)
4539 {
4540 VkImageAspectFlags imageAspectFlags = 0;
4541
4542 if (tcu::hasDepthComponent(textureFormat.order))
4543 imageAspectFlags |= VK_IMAGE_ASPECT_DEPTH_BIT;
4544
4545 if (tcu::hasStencilComponent(textureFormat.order))
4546 imageAspectFlags |= VK_IMAGE_ASPECT_STENCIL_BIT;
4547
4548 if (imageAspectFlags == 0)
4549 imageAspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;
4550
4551 return imageAspectFlags;
4552 }
4553
mipLevelExtents(const VkExtent3D & baseExtents,const uint32_t mipLevel)4554 VkExtent3D mipLevelExtents(const VkExtent3D &baseExtents, const uint32_t mipLevel)
4555 {
4556 VkExtent3D result;
4557
4558 result.width = std::max(baseExtents.width >> mipLevel, 1u);
4559 result.height = std::max(baseExtents.height >> mipLevel, 1u);
4560 result.depth = std::max(baseExtents.depth >> mipLevel, 1u);
4561
4562 return result;
4563 }
4564
alignedDivide(const VkExtent3D & extent,const VkExtent3D & divisor)4565 tcu::UVec3 alignedDivide(const VkExtent3D &extent, const VkExtent3D &divisor)
4566 {
4567 tcu::UVec3 result;
4568
4569 result.x() = extent.width / divisor.width + ((extent.width % divisor.width != 0) ? 1u : 0u);
4570 result.y() = extent.height / divisor.height + ((extent.height % divisor.height != 0) ? 1u : 0u);
4571 result.z() = extent.depth / divisor.depth + ((extent.depth % divisor.depth != 0) ? 1u : 0u);
4572
4573 return result;
4574 }
4575
copyBufferToImage(const DeviceInterface & vk,const VkCommandBuffer & cmdBuffer,const VkBuffer & buffer,VkDeviceSize bufferSize,const std::vector<VkBufferImageCopy> & copyRegions,VkImageAspectFlags imageAspectFlags,uint32_t mipLevels,uint32_t arrayLayers,VkImage destImage,VkImageLayout destImageLayout,VkPipelineStageFlags destImageDstStageFlags,VkAccessFlags destImageDstAccessMask,uint32_t baseMipLevel)4576 void copyBufferToImage(const DeviceInterface &vk, const VkCommandBuffer &cmdBuffer, const VkBuffer &buffer,
4577 VkDeviceSize bufferSize, const std::vector<VkBufferImageCopy> ©Regions,
4578 VkImageAspectFlags imageAspectFlags, uint32_t mipLevels, uint32_t arrayLayers, VkImage destImage,
4579 VkImageLayout destImageLayout, VkPipelineStageFlags destImageDstStageFlags,
4580 VkAccessFlags destImageDstAccessMask, uint32_t baseMipLevel)
4581 {
4582 // Barriers for copying buffer to image
4583 const VkBufferMemoryBarrier preBufferBarrier = {
4584 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
4585 DE_NULL, // const void* pNext;
4586 VK_ACCESS_HOST_WRITE_BIT, // VkAccessFlags srcAccessMask;
4587 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
4588 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
4589 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
4590 buffer, // VkBuffer buffer;
4591 0u, // VkDeviceSize offset;
4592 bufferSize // VkDeviceSize size;
4593 };
4594
4595 const VkImageMemoryBarrier preImageBarrier = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4596 DE_NULL, // const void* pNext;
4597 0u, // VkAccessFlags srcAccessMask;
4598 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
4599 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
4600 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
4601 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
4602 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
4603 destImage, // VkImage image;
4604 {
4605 // VkImageSubresourceRange subresourceRange;
4606 imageAspectFlags, // VkImageAspectFlags aspect;
4607 baseMipLevel, // uint32_t baseMipLevel;
4608 mipLevels, // uint32_t mipLevels;
4609 0u, // uint32_t baseArraySlice;
4610 arrayLayers // uint32_t arraySize;
4611 }};
4612
4613 const VkImageMemoryBarrier postImageBarrier = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4614 DE_NULL, // const void* pNext;
4615 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
4616 destImageDstAccessMask, // VkAccessFlags dstAccessMask;
4617 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
4618 destImageLayout, // VkImageLayout newLayout;
4619 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
4620 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
4621 destImage, // VkImage image;
4622 {
4623 // VkImageSubresourceRange subresourceRange;
4624 imageAspectFlags, // VkImageAspectFlags aspect;
4625 baseMipLevel, // uint32_t baseMipLevel;
4626 mipLevels, // uint32_t mipLevels;
4627 0u, // uint32_t baseArraySlice;
4628 arrayLayers // uint32_t arraySize;
4629 }};
4630
4631 // Copy buffer to image
4632 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0,
4633 0, (const VkMemoryBarrier *)DE_NULL, 1, &preBufferBarrier, 1, &preImageBarrier);
4634 vk.cmdCopyBufferToImage(cmdBuffer, buffer, destImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
4635 (uint32_t)copyRegions.size(), copyRegions.data());
4636 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, destImageDstStageFlags, (VkDependencyFlags)0, 0,
4637 (const VkMemoryBarrier *)DE_NULL, 0, (const VkBufferMemoryBarrier *)DE_NULL, 1,
4638 &postImageBarrier);
4639 }
4640
copyBufferToImage(const DeviceInterface & vk,VkDevice device,VkQueue queue,uint32_t queueFamilyIndex,const VkBuffer & buffer,VkDeviceSize bufferSize,const std::vector<VkBufferImageCopy> & copyRegions,const VkSemaphore * waitSemaphore,VkImageAspectFlags imageAspectFlags,uint32_t mipLevels,uint32_t arrayLayers,VkImage destImage,VkImageLayout destImageLayout,VkPipelineStageFlags destImageDstStageFlags,VkAccessFlags destImageDstAccessMask,const VkCommandPool * externalCommandPool,uint32_t baseMipLevel)4641 void copyBufferToImage(const DeviceInterface &vk, VkDevice device, VkQueue queue, uint32_t queueFamilyIndex,
4642 const VkBuffer &buffer, VkDeviceSize bufferSize,
4643 const std::vector<VkBufferImageCopy> ©Regions, const VkSemaphore *waitSemaphore,
4644 VkImageAspectFlags imageAspectFlags, uint32_t mipLevels, uint32_t arrayLayers, VkImage destImage,
4645 VkImageLayout destImageLayout, VkPipelineStageFlags destImageDstStageFlags,
4646 VkAccessFlags destImageDstAccessMask, const VkCommandPool *externalCommandPool,
4647 uint32_t baseMipLevel)
4648 {
4649 Move<VkCommandPool> cmdPool;
4650 VkCommandPool activeCmdPool;
4651 if (externalCommandPool == DE_NULL)
4652 {
4653 // Create local command pool
4654 cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
4655 activeCmdPool = *cmdPool;
4656 }
4657 else
4658 {
4659 // Use external command pool if available
4660 activeCmdPool = *externalCommandPool;
4661 }
4662
4663 Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, activeCmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
4664 Move<VkFence> fence = createFence(vk, device);
4665
4666 const VkCommandBufferBeginInfo cmdBufferBeginInfo = {
4667 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
4668 DE_NULL, // const void* pNext;
4669 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
4670 (const VkCommandBufferInheritanceInfo *)DE_NULL,
4671 };
4672
4673 VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
4674 copyBufferToImage(vk, *cmdBuffer, buffer, bufferSize, copyRegions, imageAspectFlags, mipLevels, arrayLayers,
4675 destImage, destImageLayout, destImageDstStageFlags, destImageDstAccessMask, baseMipLevel);
4676 VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
4677
4678 const VkPipelineStageFlags pipelineStageFlags = VK_PIPELINE_STAGE_TRANSFER_BIT;
4679
4680 const VkSubmitInfo submitInfo = {
4681 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
4682 DE_NULL, // const void* pNext;
4683 waitSemaphore ? 1u : 0u, // uint32_t waitSemaphoreCount;
4684 waitSemaphore, // const VkSemaphore* pWaitSemaphores;
4685 &pipelineStageFlags, // const VkPipelineStageFlags* pWaitDstStageMask;
4686 1u, // uint32_t commandBufferCount;
4687 &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
4688 0u, // uint32_t signalSemaphoreCount;
4689 DE_NULL // const VkSemaphore* pSignalSemaphores;
4690 };
4691
4692 try
4693 {
4694 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
4695 VK_CHECK(vk.waitForFences(device, 1, &fence.get(), true, ~(0ull) /* infinity */));
4696 }
4697 catch (...)
4698 {
4699 VK_CHECK(vk.deviceWaitIdle(device));
4700 throw;
4701 }
4702 }
4703
copyImageToBuffer(const DeviceInterface & vk,VkCommandBuffer cmdBuffer,VkImage image,VkBuffer buffer,tcu::IVec2 size,VkAccessFlags srcAccessMask,VkImageLayout oldLayout,uint32_t numLayers,VkImageAspectFlags barrierAspect,VkImageAspectFlags copyAspect,VkPipelineStageFlags srcStageMask)4704 void copyImageToBuffer(const DeviceInterface &vk, VkCommandBuffer cmdBuffer, VkImage image, VkBuffer buffer,
4705 tcu::IVec2 size, VkAccessFlags srcAccessMask, VkImageLayout oldLayout, uint32_t numLayers,
4706 VkImageAspectFlags barrierAspect, VkImageAspectFlags copyAspect,
4707 VkPipelineStageFlags srcStageMask)
4708 {
4709 const VkImageMemoryBarrier imageBarrier = {
4710 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4711 DE_NULL, // const void* pNext;
4712 srcAccessMask, // VkAccessFlags srcAccessMask;
4713 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
4714 oldLayout, // VkImageLayout oldLayout;
4715 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
4716 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
4717 VK_QUEUE_FAMILY_IGNORED, // uint32_t destQueueFamilyIndex;
4718 image, // VkImage image;
4719 makeImageSubresourceRange(barrierAspect, 0u, 1u, 0, numLayers) // VkImageSubresourceRange subresourceRange;
4720 };
4721
4722 vk.cmdPipelineBarrier(cmdBuffer, srcStageMask, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u,
4723 &imageBarrier);
4724
4725 const VkImageSubresourceLayers subresource = {
4726 copyAspect, // VkImageAspectFlags aspectMask;
4727 0u, // uint32_t mipLevel;
4728 0u, // uint32_t baseArrayLayer;
4729 numLayers // uint32_t layerCount;
4730 };
4731
4732 const VkBufferImageCopy region = {
4733 0ull, // VkDeviceSize bufferOffset;
4734 0u, // uint32_t bufferRowLength;
4735 0u, // uint32_t bufferImageHeight;
4736 subresource, // VkImageSubresourceLayers imageSubresource;
4737 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
4738 makeExtent3D(size.x(), size.y(), 1u) // VkExtent3D imageExtent;
4739 };
4740
4741 vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, 1u, ®ion);
4742
4743 const VkBufferMemoryBarrier bufferBarrier = {
4744 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
4745 DE_NULL, // const void* pNext;
4746 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
4747 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
4748 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
4749 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
4750 buffer, // VkBuffer buffer;
4751 0ull, // VkDeviceSize offset;
4752 VK_WHOLE_SIZE // VkDeviceSize size;
4753 };
4754
4755 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 1u,
4756 &bufferBarrier, 0u, DE_NULL);
4757 }
4758
copyImageToBuffer(const DeviceInterface & vk,vk::VkCommandBuffer cmdBuffer,vk::VkImage image,vk::VkBuffer buffer,vk::VkFormat format,tcu::IVec2 size,uint32_t mipLevel,vk::VkAccessFlags srcAccessMask,vk::VkImageLayout oldLayout,uint32_t numLayers,VkImageAspectFlags barrierAspect,VkImageAspectFlags copyAspect)4759 void copyImageToBuffer(const DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkBuffer buffer,
4760 vk::VkFormat format, tcu::IVec2 size, uint32_t mipLevel, vk::VkAccessFlags srcAccessMask,
4761 vk::VkImageLayout oldLayout, uint32_t numLayers, VkImageAspectFlags barrierAspect,
4762 VkImageAspectFlags copyAspect)
4763 {
4764 const VkImageMemoryBarrier imageBarrier = {
4765 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4766 DE_NULL, // const void* pNext;
4767 srcAccessMask, // VkAccessFlags srcAccessMask;
4768 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
4769 oldLayout, // VkImageLayout oldLayout;
4770 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
4771 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
4772 VK_QUEUE_FAMILY_IGNORED, // uint32_t destQueueFamilyIndex;
4773 image, // VkImage image;
4774 makeImageSubresourceRange(barrierAspect, mipLevel, 1u, 0,
4775 numLayers) // VkImageSubresourceRange subresourceRange;
4776 };
4777
4778 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u,
4779 DE_NULL, 0u, DE_NULL, 1u, &imageBarrier);
4780
4781 const VkImageSubresourceLayers subresource = {
4782 copyAspect, // VkImageAspectFlags aspectMask;
4783 mipLevel, // uint32_t mipLevel;
4784 0u, // uint32_t baseArrayLayer;
4785 numLayers // uint32_t layerCount;
4786 };
4787
4788 VkDeviceSize offset = 0ull;
4789 uint32_t width = size.x();
4790 uint32_t height = size.y();
4791 uint32_t pixelSize = tcu::getPixelSize(mapVkFormat(format));
4792
4793 for (uint32_t level = 0; level < mipLevel; ++level)
4794 {
4795 offset += (width * height * pixelSize);
4796 height /= 2;
4797 width /= 2;
4798 }
4799
4800 const VkBufferImageCopy region = {
4801 offset, // VkDeviceSize bufferOffset;
4802 0u, // uint32_t bufferRowLength;
4803 0u, // uint32_t bufferImageHeight;
4804 subresource, // VkImageSubresourceLayers imageSubresource;
4805 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
4806 makeExtent3D(width, height, 1u) // VkExtent3D imageExtent;
4807 };
4808
4809 vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, 1u, ®ion);
4810
4811 const VkBufferMemoryBarrier bufferBarrier = {
4812 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
4813 DE_NULL, // const void* pNext;
4814 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
4815 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
4816 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
4817 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
4818 buffer, // VkBuffer buffer;
4819 offset, // VkDeviceSize offset;
4820 VK_WHOLE_SIZE // VkDeviceSize size;
4821 };
4822
4823 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 1u,
4824 &bufferBarrier, 0u, DE_NULL);
4825 }
4826
clearColorImage(const DeviceInterface & vk,const VkDevice device,const VkQueue queue,uint32_t queueFamilyIndex,VkImage image,VkClearColorValue clearColor,VkImageLayout oldLayout,VkImageLayout newLayout,VkAccessFlags dstAccessFlags,VkPipelineStageFlags dstStageFlags,uint32_t baseArrayLayer,uint32_t layerCount,uint32_t baseMipLevel,uint32_t levelCount)4827 void clearColorImage(const DeviceInterface &vk, const VkDevice device, const VkQueue queue, uint32_t queueFamilyIndex,
4828 VkImage image, VkClearColorValue clearColor, VkImageLayout oldLayout, VkImageLayout newLayout,
4829 VkAccessFlags dstAccessFlags, VkPipelineStageFlags dstStageFlags, uint32_t baseArrayLayer,
4830 uint32_t layerCount, uint32_t baseMipLevel, uint32_t levelCount)
4831 {
4832 Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
4833 Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
4834
4835 const VkImageSubresourceRange subresourceRange = {
4836 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
4837 baseMipLevel, // uint32_t baseMipLevel
4838 levelCount, // uint32_t levelCount
4839 baseArrayLayer, // uint32_t baseArrayLayer
4840 layerCount, // uint32_t layerCount
4841 };
4842
4843 const VkImageMemoryBarrier preImageBarrier = {
4844 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4845 DE_NULL, // const void* pNext;
4846 0u, // VkAccessFlags srcAccessMask;
4847 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
4848 oldLayout, // VkImageLayout oldLayout;
4849 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
4850 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
4851 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
4852 image, // VkImage image;
4853 subresourceRange // VkImageSubresourceRange subresourceRange;
4854 };
4855
4856 const VkImageMemoryBarrier postImageBarrier = {
4857 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4858 DE_NULL, // const void* pNext;
4859 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
4860 dstAccessFlags, // VkAccessFlags dstAccessMask;
4861 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
4862 newLayout, // VkImageLayout newLayout;
4863 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
4864 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
4865 image, // VkImage image;
4866 subresourceRange // VkImageSubresourceRange subresourceRange;
4867 };
4868
4869 beginCommandBuffer(vk, *cmdBuffer);
4870 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0,
4871 0, (const VkMemoryBarrier *)DE_NULL, 0, (const VkBufferMemoryBarrier *)DE_NULL, 1,
4872 &preImageBarrier);
4873 vk.cmdClearColorImage(*cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColor, 1, &subresourceRange);
4874 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, dstStageFlags, (VkDependencyFlags)0, 0,
4875 (const VkMemoryBarrier *)DE_NULL, 0, (const VkBufferMemoryBarrier *)DE_NULL, 1,
4876 &postImageBarrier);
4877 endCommandBuffer(vk, *cmdBuffer);
4878
4879 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
4880 }
4881
clearColorImage(const DeviceInterface & vk,const VkDevice device,const VkQueue queue,uint32_t queueFamilyIndex,VkImage image,tcu::Vec4 clearColor,VkImageLayout oldLayout,VkImageLayout newLayout,VkPipelineStageFlags dstStageFlags,uint32_t baseArrayLayer,uint32_t layerCount,uint32_t baseMipLevel,uint32_t levelCount)4882 void clearColorImage(const DeviceInterface &vk, const VkDevice device, const VkQueue queue, uint32_t queueFamilyIndex,
4883 VkImage image, tcu::Vec4 clearColor, VkImageLayout oldLayout, VkImageLayout newLayout,
4884 VkPipelineStageFlags dstStageFlags, uint32_t baseArrayLayer, uint32_t layerCount,
4885 uint32_t baseMipLevel, uint32_t levelCount)
4886 {
4887 clearColorImage(vk, device, queue, queueFamilyIndex, image, makeClearValueColor(clearColor).color, oldLayout,
4888 newLayout, VK_ACCESS_SHADER_WRITE_BIT, dstStageFlags, baseArrayLayer, layerCount, baseMipLevel,
4889 levelCount);
4890 }
4891
generateChessboardCopyRegions(uint32_t tileSize,uint32_t imageWidth,uint32_t imageHeight,uint32_t tileIdx,VkImageAspectFlags aspectMask)4892 std::vector<VkBufferImageCopy> generateChessboardCopyRegions(uint32_t tileSize, uint32_t imageWidth,
4893 uint32_t imageHeight, uint32_t tileIdx,
4894 VkImageAspectFlags aspectMask)
4895 {
4896 std::vector<VkBufferImageCopy> copyRegions;
4897
4898 for (uint32_t x = 0; x < (uint32_t)deFloatCeil((float)imageWidth / (float)tileSize); x++)
4899 for (uint32_t y = 0; y < (uint32_t)deFloatCeil((float)imageHeight / (float)tileSize); y++)
4900 {
4901 if ((x + tileIdx) % 2 == y % 2)
4902 continue;
4903
4904 const uint32_t tileWidth = de::min(tileSize, imageWidth - tileSize * x);
4905 const uint32_t tileHeight = de::min(tileSize, imageHeight - tileSize * y);
4906
4907 const VkOffset3D offset = {
4908 (int32_t)x * (int32_t)tileWidth, // int32_t x
4909 (int32_t)y * (int32_t)tileHeight, // int32_t y
4910 0 // int32_t z
4911 };
4912
4913 const VkExtent3D extent = {
4914 tileWidth, // uint32_t width
4915 tileHeight, // uint32_t height
4916 1u // uint32_t depth
4917 };
4918
4919 const VkImageSubresourceLayers subresourceLayers = {
4920 aspectMask, // VkImageAspectFlags aspectMask
4921 0u, // uint32_t mipLevel
4922 0u, // uint32_t baseArrayLayer
4923 1u, // uint32_t layerCount
4924 };
4925
4926 const VkBufferImageCopy copy = {
4927 (VkDeviceSize)0, // VkDeviceSize bufferOffset
4928 0u, // uint32_t bufferRowLength
4929 0u, // uint32_t bufferImageHeight
4930 subresourceLayers, // VkImageSubresourceLayers imageSubresource
4931 offset, // VkOffset3D imageOffset
4932 extent // VkExtent3D imageExtent
4933 };
4934
4935 copyRegions.push_back(copy);
4936 }
4937
4938 return copyRegions;
4939 }
4940
initColorImageChessboardPattern(const DeviceInterface & vk,const VkDevice device,const VkQueue queue,uint32_t queueFamilyIndex,Allocator & allocator,VkImage image,VkFormat format,tcu::Vec4 colorValue0,tcu::Vec4 colorValue1,uint32_t imageWidth,uint32_t imageHeight,uint32_t tileSize,VkImageLayout oldLayout,VkImageLayout newLayout,VkPipelineStageFlags dstStageFlags)4941 void initColorImageChessboardPattern(const DeviceInterface &vk, const VkDevice device, const VkQueue queue,
4942 uint32_t queueFamilyIndex, Allocator &allocator, VkImage image, VkFormat format,
4943 tcu::Vec4 colorValue0, tcu::Vec4 colorValue1, uint32_t imageWidth,
4944 uint32_t imageHeight, uint32_t tileSize, VkImageLayout oldLayout,
4945 VkImageLayout newLayout, VkPipelineStageFlags dstStageFlags)
4946 {
4947 Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
4948 Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
4949 const tcu::TextureFormat tcuFormat = mapVkFormat(format);
4950 const tcu::Vec4 colorValues[] = {colorValue0, colorValue1};
4951 const uint32_t bufferSize = tileSize * tileSize * tcuFormat.getPixelSize();
4952
4953 const VkImageSubresourceRange subresourceRange = {
4954 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
4955 0u, // uint32_t baseMipLevel
4956 1u, // uint32_t levelCount
4957 0u, // uint32_t baseArrayLayer
4958 1u // uint32_t layerCount
4959 };
4960
4961 const VkImageMemoryBarrier preImageBarrier = {
4962 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4963 DE_NULL, // const void* pNext;
4964 0u, // VkAccessFlags srcAccessMask;
4965 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
4966 oldLayout, // VkImageLayout oldLayout;
4967 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
4968 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
4969 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
4970 image, // VkImage image;
4971 subresourceRange // VkImageSubresourceRange subresourceRange;
4972 };
4973
4974 const VkImageMemoryBarrier postImageBarrier = {
4975 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4976 DE_NULL, // const void* pNext;
4977 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
4978 VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags dstAccessMask;
4979 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
4980 newLayout, // VkImageLayout newLayout;
4981 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
4982 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
4983 image, // VkImage image;
4984 subresourceRange // VkImageSubresourceRange subresourceRange;
4985 };
4986
4987 // Create staging buffers for both color values
4988 Move<VkBuffer> buffers[2];
4989 de::MovePtr<Allocation> bufferAllocs[2];
4990
4991 const VkBufferCreateInfo bufferParams = {
4992 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType
4993 DE_NULL, // const void* pNext
4994 0u, // VkBufferCreateFlags flags
4995 (VkDeviceSize)bufferSize, // VkDeviceSize size
4996 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage
4997 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
4998 0u, // uint32_t queueFamilyIndexCount
4999 DE_NULL // const uint32_t* pQueueFamilyIndices
5000 };
5001
5002 for (uint32_t bufferIdx = 0; bufferIdx < 2; bufferIdx++)
5003 {
5004 buffers[bufferIdx] = createBuffer(vk, device, &bufferParams);
5005 bufferAllocs[bufferIdx] = allocator.allocate(getBufferMemoryRequirements(vk, device, *buffers[bufferIdx]),
5006 MemoryRequirement::HostVisible);
5007 VK_CHECK(vk.bindBufferMemory(device, *buffers[bufferIdx], bufferAllocs[bufferIdx]->getMemory(),
5008 bufferAllocs[bufferIdx]->getOffset()));
5009
5010 uint32_t *dstPtr = (uint32_t *)bufferAllocs[bufferIdx]->getHostPtr();
5011 tcu::PixelBufferAccess access(tcuFormat, tileSize, tileSize, 1, dstPtr);
5012
5013 for (uint32_t x = 0; x < tileSize; x++)
5014 for (uint32_t y = 0; y < tileSize; y++)
5015 access.setPixel(colorValues[bufferIdx], x, y, 0);
5016
5017 flushAlloc(vk, device, *bufferAllocs[bufferIdx]);
5018 }
5019
5020 beginCommandBuffer(vk, *cmdBuffer);
5021 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0,
5022 0, (const VkMemoryBarrier *)DE_NULL, 0, (const VkBufferMemoryBarrier *)DE_NULL, 1,
5023 &preImageBarrier);
5024
5025 for (uint32_t bufferIdx = 0; bufferIdx < 2; bufferIdx++)
5026 {
5027 std::vector<VkBufferImageCopy> copyRegions =
5028 generateChessboardCopyRegions(tileSize, imageWidth, imageHeight, bufferIdx, VK_IMAGE_ASPECT_COLOR_BIT);
5029
5030 vk.cmdCopyBufferToImage(*cmdBuffer, *buffers[bufferIdx], image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
5031 (uint32_t)copyRegions.size(), copyRegions.data());
5032 }
5033
5034 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, dstStageFlags, (VkDependencyFlags)0, 0,
5035 (const VkMemoryBarrier *)DE_NULL, 0, (const VkBufferMemoryBarrier *)DE_NULL, 1,
5036 &postImageBarrier);
5037
5038 endCommandBuffer(vk, *cmdBuffer);
5039
5040 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
5041 }
5042
copyDepthStencilImageToBuffers(const DeviceInterface & vk,VkCommandBuffer cmdBuffer,VkImage image,VkBuffer depthBuffer,VkBuffer stencilBuffer,tcu::IVec2 size,VkAccessFlags srcAccessMask,VkImageLayout oldLayout,uint32_t numLayers)5043 void copyDepthStencilImageToBuffers(const DeviceInterface &vk, VkCommandBuffer cmdBuffer, VkImage image,
5044 VkBuffer depthBuffer, VkBuffer stencilBuffer, tcu::IVec2 size,
5045 VkAccessFlags srcAccessMask, VkImageLayout oldLayout, uint32_t numLayers)
5046 {
5047 const VkImageAspectFlags aspect = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
5048 const VkImageMemoryBarrier imageBarrier = {
5049 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
5050 DE_NULL, // const void* pNext;
5051 srcAccessMask, // VkAccessFlags srcAccessMask;
5052 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
5053 oldLayout, // VkImageLayout oldLayout;
5054 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
5055 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
5056 VK_QUEUE_FAMILY_IGNORED, // uint32_t destQueueFamilyIndex;
5057 image, // VkImage image;
5058 makeImageSubresourceRange(aspect, 0u, 1u, 0, numLayers) // VkImageSubresourceRange subresourceRange;
5059 };
5060
5061 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u,
5062 DE_NULL, 0u, DE_NULL, 1u, &imageBarrier);
5063
5064 const VkImageSubresourceLayers subresourceDepth = {
5065 VK_IMAGE_ASPECT_DEPTH_BIT, // VkImageAspectFlags aspectMask;
5066 0u, // uint32_t mipLevel;
5067 0u, // uint32_t baseArrayLayer;
5068 numLayers // uint32_t layerCount;
5069 };
5070
5071 const VkBufferImageCopy regionDepth = {
5072 0ull, // VkDeviceSize bufferOffset;
5073 0u, // uint32_t bufferRowLength;
5074 0u, // uint32_t bufferImageHeight;
5075 subresourceDepth, // VkImageSubresourceLayers imageSubresource;
5076 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
5077 makeExtent3D(size.x(), size.y(), 1u) // VkExtent3D imageExtent;
5078 };
5079
5080 const VkImageSubresourceLayers subresourceStencil = {
5081 VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask;
5082 0u, // uint32_t mipLevel;
5083 0u, // uint32_t baseArrayLayer;
5084 numLayers // uint32_t layerCount;
5085 };
5086
5087 const VkBufferImageCopy regionStencil = {
5088 0ull, // VkDeviceSize bufferOffset;
5089 0u, // uint32_t bufferRowLength;
5090 0u, // uint32_t bufferImageHeight;
5091 subresourceStencil, // VkImageSubresourceLayers imageSubresource;
5092 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
5093 makeExtent3D(size.x(), size.y(), 1u) // VkExtent3D imageExtent;
5094 };
5095
5096 vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, depthBuffer, 1u, ®ionDepth);
5097 vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, stencilBuffer, 1u, ®ionStencil);
5098
5099 const VkBufferMemoryBarrier bufferBarriers[] = {
5100 {
5101 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
5102 DE_NULL, // const void* pNext;
5103 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
5104 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
5105 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
5106 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
5107 depthBuffer, // VkBuffer buffer;
5108 0ull, // VkDeviceSize offset;
5109 VK_WHOLE_SIZE // VkDeviceSize size;
5110 },
5111 {
5112 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
5113 DE_NULL, // const void* pNext;
5114 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
5115 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
5116 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
5117 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
5118 stencilBuffer, // VkBuffer buffer;
5119 0ull, // VkDeviceSize offset;
5120 VK_WHOLE_SIZE // VkDeviceSize size;
5121 }};
5122
5123 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 2u,
5124 bufferBarriers, 0u, DE_NULL);
5125 }
5126
clearDepthStencilImage(const DeviceInterface & vk,const VkDevice device,const VkQueue queue,uint32_t queueFamilyIndex,VkImage image,VkFormat format,float depthValue,uint32_t stencilValue,VkImageLayout oldLayout,VkImageLayout newLayout,VkAccessFlags dstAccessFlags,VkPipelineStageFlags dstStageFlags)5127 void clearDepthStencilImage(const DeviceInterface &vk, const VkDevice device, const VkQueue queue,
5128 uint32_t queueFamilyIndex, VkImage image, VkFormat format, float depthValue,
5129 uint32_t stencilValue, VkImageLayout oldLayout, VkImageLayout newLayout,
5130 VkAccessFlags dstAccessFlags, VkPipelineStageFlags dstStageFlags)
5131 {
5132 Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
5133 Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
5134
5135 const VkClearDepthStencilValue clearValue = makeClearValueDepthStencil(depthValue, stencilValue).depthStencil;
5136 const auto aspectMask = getImageAspectFlags(mapVkFormat(format));
5137
5138 const VkImageSubresourceRange subresourceRange = {
5139 aspectMask, // VkImageAspectFlags aspectMask
5140 0u, // uint32_t baseMipLevel
5141 1u, // uint32_t levelCount
5142 0u, // uint32_t baseArrayLayer
5143 1u // uint32_t layerCount
5144 };
5145
5146 const VkImageMemoryBarrier preImageBarrier = {
5147 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
5148 DE_NULL, // const void* pNext;
5149 0u, // VkAccessFlags srcAccessMask;
5150 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
5151 oldLayout, // VkImageLayout oldLayout;
5152 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
5153 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
5154 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
5155 image, // VkImage image;
5156 subresourceRange // VkImageSubresourceRange subresourceRange;
5157 };
5158
5159 const VkImageMemoryBarrier postImageBarrier = {
5160 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
5161 DE_NULL, // const void* pNext;
5162 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
5163 dstAccessFlags, // VkAccessFlags dstAccessMask;
5164 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
5165 newLayout, // VkImageLayout newLayout;
5166 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
5167 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
5168 image, // VkImage image;
5169 subresourceRange // VkImageSubresourceRange subresourceRange;
5170 };
5171
5172 beginCommandBuffer(vk, *cmdBuffer);
5173 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0,
5174 0, (const VkMemoryBarrier *)DE_NULL, 0, (const VkBufferMemoryBarrier *)DE_NULL, 1,
5175 &preImageBarrier);
5176 vk.cmdClearDepthStencilImage(*cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearValue, 1,
5177 &subresourceRange);
5178 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, dstStageFlags, (VkDependencyFlags)0, 0,
5179 (const VkMemoryBarrier *)DE_NULL, 0, (const VkBufferMemoryBarrier *)DE_NULL, 1,
5180 &postImageBarrier);
5181 endCommandBuffer(vk, *cmdBuffer);
5182
5183 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
5184 }
5185
initDepthStencilImageChessboardPattern(const DeviceInterface & vk,const VkDevice device,const VkQueue queue,uint32_t queueFamilyIndex,Allocator & allocator,VkImage image,VkFormat format,float depthValue0,float depthValue1,uint32_t stencilValue0,uint32_t stencilValue1,uint32_t imageWidth,uint32_t imageHeight,uint32_t tileSize,VkImageLayout oldLayout,VkImageLayout newLayout,VkPipelineStageFlags dstStageFlags)5186 void initDepthStencilImageChessboardPattern(const DeviceInterface &vk, const VkDevice device, const VkQueue queue,
5187 uint32_t queueFamilyIndex, Allocator &allocator, VkImage image,
5188 VkFormat format, float depthValue0, float depthValue1,
5189 uint32_t stencilValue0, uint32_t stencilValue1, uint32_t imageWidth,
5190 uint32_t imageHeight, uint32_t tileSize, VkImageLayout oldLayout,
5191 VkImageLayout newLayout, VkPipelineStageFlags dstStageFlags)
5192 {
5193 Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
5194 Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
5195
5196 const uint32_t depthBufferSize = tileSize * tileSize * 4;
5197 const uint32_t stencilBufferSize = tileSize * tileSize;
5198 const float depthValues[] = {depthValue0, depthValue1};
5199 const uint32_t stencilValues[] = {stencilValue0, stencilValue1};
5200 const tcu::TextureFormat tcuFormat = mapVkFormat(format);
5201
5202 const VkImageSubresourceRange subresourceRange = {
5203 VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask
5204 0u, // uint32_t baseMipLevel
5205 1u, // uint32_t levelCount
5206 0u, // uint32_t baseArrayLayer
5207 1u // uint32_t layerCount
5208 };
5209
5210 const VkImageMemoryBarrier preImageBarrier = {
5211 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
5212 DE_NULL, // const void* pNext;
5213 0u, // VkAccessFlags srcAccessMask;
5214 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
5215 oldLayout, // VkImageLayout oldLayout;
5216 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
5217 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
5218 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
5219 image, // VkImage image;
5220 subresourceRange // VkImageSubresourceRange subresourceRange;
5221 };
5222
5223 const VkImageMemoryBarrier postImageBarrier = {
5224 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
5225 DE_NULL, // const void* pNext;
5226 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
5227 VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags dstAccessMask;
5228 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
5229 newLayout, // VkImageLayout newLayout;
5230 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
5231 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
5232 image, // VkImage image;
5233 subresourceRange // VkImageSubresourceRange subresourceRange;
5234 };
5235
5236 // Create staging buffers for depth and stencil values
5237 Move<VkBuffer> depthBuffers[2];
5238 de::MovePtr<Allocation> depthBufferAllocs[2];
5239 Move<VkBuffer> stencilBuffers[2];
5240 de::MovePtr<Allocation> stencilBufferAllocs[2];
5241
5242 const VkBufferCreateInfo depthBufferParams = {
5243 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType
5244 DE_NULL, // const void* pNext
5245 0u, // VkBufferCreateFlags flags
5246 (VkDeviceSize)depthBufferSize, // VkDeviceSize size
5247 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage
5248 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
5249 0u, // uint32_t queueFamilyIndexCount
5250 DE_NULL // const uint32_t* pQueueFamilyIndices
5251 };
5252
5253 const VkBufferCreateInfo stencilBufferParams = {
5254 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType
5255 DE_NULL, // const void* pNext
5256 0u, // VkBufferCreateFlags flags
5257 (VkDeviceSize)stencilBufferSize, // VkDeviceSize size
5258 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage
5259 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
5260 0u, // uint32_t queueFamilyIndexCount
5261 DE_NULL // const uint32_t* pQueueFamilyIndices
5262 };
5263
5264 for (uint32_t bufferIdx = 0; bufferIdx < 2; bufferIdx++)
5265 {
5266 depthBuffers[bufferIdx] = createBuffer(vk, device, &depthBufferParams);
5267 depthBufferAllocs[bufferIdx] = allocator.allocate(
5268 getBufferMemoryRequirements(vk, device, *depthBuffers[bufferIdx]), MemoryRequirement::HostVisible);
5269 VK_CHECK(vk.bindBufferMemory(device, *depthBuffers[bufferIdx], depthBufferAllocs[bufferIdx]->getMemory(),
5270 depthBufferAllocs[bufferIdx]->getOffset()));
5271 stencilBuffers[bufferIdx] = createBuffer(vk, device, &stencilBufferParams);
5272 stencilBufferAllocs[bufferIdx] = allocator.allocate(
5273 getBufferMemoryRequirements(vk, device, *stencilBuffers[bufferIdx]), MemoryRequirement::HostVisible);
5274 VK_CHECK(vk.bindBufferMemory(device, *stencilBuffers[bufferIdx], stencilBufferAllocs[bufferIdx]->getMemory(),
5275 stencilBufferAllocs[bufferIdx]->getOffset()));
5276
5277 uint32_t *depthPtr = (uint32_t *)depthBufferAllocs[bufferIdx]->getHostPtr();
5278 uint32_t *stencilPtr = (uint32_t *)stencilBufferAllocs[bufferIdx]->getHostPtr();
5279
5280 if (format == VK_FORMAT_D24_UNORM_S8_UINT)
5281 {
5282 tcu::PixelBufferAccess access(tcuFormat, tileSize, tileSize, 1, depthPtr);
5283
5284 for (uint32_t x = 0; x < tileSize; x++)
5285 for (uint32_t y = 0; y < tileSize; y++)
5286 access.setPixDepth(depthValues[bufferIdx], x, y, 0);
5287 }
5288 else
5289 {
5290 DE_ASSERT(format == VK_FORMAT_D32_SFLOAT_S8_UINT);
5291
5292 for (uint32_t i = 0; i < tileSize * tileSize; i++)
5293 ((float *)depthPtr)[i] = depthValues[bufferIdx];
5294 }
5295
5296 deMemset(stencilPtr, stencilValues[bufferIdx], stencilBufferSize);
5297 flushAlloc(vk, device, *depthBufferAllocs[bufferIdx]);
5298 flushAlloc(vk, device, *stencilBufferAllocs[bufferIdx]);
5299 }
5300
5301 beginCommandBuffer(vk, *cmdBuffer);
5302 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0,
5303 0, (const VkMemoryBarrier *)DE_NULL, 0, (const VkBufferMemoryBarrier *)DE_NULL, 1,
5304 &preImageBarrier);
5305
5306 for (uint32_t bufferIdx = 0; bufferIdx < 2; bufferIdx++)
5307 {
5308 std::vector<VkBufferImageCopy> copyRegionsDepth =
5309 generateChessboardCopyRegions(tileSize, imageWidth, imageHeight, bufferIdx, VK_IMAGE_ASPECT_DEPTH_BIT);
5310 std::vector<VkBufferImageCopy> copyRegionsStencil =
5311 generateChessboardCopyRegions(tileSize, imageWidth, imageHeight, bufferIdx, VK_IMAGE_ASPECT_STENCIL_BIT);
5312
5313 vk.cmdCopyBufferToImage(*cmdBuffer, *depthBuffers[bufferIdx], image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
5314 (uint32_t)copyRegionsDepth.size(), copyRegionsDepth.data());
5315 vk.cmdCopyBufferToImage(*cmdBuffer, *stencilBuffers[bufferIdx], image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
5316 (uint32_t)copyRegionsStencil.size(), copyRegionsStencil.data());
5317 }
5318
5319 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, dstStageFlags, (VkDependencyFlags)0, 0,
5320 (const VkMemoryBarrier *)DE_NULL, 0, (const VkBufferMemoryBarrier *)DE_NULL, 1,
5321 &postImageBarrier);
5322
5323 endCommandBuffer(vk, *cmdBuffer);
5324
5325 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
5326 }
5327
makeDefaultImageSubresourceRange()5328 vk::VkImageSubresourceRange makeDefaultImageSubresourceRange()
5329 {
5330 return vk::makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
5331 }
5332
makeDefaultImageSubresourceLayers()5333 vk::VkImageSubresourceLayers makeDefaultImageSubresourceLayers()
5334 {
5335 return makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u);
5336 }
5337
ImageWithBuffer(const DeviceInterface & vkd,const VkDevice device,Allocator & alloc,vk::VkExtent3D extent,vk::VkFormat imageFormat,vk::VkImageUsageFlags usage,vk::VkImageType imageType,vk::VkImageSubresourceRange ssr,uint32_t arrayLayers,vk::VkSampleCountFlagBits samples,vk::VkImageTiling tiling,uint32_t mipLevels,vk::VkSharingMode sharingMode)5338 ImageWithBuffer::ImageWithBuffer(const DeviceInterface &vkd, const VkDevice device, Allocator &alloc,
5339 vk::VkExtent3D extent, vk::VkFormat imageFormat, vk::VkImageUsageFlags usage,
5340 vk::VkImageType imageType, vk::VkImageSubresourceRange ssr, uint32_t arrayLayers,
5341 vk::VkSampleCountFlagBits samples, vk::VkImageTiling tiling, uint32_t mipLevels,
5342 vk::VkSharingMode sharingMode)
5343 {
5344
5345 if (imageType == VK_IMAGE_TYPE_3D)
5346 DE_ASSERT(arrayLayers == 1);
5347 DE_ASSERT(extent.width > 0 && extent.height > 0 && extent.depth > 0);
5348 DE_ASSERT(mipLevels > 0 && arrayLayers > 0);
5349
5350 // Color attachment.
5351 const VkImageCreateInfo colorAttachmentCreateInfo = {
5352 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
5353 nullptr, // const void* pNext;
5354 0u, // VkImageCreateFlags flags;
5355 imageType, // VkImageType imageType;
5356 imageFormat, // VkFormat format;
5357 extent, // VkExtent3D extent;
5358 mipLevels, // uint32_t mipLevels;
5359 arrayLayers, // uint32_t arrayLayers;
5360 samples, // VkSampleCountFlagBits samples;
5361 tiling, // VkImageTiling tiling;
5362 usage, // VkImageUsageFlags usage;
5363 sharingMode, // VkSharingMode sharingMode;
5364 0u, // uint32_t queueFamilyIndexCount;
5365 nullptr, // const uint32_t* pQueueFamilyIndices;
5366 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
5367 };
5368 image = std::unique_ptr<ImageWithMemory>(
5369 new ImageWithMemory(vkd, device, alloc, colorAttachmentCreateInfo, MemoryRequirement::Any));
5370
5371 VkImageViewType viewType;
5372 switch (imageType)
5373 {
5374 case VK_IMAGE_TYPE_1D:
5375 viewType = ((arrayLayers == 1) ? VK_IMAGE_VIEW_TYPE_1D : VK_IMAGE_VIEW_TYPE_1D_ARRAY);
5376 break;
5377 case VK_IMAGE_TYPE_2D:
5378 viewType = ((arrayLayers == 1) ? VK_IMAGE_VIEW_TYPE_2D : VK_IMAGE_VIEW_TYPE_2D_ARRAY);
5379 break;
5380 case VK_IMAGE_TYPE_3D:
5381 viewType = VK_IMAGE_VIEW_TYPE_3D;
5382 break;
5383 default:
5384 viewType = VK_IMAGE_VIEW_TYPE_LAST;
5385 DE_ASSERT(imageType <= VK_IMAGE_TYPE_3D);
5386 }
5387
5388 // Color attachment view.
5389 imageView = makeImageView(vkd, device, (*image).get(), viewType, imageFormat, ssr);
5390
5391 // Verification buffer.
5392 const auto tcuFormat = mapVkFormat(imageFormat);
5393 const auto verificationBufferSize =
5394 tcuFormat.getPixelSize() * extent.width * extent.height * arrayLayers * extent.depth;
5395 const auto verificationBufferCreateInfo =
5396 makeBufferCreateInfo(verificationBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
5397
5398 buffer = std::unique_ptr<BufferWithMemory>(
5399 new BufferWithMemory(vkd, device, alloc, verificationBufferCreateInfo, MemoryRequirement::HostVisible));
5400 size = verificationBufferSize;
5401 }
5402
getImage()5403 VkImage ImageWithBuffer::getImage()
5404 {
5405 return (*image).get();
5406 }
5407
getImageView()5408 VkImageView ImageWithBuffer::getImageView()
5409 {
5410 return imageView.get();
5411 }
5412
getBuffer()5413 VkBuffer ImageWithBuffer::getBuffer()
5414 {
5415 return (*buffer).get();
5416 }
5417
getBufferSize()5418 VkDeviceSize ImageWithBuffer::getBufferSize()
5419 {
5420 return size;
5421 }
5422
getImageAllocation()5423 Allocation &ImageWithBuffer::getImageAllocation()
5424 {
5425 return (*image).getAllocation();
5426 }
5427
getBufferAllocation()5428 Allocation &ImageWithBuffer::getBufferAllocation()
5429 {
5430 return (*buffer).getAllocation();
5431 }
5432
5433 #ifndef CTS_USES_VULKANSC
5434
allocateAndBindSparseImage(const DeviceInterface & vk,VkDevice device,const VkPhysicalDevice physicalDevice,const InstanceInterface & instance,const VkImageCreateInfo & imageCreateInfo,const VkSemaphore & signalSemaphore,VkQueue queue,Allocator & allocator,std::vector<de::SharedPtr<Allocation>> & allocations,tcu::TextureFormat format,VkImage destImage)5435 void allocateAndBindSparseImage(const DeviceInterface &vk, VkDevice device, const VkPhysicalDevice physicalDevice,
5436 const InstanceInterface &instance, const VkImageCreateInfo &imageCreateInfo,
5437 const VkSemaphore &signalSemaphore, VkQueue queue, Allocator &allocator,
5438 std::vector<de::SharedPtr<Allocation>> &allocations, tcu::TextureFormat format,
5439 VkImage destImage)
5440 {
5441 const VkImageAspectFlags imageAspectFlags = getImageAspectFlags(format);
5442 const VkPhysicalDeviceProperties deviceProperties = getPhysicalDeviceProperties(instance, physicalDevice);
5443 const VkPhysicalDeviceMemoryProperties deviceMemoryProperties =
5444 getPhysicalDeviceMemoryProperties(instance, physicalDevice);
5445 uint32_t sparseMemoryReqCount = 0;
5446
5447 // Check if the image format supports sparse operations
5448 if (!checkSparseImageFormatSupport(physicalDevice, instance, imageCreateInfo))
5449 TCU_THROW(NotSupportedError, "The image format does not support sparse operations.");
5450
5451 vk.getImageSparseMemoryRequirements(device, destImage, &sparseMemoryReqCount, DE_NULL);
5452
5453 DE_ASSERT(sparseMemoryReqCount != 0);
5454
5455 std::vector<VkSparseImageMemoryRequirements> sparseImageMemoryRequirements;
5456 sparseImageMemoryRequirements.resize(sparseMemoryReqCount);
5457
5458 vk.getImageSparseMemoryRequirements(device, destImage, &sparseMemoryReqCount, &sparseImageMemoryRequirements[0]);
5459
5460 const uint32_t noMatchFound = ~((uint32_t)0);
5461
5462 std::vector<uint32_t> aspectIndices;
5463
5464 VkImageAspectFlags memReqAspectFlags = 0;
5465
5466 for (uint32_t memoryReqNdx = 0; memoryReqNdx < sparseMemoryReqCount; ++memoryReqNdx)
5467 {
5468 if (sparseImageMemoryRequirements[memoryReqNdx].formatProperties.aspectMask & imageAspectFlags)
5469 {
5470 aspectIndices.push_back(memoryReqNdx);
5471 memReqAspectFlags |= sparseImageMemoryRequirements[memoryReqNdx].formatProperties.aspectMask;
5472 }
5473 }
5474
5475 uint32_t metadataAspectIndex = noMatchFound;
5476 for (uint32_t memoryReqNdx = 0; memoryReqNdx < sparseMemoryReqCount; ++memoryReqNdx)
5477 {
5478 if (sparseImageMemoryRequirements[memoryReqNdx].formatProperties.aspectMask & VK_IMAGE_ASPECT_METADATA_BIT)
5479 {
5480 metadataAspectIndex = memoryReqNdx;
5481 break;
5482 }
5483 }
5484
5485 if (memReqAspectFlags != imageAspectFlags)
5486 TCU_THROW(NotSupportedError, "Required image aspect not supported.");
5487
5488 const VkMemoryRequirements memoryRequirements = getImageMemoryRequirements(vk, device, destImage);
5489
5490 uint32_t memoryType = noMatchFound;
5491 for (uint32_t memoryTypeNdx = 0; memoryTypeNdx < deviceMemoryProperties.memoryTypeCount; ++memoryTypeNdx)
5492 {
5493 if ((memoryRequirements.memoryTypeBits & (1u << memoryTypeNdx)) != 0 &&
5494 MemoryRequirement::Any.matchesHeap(deviceMemoryProperties.memoryTypes[memoryTypeNdx].propertyFlags))
5495 {
5496 memoryType = memoryTypeNdx;
5497 break;
5498 }
5499 }
5500
5501 if (memoryType == noMatchFound)
5502 TCU_THROW(NotSupportedError, "No matching memory type found.");
5503
5504 if (memoryRequirements.size > deviceProperties.limits.sparseAddressSpaceSize)
5505 TCU_THROW(NotSupportedError, "Required memory size for sparse resource exceeds device limits.");
5506
5507 std::vector<VkSparseImageMemoryBind> imageResidencyMemoryBinds;
5508 std::vector<VkSparseMemoryBind> imageMipTailMemoryBinds;
5509
5510 for (uint32_t aspectIndex : aspectIndices)
5511 {
5512 const VkSparseImageMemoryRequirements aspectRequirements = sparseImageMemoryRequirements[aspectIndex];
5513 VkExtent3D blockSize = aspectRequirements.formatProperties.imageGranularity;
5514
5515 for (uint32_t layerNdx = 0; layerNdx < imageCreateInfo.arrayLayers; ++layerNdx)
5516 {
5517 for (uint32_t mipLevelNdx = 0; mipLevelNdx < aspectRequirements.imageMipTailFirstLod; ++mipLevelNdx)
5518 {
5519 const VkExtent3D mipExtent = mipLevelExtents(imageCreateInfo.extent, mipLevelNdx);
5520 const tcu::UVec3 numSparseBinds = alignedDivide(mipExtent, blockSize);
5521 const tcu::UVec3 lastBlockExtent = tcu::UVec3(
5522 mipExtent.width % blockSize.width ? mipExtent.width % blockSize.width : blockSize.width,
5523 mipExtent.height % blockSize.height ? mipExtent.height % blockSize.height : blockSize.height,
5524 mipExtent.depth % blockSize.depth ? mipExtent.depth % blockSize.depth : blockSize.depth);
5525
5526 for (uint32_t z = 0; z < numSparseBinds.z(); ++z)
5527 for (uint32_t y = 0; y < numSparseBinds.y(); ++y)
5528 for (uint32_t x = 0; x < numSparseBinds.x(); ++x)
5529 {
5530 const VkMemoryRequirements allocRequirements = {
5531 // 28.7.5 alignment shows the block size in bytes
5532 memoryRequirements.alignment, // VkDeviceSize size;
5533 memoryRequirements.alignment, // VkDeviceSize alignment;
5534 memoryRequirements.memoryTypeBits, // uint32_t memoryTypeBits;
5535 };
5536
5537 de::SharedPtr<Allocation> allocation(
5538 allocator.allocate(allocRequirements, MemoryRequirement::Any).release());
5539 allocations.push_back(allocation);
5540
5541 VkOffset3D offset;
5542 offset.x = x * blockSize.width;
5543 offset.y = y * blockSize.height;
5544 offset.z = z * blockSize.depth;
5545
5546 VkExtent3D extent;
5547 extent.width = (x == numSparseBinds.x() - 1) ? lastBlockExtent.x() : blockSize.width;
5548 extent.height = (y == numSparseBinds.y() - 1) ? lastBlockExtent.y() : blockSize.height;
5549 extent.depth = (z == numSparseBinds.z() - 1) ? lastBlockExtent.z() : blockSize.depth;
5550
5551 const VkSparseImageMemoryBind imageMemoryBind = {
5552 {
5553 aspectRequirements.formatProperties.aspectMask, // VkImageAspectFlags aspectMask;
5554 mipLevelNdx, // uint32_t mipLevel;
5555 layerNdx, // uint32_t arrayLayer;
5556 }, // VkImageSubresource subresource;
5557 offset, // VkOffset3D offset;
5558 extent, // VkExtent3D extent;
5559 allocation->getMemory(), // VkDeviceMemory memory;
5560 allocation->getOffset(), // VkDeviceSize memoryOffset;
5561 0u, // VkSparseMemoryBindFlags flags;
5562 };
5563
5564 imageResidencyMemoryBinds.push_back(imageMemoryBind);
5565 }
5566 }
5567
5568 // Handle MIP tail. There are two cases to consider here:
5569 //
5570 // 1) VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT is requested by the driver: each layer needs a separate tail.
5571 // 2) otherwise: only one tail is needed.
5572 if (aspectRequirements.imageMipTailSize > 0)
5573 {
5574 if (layerNdx == 0 ||
5575 (aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) == 0)
5576 {
5577 const VkMemoryRequirements allocRequirements = {
5578 aspectRequirements.imageMipTailSize, // VkDeviceSize size;
5579 memoryRequirements.alignment, // VkDeviceSize alignment;
5580 memoryRequirements.memoryTypeBits, // uint32_t memoryTypeBits;
5581 };
5582
5583 const de::SharedPtr<Allocation> allocation(
5584 allocator.allocate(allocRequirements, MemoryRequirement::Any).release());
5585
5586 const VkSparseMemoryBind imageMipTailMemoryBind = {
5587 aspectRequirements.imageMipTailOffset +
5588 layerNdx * aspectRequirements.imageMipTailStride, // VkDeviceSize resourceOffset;
5589 aspectRequirements.imageMipTailSize, // VkDeviceSize size;
5590 allocation->getMemory(), // VkDeviceMemory memory;
5591 allocation->getOffset(), // VkDeviceSize memoryOffset;
5592 0u, // VkSparseMemoryBindFlags flags;
5593 };
5594
5595 allocations.push_back(allocation);
5596
5597 imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
5598 }
5599 }
5600
5601 // Handle Metadata. Similarly to MIP tail in aspectRequirements, there are two cases to consider here:
5602 //
5603 // 1) VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT is requested by the driver: each layer needs a separate tail.
5604 // 2) otherwise:
5605 if (metadataAspectIndex != noMatchFound)
5606 {
5607 const VkSparseImageMemoryRequirements metadataAspectRequirements =
5608 sparseImageMemoryRequirements[metadataAspectIndex];
5609
5610 if (layerNdx == 0 || (metadataAspectRequirements.formatProperties.flags &
5611 VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) == 0)
5612 {
5613 const VkMemoryRequirements metadataAllocRequirements = {
5614 metadataAspectRequirements.imageMipTailSize, // VkDeviceSize size;
5615 memoryRequirements.alignment, // VkDeviceSize alignment;
5616 memoryRequirements.memoryTypeBits, // uint32_t memoryTypeBits;
5617 };
5618 const de::SharedPtr<Allocation> metadataAllocation(
5619 allocator.allocate(metadataAllocRequirements, MemoryRequirement::Any).release());
5620
5621 const VkSparseMemoryBind metadataMipTailMemoryBind = {
5622 metadataAspectRequirements.imageMipTailOffset +
5623 layerNdx * metadataAspectRequirements.imageMipTailStride, // VkDeviceSize resourceOffset;
5624 metadataAspectRequirements.imageMipTailSize, // VkDeviceSize size;
5625 metadataAllocation->getMemory(), // VkDeviceMemory memory;
5626 metadataAllocation->getOffset(), // VkDeviceSize memoryOffset;
5627 VK_SPARSE_MEMORY_BIND_METADATA_BIT // VkSparseMemoryBindFlags flags;
5628 };
5629
5630 allocations.push_back(metadataAllocation);
5631
5632 imageMipTailMemoryBinds.push_back(metadataMipTailMemoryBind);
5633 }
5634 }
5635 }
5636 }
5637
5638 VkBindSparseInfo bindSparseInfo = {
5639 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, //VkStructureType sType;
5640 DE_NULL, //const void* pNext;
5641 0u, //uint32_t waitSemaphoreCount;
5642 DE_NULL, //const VkSemaphore* pWaitSemaphores;
5643 0u, //uint32_t bufferBindCount;
5644 DE_NULL, //const VkSparseBufferMemoryBindInfo* pBufferBinds;
5645 0u, //uint32_t imageOpaqueBindCount;
5646 DE_NULL, //const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
5647 0u, //uint32_t imageBindCount;
5648 DE_NULL, //const VkSparseImageMemoryBindInfo* pImageBinds;
5649 1u, //uint32_t signalSemaphoreCount;
5650 &signalSemaphore //const VkSemaphore* pSignalSemaphores;
5651 };
5652
5653 VkSparseImageMemoryBindInfo imageResidencyBindInfo;
5654 VkSparseImageOpaqueMemoryBindInfo imageMipTailBindInfo;
5655
5656 if (imageResidencyMemoryBinds.size() > 0)
5657 {
5658 imageResidencyBindInfo.image = destImage;
5659 imageResidencyBindInfo.bindCount = static_cast<uint32_t>(imageResidencyMemoryBinds.size());
5660 imageResidencyBindInfo.pBinds = &imageResidencyMemoryBinds[0];
5661
5662 bindSparseInfo.imageBindCount = 1u;
5663 bindSparseInfo.pImageBinds = &imageResidencyBindInfo;
5664 }
5665
5666 if (imageMipTailMemoryBinds.size() > 0)
5667 {
5668 imageMipTailBindInfo.image = destImage;
5669 imageMipTailBindInfo.bindCount = static_cast<uint32_t>(imageMipTailMemoryBinds.size());
5670 imageMipTailBindInfo.pBinds = &imageMipTailMemoryBinds[0];
5671
5672 bindSparseInfo.imageOpaqueBindCount = 1u;
5673 bindSparseInfo.pImageOpaqueBinds = &imageMipTailBindInfo;
5674 }
5675
5676 VK_CHECK(vk.queueBindSparse(queue, 1u, &bindSparseInfo, DE_NULL));
5677 }
5678
checkSparseImageFormatSupport(const VkPhysicalDevice physicalDevice,const InstanceInterface & instance,const VkFormat format,const VkImageType imageType,const VkSampleCountFlagBits sampleCount,const VkImageUsageFlags usageFlags,const VkImageTiling imageTiling)5679 bool checkSparseImageFormatSupport(const VkPhysicalDevice physicalDevice, const InstanceInterface &instance,
5680 const VkFormat format, const VkImageType imageType,
5681 const VkSampleCountFlagBits sampleCount, const VkImageUsageFlags usageFlags,
5682 const VkImageTiling imageTiling)
5683 {
5684 const auto propVec = getPhysicalDeviceSparseImageFormatProperties(instance, physicalDevice, format, imageType,
5685 sampleCount, usageFlags, imageTiling);
5686 return (propVec.size() != 0);
5687 }
5688
checkSparseImageFormatSupport(const VkPhysicalDevice physicalDevice,const InstanceInterface & instance,const VkImageCreateInfo & imageCreateInfo)5689 bool checkSparseImageFormatSupport(const VkPhysicalDevice physicalDevice, const InstanceInterface &instance,
5690 const VkImageCreateInfo &imageCreateInfo)
5691 {
5692 return checkSparseImageFormatSupport(physicalDevice, instance, imageCreateInfo.format, imageCreateInfo.imageType,
5693 imageCreateInfo.samples, imageCreateInfo.usage, imageCreateInfo.tiling);
5694 }
5695 #endif // CTS_USES_VULKANSC
5696
5697 } // namespace vk
5698