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_R16G16B16A16_SFLOAT:
2319 {
2320 const PlanarFormatDescription desc = {1, // planes
2321 chanR | chanG | chanB | chanA,
2322 1,
2323 1,
2324 {
2325 // Size WDiv HDiv planeCompatibleFormat
2326 {8, 1, 1, VK_FORMAT_R16G16B16A16_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, 16, 8}, // R
2333 {0, sfloat, 16, 16, 8}, // G
2334 {0, sfloat, 32, 16, 8}, // B
2335 {0, sfloat, 48, 16, 8} // A
2336 }};
2337 return desc;
2338 }
2339
2340 case VK_FORMAT_R32G32B32A32_SFLOAT:
2341 {
2342 const PlanarFormatDescription desc = {1, // planes
2343 chanR | chanG | chanB | chanA,
2344 1,
2345 1,
2346 {
2347 // Size WDiv HDiv planeCompatibleFormat
2348 {16, 1, 1, VK_FORMAT_R32G32B32A32_SFLOAT},
2349 {0, 0, 0, VK_FORMAT_UNDEFINED},
2350 {0, 0, 0, VK_FORMAT_UNDEFINED},
2351 },
2352 {
2353 // Plane Type Offs Size Stride
2354 {0, sfloat, 0, 32, 16}, // R
2355 {0, sfloat, 32, 32, 16}, // G
2356 {0, sfloat, 64, 32, 16}, // B
2357 {0, sfloat, 96, 32, 16}, // A
2358 }};
2359 return desc;
2360 }
2361
2362 case VK_FORMAT_A4R4G4B4_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_A4R4G4B4_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, 8, 4, 2}, // R
2377 {0, unorm, 4, 4, 2}, // G
2378 {0, unorm, 0, 4, 2}, // B
2379 {0, unorm, 12, 4, 2} // A
2380 }};
2381 return desc;
2382 }
2383
2384 case VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT:
2385 {
2386 const PlanarFormatDescription desc = {1, // planes
2387 chanR | chanG | chanB | chanA,
2388 1,
2389 1,
2390 {
2391 // Size WDiv HDiv planeCompatibleFormat
2392 {2, 1, 1, VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT},
2393 {0, 0, 0, VK_FORMAT_UNDEFINED},
2394 {0, 0, 0, VK_FORMAT_UNDEFINED},
2395 },
2396 {
2397 // Plane Type Offs Size Stride
2398 {0, unorm, 0, 4, 2}, // R
2399 {0, unorm, 4, 4, 2}, // G
2400 {0, unorm, 8, 4, 2}, // B
2401 {0, unorm, 12, 4, 2} // A
2402 }};
2403 return desc;
2404 }
2405
2406 #ifndef CTS_USES_VULKANSC
2407 case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR:
2408 {
2409 const PlanarFormatDescription desc{1, // planes
2410 chanR | chanG | chanB | chanA,
2411 1,
2412 1,
2413 {
2414 // Size WDiv HDiv planeCompatibleFormat
2415 {2, 1, 1, VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR},
2416 {0, 0, 0, VK_FORMAT_UNDEFINED},
2417 {0, 0, 0, VK_FORMAT_UNDEFINED},
2418 },
2419 {
2420 // Plane Type Offs Size Stride
2421 {0, unorm, 11, 5, 2}, // R
2422 {0, unorm, 6, 5, 2}, // G
2423 {0, unorm, 1, 5, 2}, // B
2424 {0, unorm, 0, 1, 2} // A
2425 }};
2426 return desc;
2427 }
2428 #endif // CTS_USES_VULKANSC
2429
2430 default:
2431 TCU_THROW(InternalError, "Not implemented");
2432 }
2433 }
2434
getPlanarFormatDescription(VkFormat format)2435 PlanarFormatDescription getPlanarFormatDescription(VkFormat format)
2436 {
2437 if (isYCbCrFormat(format))
2438 return getYCbCrPlanarFormatDescription(format);
2439 #ifndef CTS_USES_VULKANSC
2440 else if (format == VK_FORMAT_A8_UNORM_KHR)
2441 {
2442 const auto unorm = static_cast<uint8_t>(tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT);
2443 const auto chanA = static_cast<uint8_t>(PlanarFormatDescription::CHANNEL_A);
2444
2445 const PlanarFormatDescription desc = {1, // planes
2446 chanA,
2447 1,
2448 1,
2449 {
2450 // Size WDiv HDiv planeCompatibleFormat
2451 {1, 1, 1, VK_FORMAT_A8_UNORM_KHR},
2452 {0, 0, 0, VK_FORMAT_UNDEFINED},
2453 {0, 0, 0, VK_FORMAT_UNDEFINED},
2454 },
2455 {
2456 // Plane Type Offs Size Stride
2457 {0, 0, 0, 0, 0}, // R
2458 {0, 0, 0, 0, 0}, // G
2459 {0, 0, 0, 0, 0}, // B
2460 {0, unorm, 0, 8, 1}, // A
2461 }};
2462
2463 return desc;
2464 }
2465 #endif // CTS_USES_VULKANSC
2466 else
2467 return getCorePlanarFormatDescription(format);
2468 }
2469
getPlaneCount(VkFormat format)2470 int getPlaneCount(VkFormat format)
2471 {
2472 switch (format)
2473 {
2474 case VK_FORMAT_G8B8G8R8_422_UNORM:
2475 case VK_FORMAT_B8G8R8G8_422_UNORM:
2476 case VK_FORMAT_R10X6_UNORM_PACK16:
2477 case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
2478 case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
2479 case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
2480 case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
2481 case VK_FORMAT_R12X4_UNORM_PACK16:
2482 case VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
2483 case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
2484 case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
2485 case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
2486 case VK_FORMAT_G16B16G16R16_422_UNORM:
2487 case VK_FORMAT_B16G16R16G16_422_UNORM:
2488 return 1;
2489
2490 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
2491 case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
2492 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
2493 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
2494 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
2495 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
2496 case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
2497 case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
2498 case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT:
2499 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT:
2500 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT:
2501 case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT:
2502 return 2;
2503
2504 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
2505 case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
2506 case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
2507 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
2508 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
2509 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
2510 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
2511 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
2512 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
2513 case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
2514 case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
2515 case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
2516 return 3;
2517
2518 default:
2519 DE_FATAL("Not YCbCr format");
2520 return 0;
2521 }
2522 }
2523
getMipmapCount(VkFormat format,const vk::PlanarFormatDescription & formatDescription,const VkImageFormatProperties & imageFormatProperties,const VkExtent3D & extent)2524 uint32_t getMipmapCount(VkFormat format, const vk::PlanarFormatDescription &formatDescription,
2525 const VkImageFormatProperties &imageFormatProperties, const VkExtent3D &extent)
2526 {
2527 if (isYCbCrFormat(format))
2528 return 1;
2529 tcu::UVec3 imageAlignment = getImageSizeAlignment(formatDescription);
2530 uint32_t mipmapEdge = std::max(std::max(extent.width, extent.height), extent.depth);
2531 if (imageAlignment.x() > 1)
2532 mipmapEdge = std::min(mipmapEdge, extent.width / imageAlignment.x());
2533 if (imageAlignment.y() > 1)
2534 mipmapEdge = std::min(mipmapEdge, extent.height / imageAlignment.y());
2535 if (imageAlignment.z() > 1)
2536 mipmapEdge = std::min(mipmapEdge, extent.depth / imageAlignment.z());
2537 return std::min(static_cast<uint32_t>(deFloatLog2(static_cast<float>(mipmapEdge))) + 1u,
2538 imageFormatProperties.maxMipLevels);
2539 }
2540
getPlaneSizeInBytes(const PlanarFormatDescription & formatInfo,const VkExtent3D & baseExtents,const uint32_t planeNdx,const uint32_t mipmapLevel,const uint32_t mipmapMemoryAlignment)2541 uint32_t getPlaneSizeInBytes(const PlanarFormatDescription &formatInfo, const VkExtent3D &baseExtents,
2542 const uint32_t planeNdx, const uint32_t mipmapLevel, const uint32_t mipmapMemoryAlignment)
2543 {
2544 VkExtent3D imageExtent = getPlaneExtent(formatInfo, baseExtents, planeNdx, mipmapLevel);
2545 imageExtent.width /= formatInfo.blockWidth;
2546 imageExtent.height /= formatInfo.blockHeight;
2547 return deAlign32(formatInfo.planes[planeNdx].elementSizeBytes * imageExtent.width * imageExtent.height *
2548 imageExtent.depth,
2549 mipmapMemoryAlignment);
2550 }
2551
getPlaneSizeInBytes(const PlanarFormatDescription & formatInfo,const tcu::UVec2 & baseExtents,const uint32_t planeNdx,const uint32_t mipmapLevel,const uint32_t mipmapMemoryAlignment)2552 uint32_t getPlaneSizeInBytes(const PlanarFormatDescription &formatInfo, const tcu::UVec2 &baseExtents,
2553 const uint32_t planeNdx, const uint32_t mipmapLevel, const uint32_t mipmapMemoryAlignment)
2554 {
2555 tcu::UVec2 mipExtents = getPlaneExtent(formatInfo, baseExtents, planeNdx, mipmapLevel) /
2556 tcu::UVec2(formatInfo.blockWidth, formatInfo.blockHeight);
2557 return deAlign32(formatInfo.planes[planeNdx].elementSizeBytes * mipExtents.x() * mipExtents.y(),
2558 mipmapMemoryAlignment);
2559 }
2560
getPlaneExtent(const PlanarFormatDescription & formatInfo,const VkExtent3D & baseExtents,const uint32_t planeNdx,const uint32_t mipmapLevel)2561 VkExtent3D getPlaneExtent(const PlanarFormatDescription &formatInfo, const VkExtent3D &baseExtents,
2562 const uint32_t planeNdx, const uint32_t mipmapLevel)
2563 {
2564 uint32_t widthDivisor = formatInfo.planes[planeNdx].widthDivisor;
2565 uint32_t heightDivisor = formatInfo.planes[planeNdx].heightDivisor;
2566 uint32_t depthDivisor = 1u;
2567 VkExtent3D mip0Extents{baseExtents.width / widthDivisor, baseExtents.height / heightDivisor,
2568 baseExtents.depth / depthDivisor};
2569
2570 return mipLevelExtents(mip0Extents, mipmapLevel);
2571 }
2572
getPlaneExtent(const PlanarFormatDescription & formatInfo,const tcu::UVec2 & baseExtents,const uint32_t planeNdx,const uint32_t mipmapLevel)2573 tcu::UVec2 getPlaneExtent(const PlanarFormatDescription &formatInfo, const tcu::UVec2 &baseExtents,
2574 const uint32_t planeNdx, const uint32_t mipmapLevel)
2575 {
2576 uint32_t widthDivisor = formatInfo.planes[planeNdx].widthDivisor;
2577 uint32_t heightDivisor = formatInfo.planes[planeNdx].heightDivisor;
2578 tcu::UVec2 mip0Extents{baseExtents.x() / widthDivisor, baseExtents.y() / heightDivisor};
2579
2580 return tcu::UVec2{std::max(mip0Extents.x() >> mipmapLevel, 1u), std::max(mip0Extents.y() >> mipmapLevel, 1u)};
2581 }
2582
getImageSizeAlignment(VkFormat format)2583 tcu::UVec3 getImageSizeAlignment(VkFormat format)
2584 {
2585 return getImageSizeAlignment(getPlanarFormatDescription(format));
2586 }
2587
getImageSizeAlignment(const PlanarFormatDescription & formatInfo)2588 tcu::UVec3 getImageSizeAlignment(const PlanarFormatDescription &formatInfo)
2589 {
2590 tcu::UVec3 imgAlignment{formatInfo.blockWidth, formatInfo.blockHeight, 1};
2591 for (uint32_t planeNdx = 0; planeNdx < formatInfo.numPlanes; ++planeNdx)
2592 {
2593 imgAlignment.x() = std::max(imgAlignment.x(), static_cast<uint32_t>(formatInfo.planes[planeNdx].widthDivisor));
2594 imgAlignment.y() = std::max(imgAlignment.y(), static_cast<uint32_t>(formatInfo.planes[planeNdx].heightDivisor));
2595 }
2596 return imgAlignment;
2597 }
2598
getBlockExtent(VkFormat format)2599 tcu::UVec2 getBlockExtent(VkFormat format)
2600 {
2601 return getBlockExtent(getPlanarFormatDescription(format));
2602 }
2603
getBlockExtent(const PlanarFormatDescription & formatInfo)2604 tcu::UVec2 getBlockExtent(const PlanarFormatDescription &formatInfo)
2605 {
2606 return tcu::UVec2{formatInfo.blockWidth, formatInfo.blockHeight};
2607 }
2608
getPlaneCompatibleFormat(VkFormat format,uint32_t planeNdx)2609 VkFormat getPlaneCompatibleFormat(VkFormat format, uint32_t planeNdx)
2610 {
2611 return getPlaneCompatibleFormat(getPlanarFormatDescription(format), planeNdx);
2612 }
2613
getPlaneCompatibleFormat(const PlanarFormatDescription & formatInfo,uint32_t planeNdx)2614 VkFormat getPlaneCompatibleFormat(const PlanarFormatDescription &formatInfo, uint32_t planeNdx)
2615 {
2616 DE_ASSERT(planeNdx < formatInfo.numPlanes);
2617 return formatInfo.planes[planeNdx].planeCompatibleFormat;
2618 }
2619
getPlaneAspect(uint32_t planeNdx)2620 VkImageAspectFlagBits getPlaneAspect(uint32_t planeNdx)
2621 {
2622 DE_ASSERT(de::inBounds(planeNdx, 0u, 3u));
2623 return (VkImageAspectFlagBits)(VK_IMAGE_ASPECT_PLANE_0_BIT << planeNdx);
2624 }
2625
getAspectPlaneNdx(VkImageAspectFlagBits flags)2626 uint32_t getAspectPlaneNdx(VkImageAspectFlagBits flags)
2627 {
2628 switch (flags)
2629 {
2630 case VK_IMAGE_ASPECT_PLANE_0_BIT:
2631 return 0;
2632 case VK_IMAGE_ASPECT_PLANE_1_BIT:
2633 return 1;
2634 case VK_IMAGE_ASPECT_PLANE_2_BIT:
2635 return 2;
2636 default:
2637 DE_FATAL("Invalid plane aspect");
2638 return 0;
2639 }
2640 }
2641
isChromaSubsampled(VkFormat format)2642 bool isChromaSubsampled(VkFormat format)
2643 {
2644 switch (format)
2645 {
2646 case VK_FORMAT_G8B8G8R8_422_UNORM:
2647 case VK_FORMAT_B8G8R8G8_422_UNORM:
2648 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
2649 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
2650 case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
2651 case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
2652 case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
2653 case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
2654 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
2655 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
2656 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
2657 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
2658 case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
2659 case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
2660 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
2661 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
2662 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
2663 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
2664 case VK_FORMAT_G16B16G16R16_422_UNORM:
2665 case VK_FORMAT_B16G16R16G16_422_UNORM:
2666 case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
2667 case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
2668 case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
2669 case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
2670 return true;
2671
2672 default:
2673 return false;
2674 }
2675 }
2676
isSupportedByFramework(VkFormat format)2677 bool isSupportedByFramework(VkFormat format)
2678 {
2679 #ifndef CTS_USES_VULKANSC
2680 if (format == VK_FORMAT_A8_UNORM_KHR || format == VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR)
2681 return true;
2682 #endif // CTS_USES_VULKANSC
2683
2684 if (format == VK_FORMAT_UNDEFINED || format > VK_CORE_FORMAT_LAST)
2685 return false;
2686
2687 switch (format)
2688 {
2689 case VK_FORMAT_R64_UINT:
2690 case VK_FORMAT_R64_SINT:
2691 case VK_FORMAT_R64_SFLOAT:
2692 case VK_FORMAT_R64G64_UINT:
2693 case VK_FORMAT_R64G64_SINT:
2694 case VK_FORMAT_R64G64_SFLOAT:
2695 case VK_FORMAT_R64G64B64_UINT:
2696 case VK_FORMAT_R64G64B64_SINT:
2697 case VK_FORMAT_R64G64B64_SFLOAT:
2698 case VK_FORMAT_R64G64B64A64_UINT:
2699 case VK_FORMAT_R64G64B64A64_SINT:
2700 case VK_FORMAT_R64G64B64A64_SFLOAT:
2701 // \todo [2016-12-01 pyry] Support 64-bit channel types
2702 return false;
2703
2704 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
2705 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
2706 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
2707 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
2708 case VK_FORMAT_BC2_UNORM_BLOCK:
2709 case VK_FORMAT_BC2_SRGB_BLOCK:
2710 case VK_FORMAT_BC3_UNORM_BLOCK:
2711 case VK_FORMAT_BC3_SRGB_BLOCK:
2712 case VK_FORMAT_BC4_UNORM_BLOCK:
2713 case VK_FORMAT_BC4_SNORM_BLOCK:
2714 case VK_FORMAT_BC5_UNORM_BLOCK:
2715 case VK_FORMAT_BC5_SNORM_BLOCK:
2716 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
2717 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
2718 case VK_FORMAT_BC7_UNORM_BLOCK:
2719 case VK_FORMAT_BC7_SRGB_BLOCK:
2720 return false;
2721
2722 default:
2723 return true;
2724 }
2725 }
2726
checkImageSupport(const InstanceInterface & vki,VkPhysicalDevice physicalDevice,const VkImageCreateInfo & imageCreateInfo)2727 void checkImageSupport(const InstanceInterface &vki, VkPhysicalDevice physicalDevice,
2728 const VkImageCreateInfo &imageCreateInfo)
2729 {
2730 VkImageFormatProperties imageFormatProperties;
2731
2732 if (vki.getPhysicalDeviceImageFormatProperties(physicalDevice, imageCreateInfo.format, imageCreateInfo.imageType,
2733 imageCreateInfo.tiling, imageCreateInfo.usage, imageCreateInfo.flags,
2734 &imageFormatProperties))
2735 {
2736 TCU_THROW(NotSupportedError, "Image format not supported.");
2737 }
2738 if (((VkSampleCountFlagBits)imageFormatProperties.sampleCounts & imageCreateInfo.samples) == 0)
2739 {
2740 TCU_THROW(NotSupportedError, "Sample count not supported.");
2741 }
2742 if (imageFormatProperties.maxArrayLayers < imageCreateInfo.arrayLayers)
2743 {
2744 TCU_THROW(NotSupportedError, "Layer count not supported.");
2745 }
2746 }
2747
mapTextureFormat(const tcu::TextureFormat & format)2748 VkFormat mapTextureFormat(const tcu::TextureFormat &format)
2749 {
2750 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST < (1 << 16));
2751 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELTYPE_LAST < (1 << 16));
2752
2753 #define PACK_FMT(ORDER, TYPE) ((int(ORDER) << 16) | int(TYPE))
2754 #define FMT_CASE(ORDER, TYPE) PACK_FMT(tcu::TextureFormat::ORDER, tcu::TextureFormat::TYPE)
2755
2756 // update this mapping if VkFormat changes
2757 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
2758
2759 switch (PACK_FMT(format.order, format.type))
2760 {
2761 case FMT_CASE(RG, UNORM_BYTE_44):
2762 return VK_FORMAT_R4G4_UNORM_PACK8;
2763 case FMT_CASE(RGB, UNORM_SHORT_565):
2764 return VK_FORMAT_R5G6B5_UNORM_PACK16;
2765 case FMT_CASE(RGBA, UNORM_SHORT_4444):
2766 return VK_FORMAT_R4G4B4A4_UNORM_PACK16;
2767 case FMT_CASE(RGBA, UNORM_SHORT_5551):
2768 return VK_FORMAT_R5G5B5A1_UNORM_PACK16;
2769 #ifndef CTS_USES_VULKANSC
2770 case FMT_CASE(ABGR, UNORM_SHORT_1555):
2771 return VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR;
2772 #endif // CTS_USES_VULKANSC
2773
2774 case FMT_CASE(BGR, UNORM_SHORT_565):
2775 return VK_FORMAT_B5G6R5_UNORM_PACK16;
2776 case FMT_CASE(BGRA, UNORM_SHORT_4444):
2777 return VK_FORMAT_B4G4R4A4_UNORM_PACK16;
2778 case FMT_CASE(BGRA, UNORM_SHORT_5551):
2779 return VK_FORMAT_B5G5R5A1_UNORM_PACK16;
2780
2781 case FMT_CASE(ARGB, UNORM_SHORT_1555):
2782 return VK_FORMAT_A1R5G5B5_UNORM_PACK16;
2783
2784 case FMT_CASE(R, UNORM_INT8):
2785 return VK_FORMAT_R8_UNORM;
2786 case FMT_CASE(R, SNORM_INT8):
2787 return VK_FORMAT_R8_SNORM;
2788 case FMT_CASE(R, UNSIGNED_INT8):
2789 return VK_FORMAT_R8_UINT;
2790 case FMT_CASE(R, SIGNED_INT8):
2791 return VK_FORMAT_R8_SINT;
2792 case FMT_CASE(sR, UNORM_INT8):
2793 return VK_FORMAT_R8_SRGB;
2794 #ifndef CTS_USES_VULKANSC
2795 case FMT_CASE(A, UNORM_INT8):
2796 return VK_FORMAT_A8_UNORM_KHR;
2797 #endif // CTS_USES_VULKANSC
2798
2799 case FMT_CASE(RG, UNORM_INT8):
2800 return VK_FORMAT_R8G8_UNORM;
2801 case FMT_CASE(RG, SNORM_INT8):
2802 return VK_FORMAT_R8G8_SNORM;
2803 case FMT_CASE(RG, UNSIGNED_INT8):
2804 return VK_FORMAT_R8G8_UINT;
2805 case FMT_CASE(RG, SIGNED_INT8):
2806 return VK_FORMAT_R8G8_SINT;
2807 case FMT_CASE(sRG, UNORM_INT8):
2808 return VK_FORMAT_R8G8_SRGB;
2809
2810 case FMT_CASE(RGB, UNORM_INT8):
2811 return VK_FORMAT_R8G8B8_UNORM;
2812 case FMT_CASE(RGB, SNORM_INT8):
2813 return VK_FORMAT_R8G8B8_SNORM;
2814 case FMT_CASE(RGB, UNSIGNED_INT8):
2815 return VK_FORMAT_R8G8B8_UINT;
2816 case FMT_CASE(RGB, SIGNED_INT8):
2817 return VK_FORMAT_R8G8B8_SINT;
2818 case FMT_CASE(sRGB, UNORM_INT8):
2819 return VK_FORMAT_R8G8B8_SRGB;
2820
2821 case FMT_CASE(RGBA, UNORM_INT8):
2822 return VK_FORMAT_R8G8B8A8_UNORM;
2823 case FMT_CASE(RGBA, SNORM_INT8):
2824 return VK_FORMAT_R8G8B8A8_SNORM;
2825 case FMT_CASE(RGBA, UNSIGNED_INT8):
2826 return VK_FORMAT_R8G8B8A8_UINT;
2827 case FMT_CASE(RGBA, SIGNED_INT8):
2828 return VK_FORMAT_R8G8B8A8_SINT;
2829 case FMT_CASE(sRGBA, UNORM_INT8):
2830 return VK_FORMAT_R8G8B8A8_SRGB;
2831
2832 case FMT_CASE(RGBA, UNORM_INT_1010102_REV):
2833 return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
2834 case FMT_CASE(RGBA, SNORM_INT_1010102_REV):
2835 return VK_FORMAT_A2B10G10R10_SNORM_PACK32;
2836 case FMT_CASE(RGBA, UNSIGNED_INT_1010102_REV):
2837 return VK_FORMAT_A2B10G10R10_UINT_PACK32;
2838 case FMT_CASE(RGBA, SIGNED_INT_1010102_REV):
2839 return VK_FORMAT_A2B10G10R10_SINT_PACK32;
2840
2841 case FMT_CASE(R, UNORM_INT16):
2842 return VK_FORMAT_R16_UNORM;
2843 case FMT_CASE(R, SNORM_INT16):
2844 return VK_FORMAT_R16_SNORM;
2845 case FMT_CASE(R, UNSIGNED_INT16):
2846 return VK_FORMAT_R16_UINT;
2847 case FMT_CASE(R, SIGNED_INT16):
2848 return VK_FORMAT_R16_SINT;
2849 case FMT_CASE(R, HALF_FLOAT):
2850 return VK_FORMAT_R16_SFLOAT;
2851
2852 case FMT_CASE(RG, UNORM_INT16):
2853 return VK_FORMAT_R16G16_UNORM;
2854 case FMT_CASE(RG, SNORM_INT16):
2855 return VK_FORMAT_R16G16_SNORM;
2856 case FMT_CASE(RG, UNSIGNED_INT16):
2857 return VK_FORMAT_R16G16_UINT;
2858 case FMT_CASE(RG, SIGNED_INT16):
2859 return VK_FORMAT_R16G16_SINT;
2860 case FMT_CASE(RG, HALF_FLOAT):
2861 return VK_FORMAT_R16G16_SFLOAT;
2862
2863 case FMT_CASE(RGB, UNORM_INT16):
2864 return VK_FORMAT_R16G16B16_UNORM;
2865 case FMT_CASE(RGB, SNORM_INT16):
2866 return VK_FORMAT_R16G16B16_SNORM;
2867 case FMT_CASE(RGB, UNSIGNED_INT16):
2868 return VK_FORMAT_R16G16B16_UINT;
2869 case FMT_CASE(RGB, SIGNED_INT16):
2870 return VK_FORMAT_R16G16B16_SINT;
2871 case FMT_CASE(RGB, HALF_FLOAT):
2872 return VK_FORMAT_R16G16B16_SFLOAT;
2873
2874 case FMT_CASE(RGBA, UNORM_INT16):
2875 return VK_FORMAT_R16G16B16A16_UNORM;
2876 case FMT_CASE(RGBA, SNORM_INT16):
2877 return VK_FORMAT_R16G16B16A16_SNORM;
2878 case FMT_CASE(RGBA, UNSIGNED_INT16):
2879 return VK_FORMAT_R16G16B16A16_UINT;
2880 case FMT_CASE(RGBA, SIGNED_INT16):
2881 return VK_FORMAT_R16G16B16A16_SINT;
2882 case FMT_CASE(RGBA, HALF_FLOAT):
2883 return VK_FORMAT_R16G16B16A16_SFLOAT;
2884
2885 case FMT_CASE(R, UNSIGNED_INT32):
2886 return VK_FORMAT_R32_UINT;
2887 case FMT_CASE(R, SIGNED_INT32):
2888 return VK_FORMAT_R32_SINT;
2889 case FMT_CASE(R, UNSIGNED_INT64):
2890 return VK_FORMAT_R64_UINT;
2891 case FMT_CASE(R, SIGNED_INT64):
2892 return VK_FORMAT_R64_SINT;
2893 case FMT_CASE(R, FLOAT):
2894 return VK_FORMAT_R32_SFLOAT;
2895
2896 case FMT_CASE(RG, UNSIGNED_INT32):
2897 return VK_FORMAT_R32G32_UINT;
2898 case FMT_CASE(RG, SIGNED_INT32):
2899 return VK_FORMAT_R32G32_SINT;
2900 case FMT_CASE(RG, FLOAT):
2901 return VK_FORMAT_R32G32_SFLOAT;
2902
2903 case FMT_CASE(RGB, UNSIGNED_INT32):
2904 return VK_FORMAT_R32G32B32_UINT;
2905 case FMT_CASE(RGB, SIGNED_INT32):
2906 return VK_FORMAT_R32G32B32_SINT;
2907 case FMT_CASE(RGB, FLOAT):
2908 return VK_FORMAT_R32G32B32_SFLOAT;
2909
2910 case FMT_CASE(RGBA, UNSIGNED_INT32):
2911 return VK_FORMAT_R32G32B32A32_UINT;
2912 case FMT_CASE(RGBA, SIGNED_INT32):
2913 return VK_FORMAT_R32G32B32A32_SINT;
2914 case FMT_CASE(RGBA, FLOAT):
2915 return VK_FORMAT_R32G32B32A32_SFLOAT;
2916
2917 case FMT_CASE(R, FLOAT64):
2918 return VK_FORMAT_R64_SFLOAT;
2919 case FMT_CASE(RG, FLOAT64):
2920 return VK_FORMAT_R64G64_SFLOAT;
2921 case FMT_CASE(RGB, FLOAT64):
2922 return VK_FORMAT_R64G64B64_SFLOAT;
2923 case FMT_CASE(RGBA, FLOAT64):
2924 return VK_FORMAT_R64G64B64A64_SFLOAT;
2925
2926 case FMT_CASE(RGB, UNSIGNED_INT_11F_11F_10F_REV):
2927 return VK_FORMAT_B10G11R11_UFLOAT_PACK32;
2928 case FMT_CASE(RGB, UNSIGNED_INT_999_E5_REV):
2929 return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
2930
2931 case FMT_CASE(BGR, UNORM_INT8):
2932 return VK_FORMAT_B8G8R8_UNORM;
2933 case FMT_CASE(BGR, SNORM_INT8):
2934 return VK_FORMAT_B8G8R8_SNORM;
2935 case FMT_CASE(BGR, UNSIGNED_INT8):
2936 return VK_FORMAT_B8G8R8_UINT;
2937 case FMT_CASE(BGR, SIGNED_INT8):
2938 return VK_FORMAT_B8G8R8_SINT;
2939 case FMT_CASE(BGR, USCALED_INT8):
2940 return VK_FORMAT_B8G8R8_USCALED;
2941 case FMT_CASE(BGR, SSCALED_INT8):
2942 return VK_FORMAT_B8G8R8_SSCALED;
2943 case FMT_CASE(sBGR, UNORM_INT8):
2944 return VK_FORMAT_B8G8R8_SRGB;
2945
2946 case FMT_CASE(BGRA, UNORM_INT8):
2947 return VK_FORMAT_B8G8R8A8_UNORM;
2948 case FMT_CASE(BGRA, SNORM_INT8):
2949 return VK_FORMAT_B8G8R8A8_SNORM;
2950 case FMT_CASE(BGRA, UNSIGNED_INT8):
2951 return VK_FORMAT_B8G8R8A8_UINT;
2952 case FMT_CASE(BGRA, SIGNED_INT8):
2953 return VK_FORMAT_B8G8R8A8_SINT;
2954 case FMT_CASE(BGRA, USCALED_INT8):
2955 return VK_FORMAT_B8G8R8A8_USCALED;
2956 case FMT_CASE(BGRA, SSCALED_INT8):
2957 return VK_FORMAT_B8G8R8A8_SSCALED;
2958 case FMT_CASE(sBGRA, UNORM_INT8):
2959 return VK_FORMAT_B8G8R8A8_SRGB;
2960
2961 case FMT_CASE(BGRA, UNORM_INT_1010102_REV):
2962 return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
2963 case FMT_CASE(BGRA, SNORM_INT_1010102_REV):
2964 return VK_FORMAT_A2R10G10B10_SNORM_PACK32;
2965 case FMT_CASE(BGRA, UNSIGNED_INT_1010102_REV):
2966 return VK_FORMAT_A2R10G10B10_UINT_PACK32;
2967 case FMT_CASE(BGRA, SIGNED_INT_1010102_REV):
2968 return VK_FORMAT_A2R10G10B10_SINT_PACK32;
2969
2970 case FMT_CASE(D, UNORM_INT16):
2971 return VK_FORMAT_D16_UNORM;
2972 case FMT_CASE(D, UNSIGNED_INT_24_8_REV):
2973 return VK_FORMAT_X8_D24_UNORM_PACK32;
2974 case FMT_CASE(D, FLOAT):
2975 return VK_FORMAT_D32_SFLOAT;
2976 case FMT_CASE(D, UNORM_INT24):
2977 return VK_FORMAT_D24_UNORM_S8_UINT;
2978
2979 case FMT_CASE(S, UNSIGNED_INT8):
2980 return VK_FORMAT_S8_UINT;
2981
2982 case FMT_CASE(DS, UNSIGNED_INT_16_8_8):
2983 return VK_FORMAT_D16_UNORM_S8_UINT;
2984 case FMT_CASE(DS, UNSIGNED_INT_24_8_REV):
2985 return VK_FORMAT_D24_UNORM_S8_UINT;
2986 case FMT_CASE(DS, FLOAT_UNSIGNED_INT_24_8_REV):
2987 return VK_FORMAT_D32_SFLOAT_S8_UINT;
2988
2989 case FMT_CASE(R, UNORM_SHORT_10):
2990 return VK_FORMAT_R10X6_UNORM_PACK16;
2991 case FMT_CASE(RG, UNORM_SHORT_10):
2992 return VK_FORMAT_R10X6G10X6_UNORM_2PACK16;
2993 case FMT_CASE(RGBA, UNORM_SHORT_10):
2994 return VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16;
2995
2996 case FMT_CASE(R, UNORM_SHORT_12):
2997 return VK_FORMAT_R12X4_UNORM_PACK16;
2998 case FMT_CASE(RG, UNORM_SHORT_12):
2999 return VK_FORMAT_R12X4G12X4_UNORM_2PACK16;
3000 case FMT_CASE(RGBA, UNORM_SHORT_12):
3001 return VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16;
3002
3003 case FMT_CASE(R, USCALED_INT8):
3004 return VK_FORMAT_R8_USCALED;
3005 case FMT_CASE(RG, USCALED_INT8):
3006 return VK_FORMAT_R8G8_USCALED;
3007 case FMT_CASE(RGB, USCALED_INT8):
3008 return VK_FORMAT_R8G8B8_USCALED;
3009 case FMT_CASE(RGBA, USCALED_INT8):
3010 return VK_FORMAT_R8G8B8A8_USCALED;
3011
3012 case FMT_CASE(R, USCALED_INT16):
3013 return VK_FORMAT_R16_USCALED;
3014 case FMT_CASE(RG, USCALED_INT16):
3015 return VK_FORMAT_R16G16_USCALED;
3016 case FMT_CASE(RGB, USCALED_INT16):
3017 return VK_FORMAT_R16G16B16_USCALED;
3018 case FMT_CASE(RGBA, USCALED_INT16):
3019 return VK_FORMAT_R16G16B16A16_USCALED;
3020
3021 case FMT_CASE(R, SSCALED_INT8):
3022 return VK_FORMAT_R8_SSCALED;
3023 case FMT_CASE(RG, SSCALED_INT8):
3024 return VK_FORMAT_R8G8_SSCALED;
3025 case FMT_CASE(RGB, SSCALED_INT8):
3026 return VK_FORMAT_R8G8B8_SSCALED;
3027 case FMT_CASE(RGBA, SSCALED_INT8):
3028 return VK_FORMAT_R8G8B8A8_SSCALED;
3029
3030 case FMT_CASE(R, SSCALED_INT16):
3031 return VK_FORMAT_R16_SSCALED;
3032 case FMT_CASE(RG, SSCALED_INT16):
3033 return VK_FORMAT_R16G16_SSCALED;
3034 case FMT_CASE(RGB, SSCALED_INT16):
3035 return VK_FORMAT_R16G16B16_SSCALED;
3036 case FMT_CASE(RGBA, SSCALED_INT16):
3037 return VK_FORMAT_R16G16B16A16_SSCALED;
3038
3039 case FMT_CASE(RGBA, USCALED_INT_1010102_REV):
3040 return VK_FORMAT_A2B10G10R10_USCALED_PACK32;
3041 case FMT_CASE(RGBA, SSCALED_INT_1010102_REV):
3042 return VK_FORMAT_A2B10G10R10_SSCALED_PACK32;
3043
3044 case FMT_CASE(BGRA, USCALED_INT_1010102_REV):
3045 return VK_FORMAT_A2R10G10B10_USCALED_PACK32;
3046 case FMT_CASE(BGRA, SSCALED_INT_1010102_REV):
3047 return VK_FORMAT_A2R10G10B10_SSCALED_PACK32;
3048
3049 case FMT_CASE(ARGB, UNORM_SHORT_4444):
3050 return VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT;
3051 case FMT_CASE(ABGR, UNORM_SHORT_4444):
3052 return VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT;
3053
3054 default:
3055 TCU_THROW(InternalError, "Unknown texture format");
3056 }
3057
3058 #undef PACK_FMT
3059 #undef FMT_CASE
3060 }
3061
mapCompressedTextureFormat(const tcu::CompressedTexFormat format)3062 VkFormat mapCompressedTextureFormat(const tcu::CompressedTexFormat format)
3063 {
3064 // update this mapping if CompressedTexFormat changes
3065 // 55 needed for Vulkan and 2 for AHB that won't have mapping here
3066 DE_STATIC_ASSERT(tcu::COMPRESSEDTEXFORMAT_LAST == 57);
3067
3068 switch (format)
3069 {
3070 case tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8:
3071 return VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
3072 case tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8:
3073 return VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK;
3074 case tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
3075 return VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK;
3076 case tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
3077 return VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK;
3078 case tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8:
3079 return VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
3080 case tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8:
3081 return VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK;
3082
3083 case tcu::COMPRESSEDTEXFORMAT_EAC_R11:
3084 return VK_FORMAT_EAC_R11_UNORM_BLOCK;
3085 case tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_R11:
3086 return VK_FORMAT_EAC_R11_SNORM_BLOCK;
3087 case tcu::COMPRESSEDTEXFORMAT_EAC_RG11:
3088 return VK_FORMAT_EAC_R11G11_UNORM_BLOCK;
3089 case tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11:
3090 return VK_FORMAT_EAC_R11G11_SNORM_BLOCK;
3091
3092 case tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_RGBA:
3093 return VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
3094 case tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_SRGB8_ALPHA8:
3095 return VK_FORMAT_ASTC_4x4_SRGB_BLOCK;
3096 case tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_RGBA:
3097 return VK_FORMAT_ASTC_5x4_UNORM_BLOCK;
3098 case tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_SRGB8_ALPHA8:
3099 return VK_FORMAT_ASTC_5x4_SRGB_BLOCK;
3100 case tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_RGBA:
3101 return VK_FORMAT_ASTC_5x5_UNORM_BLOCK;
3102 case tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8:
3103 return VK_FORMAT_ASTC_5x5_SRGB_BLOCK;
3104 case tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_RGBA:
3105 return VK_FORMAT_ASTC_6x5_UNORM_BLOCK;
3106 case tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_SRGB8_ALPHA8:
3107 return VK_FORMAT_ASTC_6x5_SRGB_BLOCK;
3108 case tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_RGBA:
3109 return VK_FORMAT_ASTC_6x6_UNORM_BLOCK;
3110 case tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_SRGB8_ALPHA8:
3111 return VK_FORMAT_ASTC_6x6_SRGB_BLOCK;
3112 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_RGBA:
3113 return VK_FORMAT_ASTC_8x5_UNORM_BLOCK;
3114 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_SRGB8_ALPHA8:
3115 return VK_FORMAT_ASTC_8x5_SRGB_BLOCK;
3116 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_RGBA:
3117 return VK_FORMAT_ASTC_8x6_UNORM_BLOCK;
3118 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8:
3119 return VK_FORMAT_ASTC_8x6_SRGB_BLOCK;
3120 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_RGBA:
3121 return VK_FORMAT_ASTC_8x8_UNORM_BLOCK;
3122 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_SRGB8_ALPHA8:
3123 return VK_FORMAT_ASTC_8x8_SRGB_BLOCK;
3124 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_RGBA:
3125 return VK_FORMAT_ASTC_10x5_UNORM_BLOCK;
3126 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_SRGB8_ALPHA8:
3127 return VK_FORMAT_ASTC_10x5_SRGB_BLOCK;
3128 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_RGBA:
3129 return VK_FORMAT_ASTC_10x6_UNORM_BLOCK;
3130 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_SRGB8_ALPHA8:
3131 return VK_FORMAT_ASTC_10x6_SRGB_BLOCK;
3132 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_RGBA:
3133 return VK_FORMAT_ASTC_10x8_UNORM_BLOCK;
3134 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_SRGB8_ALPHA8:
3135 return VK_FORMAT_ASTC_10x8_SRGB_BLOCK;
3136 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_RGBA:
3137 return VK_FORMAT_ASTC_10x10_UNORM_BLOCK;
3138 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_SRGB8_ALPHA8:
3139 return VK_FORMAT_ASTC_10x10_SRGB_BLOCK;
3140 case tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_RGBA:
3141 return VK_FORMAT_ASTC_12x10_UNORM_BLOCK;
3142 case tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_SRGB8_ALPHA8:
3143 return VK_FORMAT_ASTC_12x10_SRGB_BLOCK;
3144 case tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_RGBA:
3145 return VK_FORMAT_ASTC_12x12_UNORM_BLOCK;
3146 case tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_SRGB8_ALPHA8:
3147 return VK_FORMAT_ASTC_12x12_SRGB_BLOCK;
3148
3149 case tcu::COMPRESSEDTEXFORMAT_BC1_RGB_UNORM_BLOCK:
3150 return VK_FORMAT_BC1_RGB_UNORM_BLOCK;
3151 case tcu::COMPRESSEDTEXFORMAT_BC1_RGB_SRGB_BLOCK:
3152 return VK_FORMAT_BC1_RGB_SRGB_BLOCK;
3153 case tcu::COMPRESSEDTEXFORMAT_BC1_RGBA_UNORM_BLOCK:
3154 return VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
3155 case tcu::COMPRESSEDTEXFORMAT_BC1_RGBA_SRGB_BLOCK:
3156 return VK_FORMAT_BC1_RGBA_SRGB_BLOCK;
3157 case tcu::COMPRESSEDTEXFORMAT_BC2_UNORM_BLOCK:
3158 return VK_FORMAT_BC2_UNORM_BLOCK;
3159 case tcu::COMPRESSEDTEXFORMAT_BC2_SRGB_BLOCK:
3160 return VK_FORMAT_BC2_SRGB_BLOCK;
3161 case tcu::COMPRESSEDTEXFORMAT_BC3_UNORM_BLOCK:
3162 return VK_FORMAT_BC3_UNORM_BLOCK;
3163 case tcu::COMPRESSEDTEXFORMAT_BC3_SRGB_BLOCK:
3164 return VK_FORMAT_BC3_SRGB_BLOCK;
3165 case tcu::COMPRESSEDTEXFORMAT_BC4_UNORM_BLOCK:
3166 return VK_FORMAT_BC4_UNORM_BLOCK;
3167 case tcu::COMPRESSEDTEXFORMAT_BC4_SNORM_BLOCK:
3168 return VK_FORMAT_BC4_SNORM_BLOCK;
3169 case tcu::COMPRESSEDTEXFORMAT_BC5_UNORM_BLOCK:
3170 return VK_FORMAT_BC5_UNORM_BLOCK;
3171 case tcu::COMPRESSEDTEXFORMAT_BC5_SNORM_BLOCK:
3172 return VK_FORMAT_BC5_SNORM_BLOCK;
3173 case tcu::COMPRESSEDTEXFORMAT_BC6H_UFLOAT_BLOCK:
3174 return VK_FORMAT_BC6H_UFLOAT_BLOCK;
3175 case tcu::COMPRESSEDTEXFORMAT_BC6H_SFLOAT_BLOCK:
3176 return VK_FORMAT_BC6H_SFLOAT_BLOCK;
3177 case tcu::COMPRESSEDTEXFORMAT_BC7_UNORM_BLOCK:
3178 return VK_FORMAT_BC7_UNORM_BLOCK;
3179 case tcu::COMPRESSEDTEXFORMAT_BC7_SRGB_BLOCK:
3180 return VK_FORMAT_BC7_SRGB_BLOCK;
3181
3182 default:
3183 TCU_THROW(InternalError, "Unknown texture format");
3184 return VK_FORMAT_UNDEFINED;
3185 }
3186 }
3187
mapVkFormat(VkFormat format)3188 tcu::TextureFormat mapVkFormat(VkFormat format)
3189 {
3190 using tcu::TextureFormat;
3191
3192 // update this mapping if VkFormat changes
3193 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
3194
3195 switch (format)
3196 {
3197 case VK_FORMAT_R4G4_UNORM_PACK8:
3198 return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_BYTE_44);
3199 case VK_FORMAT_R5G6B5_UNORM_PACK16:
3200 return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_SHORT_565);
3201 case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
3202 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_4444);
3203 case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
3204 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_5551);
3205
3206 case VK_FORMAT_B5G6R5_UNORM_PACK16:
3207 return TextureFormat(TextureFormat::BGR, TextureFormat::UNORM_SHORT_565);
3208 case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
3209 return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_SHORT_4444);
3210 case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
3211 return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_SHORT_5551);
3212
3213 case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
3214 return TextureFormat(TextureFormat::ARGB, TextureFormat::UNORM_SHORT_1555);
3215 #ifndef CTS_USES_VULKANSC
3216 case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR:
3217 return TextureFormat(TextureFormat::ABGR, TextureFormat::UNORM_SHORT_1555);
3218 #endif // CTS_USES_VULKANSC
3219
3220 case VK_FORMAT_R8_UNORM:
3221 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT8);
3222 case VK_FORMAT_R8_SNORM:
3223 return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT8);
3224 case VK_FORMAT_R8_USCALED:
3225 return TextureFormat(TextureFormat::R, TextureFormat::USCALED_INT8);
3226 case VK_FORMAT_R8_SSCALED:
3227 return TextureFormat(TextureFormat::R, TextureFormat::SSCALED_INT8);
3228 case VK_FORMAT_R8_UINT:
3229 return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT8);
3230 case VK_FORMAT_R8_SINT:
3231 return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT8);
3232 case VK_FORMAT_R8_SRGB:
3233 return TextureFormat(TextureFormat::sR, TextureFormat::UNORM_INT8);
3234 #ifndef CTS_USES_VULKANSC
3235 case VK_FORMAT_A8_UNORM_KHR:
3236 return TextureFormat(TextureFormat::A, TextureFormat::UNORM_INT8);
3237 #endif // CTS_USES_VULKANSC
3238
3239 case VK_FORMAT_R8G8_UNORM:
3240 return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT8);
3241 case VK_FORMAT_R8G8_SNORM:
3242 return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT8);
3243 case VK_FORMAT_R8G8_USCALED:
3244 return TextureFormat(TextureFormat::RG, TextureFormat::USCALED_INT8);
3245 case VK_FORMAT_R8G8_SSCALED:
3246 return TextureFormat(TextureFormat::RG, TextureFormat::SSCALED_INT8);
3247 case VK_FORMAT_R8G8_UINT:
3248 return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT8);
3249 case VK_FORMAT_R8G8_SINT:
3250 return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT8);
3251 case VK_FORMAT_R8G8_SRGB:
3252 return TextureFormat(TextureFormat::sRG, TextureFormat::UNORM_INT8);
3253
3254 case VK_FORMAT_R8G8B8_UNORM:
3255 return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8);
3256 case VK_FORMAT_R8G8B8_SNORM:
3257 return TextureFormat(TextureFormat::RGB, TextureFormat::SNORM_INT8);
3258 case VK_FORMAT_R8G8B8_USCALED:
3259 return TextureFormat(TextureFormat::RGB, TextureFormat::USCALED_INT8);
3260 case VK_FORMAT_R8G8B8_SSCALED:
3261 return TextureFormat(TextureFormat::RGB, TextureFormat::SSCALED_INT8);
3262 case VK_FORMAT_R8G8B8_UINT:
3263 return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT8);
3264 case VK_FORMAT_R8G8B8_SINT:
3265 return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT8);
3266 case VK_FORMAT_R8G8B8_SRGB:
3267 return TextureFormat(TextureFormat::sRGB, TextureFormat::UNORM_INT8);
3268
3269 case VK_FORMAT_R8G8B8A8_UNORM:
3270 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
3271 case VK_FORMAT_R8G8B8A8_SNORM:
3272 return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT8);
3273 case VK_FORMAT_R8G8B8A8_USCALED:
3274 return TextureFormat(TextureFormat::RGBA, TextureFormat::USCALED_INT8);
3275 case VK_FORMAT_R8G8B8A8_SSCALED:
3276 return TextureFormat(TextureFormat::RGBA, TextureFormat::SSCALED_INT8);
3277 case VK_FORMAT_R8G8B8A8_UINT:
3278 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8);
3279 case VK_FORMAT_R8G8B8A8_SINT:
3280 return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8);
3281 case VK_FORMAT_R8G8B8A8_SRGB:
3282 return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8);
3283
3284 case VK_FORMAT_R16_UNORM:
3285 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT16);
3286 case VK_FORMAT_R16_SNORM:
3287 return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT16);
3288 case VK_FORMAT_R16_USCALED:
3289 return TextureFormat(TextureFormat::R, TextureFormat::USCALED_INT16);
3290 case VK_FORMAT_R16_SSCALED:
3291 return TextureFormat(TextureFormat::R, TextureFormat::SSCALED_INT16);
3292 case VK_FORMAT_R16_UINT:
3293 return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT16);
3294 case VK_FORMAT_R16_SINT:
3295 return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT16);
3296 case VK_FORMAT_R16_SFLOAT:
3297 return TextureFormat(TextureFormat::R, TextureFormat::HALF_FLOAT);
3298
3299 case VK_FORMAT_R16G16_UNORM:
3300 return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT16);
3301 case VK_FORMAT_R16G16_SNORM:
3302 return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT16);
3303 case VK_FORMAT_R16G16_USCALED:
3304 return TextureFormat(TextureFormat::RG, TextureFormat::USCALED_INT16);
3305 case VK_FORMAT_R16G16_SSCALED:
3306 return TextureFormat(TextureFormat::RG, TextureFormat::SSCALED_INT16);
3307 case VK_FORMAT_R16G16_UINT:
3308 return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT16);
3309 case VK_FORMAT_R16G16_SINT:
3310 return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT16);
3311 case VK_FORMAT_R16G16_SFLOAT:
3312 return TextureFormat(TextureFormat::RG, TextureFormat::HALF_FLOAT);
3313
3314 case VK_FORMAT_R16G16B16_UNORM:
3315 return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT16);
3316 case VK_FORMAT_R16G16B16_SNORM:
3317 return TextureFormat(TextureFormat::RGB, TextureFormat::SNORM_INT16);
3318 case VK_FORMAT_R16G16B16_USCALED:
3319 return TextureFormat(TextureFormat::RGB, TextureFormat::USCALED_INT16);
3320 case VK_FORMAT_R16G16B16_SSCALED:
3321 return TextureFormat(TextureFormat::RGB, TextureFormat::SSCALED_INT16);
3322 case VK_FORMAT_R16G16B16_UINT:
3323 return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT16);
3324 case VK_FORMAT_R16G16B16_SINT:
3325 return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT16);
3326 case VK_FORMAT_R16G16B16_SFLOAT:
3327 return TextureFormat(TextureFormat::RGB, TextureFormat::HALF_FLOAT);
3328
3329 case VK_FORMAT_R16G16B16A16_UNORM:
3330 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT16);
3331 case VK_FORMAT_R16G16B16A16_SNORM:
3332 return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT16);
3333 case VK_FORMAT_R16G16B16A16_USCALED:
3334 return TextureFormat(TextureFormat::RGBA, TextureFormat::USCALED_INT16);
3335 case VK_FORMAT_R16G16B16A16_SSCALED:
3336 return TextureFormat(TextureFormat::RGBA, TextureFormat::SSCALED_INT16);
3337 case VK_FORMAT_R16G16B16A16_UINT:
3338 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT16);
3339 case VK_FORMAT_R16G16B16A16_SINT:
3340 return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT16);
3341 case VK_FORMAT_R16G16B16A16_SFLOAT:
3342 return TextureFormat(TextureFormat::RGBA, TextureFormat::HALF_FLOAT);
3343
3344 case VK_FORMAT_R32_UINT:
3345 return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT32);
3346 case VK_FORMAT_R32_SINT:
3347 return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT32);
3348 case VK_FORMAT_R32_SFLOAT:
3349 return TextureFormat(TextureFormat::R, TextureFormat::FLOAT);
3350
3351 case VK_FORMAT_R32G32_UINT:
3352 return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT32);
3353 case VK_FORMAT_R32G32_SINT:
3354 return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT32);
3355 case VK_FORMAT_R32G32_SFLOAT:
3356 return TextureFormat(TextureFormat::RG, TextureFormat::FLOAT);
3357
3358 case VK_FORMAT_R32G32B32_UINT:
3359 return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT32);
3360 case VK_FORMAT_R32G32B32_SINT:
3361 return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT32);
3362 case VK_FORMAT_R32G32B32_SFLOAT:
3363 return TextureFormat(TextureFormat::RGB, TextureFormat::FLOAT);
3364
3365 case VK_FORMAT_R32G32B32A32_UINT:
3366 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32);
3367 case VK_FORMAT_R32G32B32A32_SINT:
3368 return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT32);
3369 case VK_FORMAT_R32G32B32A32_SFLOAT:
3370 return TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT);
3371
3372 case VK_FORMAT_R64_UINT:
3373 return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT64);
3374 case VK_FORMAT_R64G64_UINT:
3375 return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT64);
3376 case VK_FORMAT_R64G64B64_UINT:
3377 return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT64);
3378 case VK_FORMAT_R64G64B64A64_UINT:
3379 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT64);
3380 case VK_FORMAT_R64_SINT:
3381 return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT64);
3382 case VK_FORMAT_R64G64_SINT:
3383 return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT64);
3384 case VK_FORMAT_R64G64B64_SINT:
3385 return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT64);
3386 case VK_FORMAT_R64G64B64A64_SINT:
3387 return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT64);
3388 case VK_FORMAT_R64_SFLOAT:
3389 return TextureFormat(TextureFormat::R, TextureFormat::FLOAT64);
3390 case VK_FORMAT_R64G64_SFLOAT:
3391 return TextureFormat(TextureFormat::RG, TextureFormat::FLOAT64);
3392 case VK_FORMAT_R64G64B64_SFLOAT:
3393 return TextureFormat(TextureFormat::RGB, TextureFormat::FLOAT64);
3394 case VK_FORMAT_R64G64B64A64_SFLOAT:
3395 return TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT64);
3396
3397 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
3398 return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT_11F_11F_10F_REV);
3399 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
3400 return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT_999_E5_REV);
3401
3402 case VK_FORMAT_B8G8R8_UNORM:
3403 return TextureFormat(TextureFormat::BGR, TextureFormat::UNORM_INT8);
3404 case VK_FORMAT_B8G8R8_SNORM:
3405 return TextureFormat(TextureFormat::BGR, TextureFormat::SNORM_INT8);
3406 case VK_FORMAT_B8G8R8_USCALED:
3407 return TextureFormat(TextureFormat::BGR, TextureFormat::USCALED_INT8);
3408 case VK_FORMAT_B8G8R8_SSCALED:
3409 return TextureFormat(TextureFormat::BGR, TextureFormat::SSCALED_INT8);
3410 case VK_FORMAT_B8G8R8_UINT:
3411 return TextureFormat(TextureFormat::BGR, TextureFormat::UNSIGNED_INT8);
3412 case VK_FORMAT_B8G8R8_SINT:
3413 return TextureFormat(TextureFormat::BGR, TextureFormat::SIGNED_INT8);
3414 case VK_FORMAT_B8G8R8_SRGB:
3415 return TextureFormat(TextureFormat::sBGR, TextureFormat::UNORM_INT8);
3416
3417 case VK_FORMAT_B8G8R8A8_UNORM:
3418 return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_INT8);
3419 case VK_FORMAT_B8G8R8A8_SNORM:
3420 return TextureFormat(TextureFormat::BGRA, TextureFormat::SNORM_INT8);
3421 case VK_FORMAT_B8G8R8A8_USCALED:
3422 return TextureFormat(TextureFormat::BGRA, TextureFormat::USCALED_INT8);
3423 case VK_FORMAT_B8G8R8A8_SSCALED:
3424 return TextureFormat(TextureFormat::BGRA, TextureFormat::SSCALED_INT8);
3425 case VK_FORMAT_B8G8R8A8_UINT:
3426 return TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT8);
3427 case VK_FORMAT_B8G8R8A8_SINT:
3428 return TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT8);
3429 case VK_FORMAT_B8G8R8A8_SRGB:
3430 return TextureFormat(TextureFormat::sBGRA, TextureFormat::UNORM_INT8);
3431
3432 case VK_FORMAT_D16_UNORM:
3433 return TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT16);
3434 case VK_FORMAT_X8_D24_UNORM_PACK32:
3435 return TextureFormat(TextureFormat::D, TextureFormat::UNSIGNED_INT_24_8_REV);
3436 case VK_FORMAT_D32_SFLOAT:
3437 return TextureFormat(TextureFormat::D, TextureFormat::FLOAT);
3438
3439 case VK_FORMAT_S8_UINT:
3440 return TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8);
3441
3442 // \note There is no standard interleaved memory layout for DS formats; buffer-image copies
3443 // will always operate on either D or S aspect only. See Khronos bug 12998
3444 case VK_FORMAT_D16_UNORM_S8_UINT:
3445 return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_16_8_8);
3446 case VK_FORMAT_D24_UNORM_S8_UINT:
3447 return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_24_8_REV);
3448 case VK_FORMAT_D32_SFLOAT_S8_UINT:
3449 return TextureFormat(TextureFormat::DS, TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV);
3450
3451 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN)
3452 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
3453 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
3454 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
3455 return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT8);
3456 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
3457 return TextureFormat(TextureFormat::RGBA, TextureFormat::USCALED_INT8);
3458 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
3459 return TextureFormat(TextureFormat::RGBA, TextureFormat::SSCALED_INT8);
3460 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
3461 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8);
3462 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
3463 return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8);
3464 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
3465 return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8);
3466 #else
3467 #error "Big-endian not supported"
3468 #endif
3469
3470 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
3471 return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_INT_1010102_REV);
3472 case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
3473 return TextureFormat(TextureFormat::BGRA, TextureFormat::SNORM_INT_1010102_REV);
3474 case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
3475 return TextureFormat(TextureFormat::BGRA, TextureFormat::USCALED_INT_1010102_REV);
3476 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
3477 return TextureFormat(TextureFormat::BGRA, TextureFormat::SSCALED_INT_1010102_REV);
3478 case VK_FORMAT_A2R10G10B10_UINT_PACK32:
3479 return TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT_1010102_REV);
3480 case VK_FORMAT_A2R10G10B10_SINT_PACK32:
3481 return TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT_1010102_REV);
3482
3483 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
3484 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT_1010102_REV);
3485 case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
3486 return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT_1010102_REV);
3487 case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
3488 return TextureFormat(TextureFormat::RGBA, TextureFormat::USCALED_INT_1010102_REV);
3489 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
3490 return TextureFormat(TextureFormat::RGBA, TextureFormat::SSCALED_INT_1010102_REV);
3491 case VK_FORMAT_A2B10G10R10_UINT_PACK32:
3492 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT_1010102_REV);
3493 case VK_FORMAT_A2B10G10R10_SINT_PACK32:
3494 return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT_1010102_REV);
3495
3496 // YCbCr formats that can be mapped
3497 case VK_FORMAT_R10X6_UNORM_PACK16:
3498 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_10);
3499 case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
3500 return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_SHORT_10);
3501 case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
3502 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_10);
3503
3504 case VK_FORMAT_R12X4_UNORM_PACK16:
3505 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_12);
3506 case VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
3507 return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_SHORT_12);
3508 case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
3509 return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_12);
3510
3511 case VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT:
3512 return TextureFormat(TextureFormat::ARGB, TextureFormat::UNORM_SHORT_4444);
3513 case VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT:
3514 return TextureFormat(TextureFormat::ABGR, TextureFormat::UNORM_SHORT_4444);
3515
3516 default:
3517 TCU_THROW(InternalError, "Unknown image format");
3518 }
3519 }
3520
mapVkCompressedFormat(VkFormat format)3521 tcu::CompressedTexFormat mapVkCompressedFormat(VkFormat format)
3522 {
3523 // update this mapping if VkFormat changes
3524 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
3525
3526 switch (format)
3527 {
3528 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
3529 return tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8;
3530 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
3531 return tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8;
3532 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
3533 return tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1;
3534 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
3535 return tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1;
3536 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
3537 return tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8;
3538 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
3539 return tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8;
3540
3541 case VK_FORMAT_EAC_R11_UNORM_BLOCK:
3542 return tcu::COMPRESSEDTEXFORMAT_EAC_R11;
3543 case VK_FORMAT_EAC_R11_SNORM_BLOCK:
3544 return tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_R11;
3545 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
3546 return tcu::COMPRESSEDTEXFORMAT_EAC_RG11;
3547 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
3548 return tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11;
3549
3550 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
3551 return tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_RGBA;
3552 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
3553 return tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_SRGB8_ALPHA8;
3554 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
3555 return tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_RGBA;
3556 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
3557 return tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_SRGB8_ALPHA8;
3558 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
3559 return tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_RGBA;
3560 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
3561 return tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8;
3562 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
3563 return tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_RGBA;
3564 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
3565 return tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_SRGB8_ALPHA8;
3566 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
3567 return tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_RGBA;
3568 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
3569 return tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_SRGB8_ALPHA8;
3570 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
3571 return tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_RGBA;
3572 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
3573 return tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_SRGB8_ALPHA8;
3574 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
3575 return tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_RGBA;
3576 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
3577 return tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8;
3578 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
3579 return tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_RGBA;
3580 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
3581 return tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_SRGB8_ALPHA8;
3582 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
3583 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_RGBA;
3584 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
3585 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_SRGB8_ALPHA8;
3586 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
3587 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_RGBA;
3588 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
3589 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_SRGB8_ALPHA8;
3590 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
3591 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_RGBA;
3592 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
3593 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_SRGB8_ALPHA8;
3594 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
3595 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_RGBA;
3596 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
3597 return tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_SRGB8_ALPHA8;
3598 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
3599 return tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_RGBA;
3600 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
3601 return tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_SRGB8_ALPHA8;
3602 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
3603 return tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_RGBA;
3604 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
3605 return tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_SRGB8_ALPHA8;
3606
3607 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
3608 return tcu::COMPRESSEDTEXFORMAT_BC1_RGB_UNORM_BLOCK;
3609 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
3610 return tcu::COMPRESSEDTEXFORMAT_BC1_RGB_SRGB_BLOCK;
3611 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
3612 return tcu::COMPRESSEDTEXFORMAT_BC1_RGBA_UNORM_BLOCK;
3613 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
3614 return tcu::COMPRESSEDTEXFORMAT_BC1_RGBA_SRGB_BLOCK;
3615 case VK_FORMAT_BC2_UNORM_BLOCK:
3616 return tcu::COMPRESSEDTEXFORMAT_BC2_UNORM_BLOCK;
3617 case VK_FORMAT_BC2_SRGB_BLOCK:
3618 return tcu::COMPRESSEDTEXFORMAT_BC2_SRGB_BLOCK;
3619 case VK_FORMAT_BC3_UNORM_BLOCK:
3620 return tcu::COMPRESSEDTEXFORMAT_BC3_UNORM_BLOCK;
3621 case VK_FORMAT_BC3_SRGB_BLOCK:
3622 return tcu::COMPRESSEDTEXFORMAT_BC3_SRGB_BLOCK;
3623 case VK_FORMAT_BC4_UNORM_BLOCK:
3624 return tcu::COMPRESSEDTEXFORMAT_BC4_UNORM_BLOCK;
3625 case VK_FORMAT_BC4_SNORM_BLOCK:
3626 return tcu::COMPRESSEDTEXFORMAT_BC4_SNORM_BLOCK;
3627 case VK_FORMAT_BC5_UNORM_BLOCK:
3628 return tcu::COMPRESSEDTEXFORMAT_BC5_UNORM_BLOCK;
3629 case VK_FORMAT_BC5_SNORM_BLOCK:
3630 return tcu::COMPRESSEDTEXFORMAT_BC5_SNORM_BLOCK;
3631 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
3632 return tcu::COMPRESSEDTEXFORMAT_BC6H_UFLOAT_BLOCK;
3633 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
3634 return tcu::COMPRESSEDTEXFORMAT_BC6H_SFLOAT_BLOCK;
3635 case VK_FORMAT_BC7_UNORM_BLOCK:
3636 return tcu::COMPRESSEDTEXFORMAT_BC7_UNORM_BLOCK;
3637 case VK_FORMAT_BC7_SRGB_BLOCK:
3638 return tcu::COMPRESSEDTEXFORMAT_BC7_SRGB_BLOCK;
3639
3640 default:
3641 TCU_THROW(InternalError, "Unknown image format");
3642 return tcu::COMPRESSEDTEXFORMAT_LAST;
3643 }
3644 }
3645
fullTextureFormatRoundTripSupported(VkFormat format)3646 static bool fullTextureFormatRoundTripSupported(VkFormat format)
3647 {
3648 if (isScaledFormat(format))
3649 {
3650 // *SCALED formats get mapped to correspoding (u)int formats since
3651 // accessing them through (float) getPixel/setPixel has same behavior
3652 // as in shader access in Vulkan.
3653 // Unfortunately full round-trip between tcu::TextureFormat and VkFormat
3654 // for most SCALED formats is not supported though.
3655
3656 const tcu::TextureFormat tcuFormat = mapVkFormat(format);
3657
3658 switch (tcuFormat.type)
3659 {
3660 case tcu::TextureFormat::UNSIGNED_INT8:
3661 case tcu::TextureFormat::UNSIGNED_INT16:
3662 case tcu::TextureFormat::UNSIGNED_INT32:
3663 case tcu::TextureFormat::SIGNED_INT8:
3664 case tcu::TextureFormat::SIGNED_INT16:
3665 case tcu::TextureFormat::SIGNED_INT32:
3666 case tcu::TextureFormat::UNSIGNED_INT_1010102_REV:
3667 case tcu::TextureFormat::SIGNED_INT_1010102_REV:
3668 return false;
3669
3670 default:
3671 return true;
3672 }
3673 }
3674 else
3675 {
3676 switch (format)
3677 {
3678 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
3679 case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
3680 case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
3681 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
3682 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
3683 case VK_FORMAT_A8B8G8R8_SINT_PACK32:
3684 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
3685 return false; // These map to regular byte array formats
3686
3687 default:
3688 break;
3689 }
3690
3691 return (format != VK_FORMAT_UNDEFINED);
3692 }
3693 }
3694
getChannelAccessFormat(tcu::TextureChannelClass type,uint32_t offsetBits,uint32_t sizeBits)3695 tcu::TextureFormat getChannelAccessFormat(tcu::TextureChannelClass type, uint32_t offsetBits, uint32_t sizeBits)
3696 {
3697 using tcu::TextureFormat;
3698
3699 if (offsetBits == 0)
3700 {
3701 static const TextureFormat::ChannelType s_size8[tcu::TEXTURECHANNELCLASS_LAST] = {
3702 TextureFormat::SNORM_INT8, // snorm
3703 TextureFormat::UNORM_INT8, // unorm
3704 TextureFormat::SIGNED_INT8, // sint
3705 TextureFormat::UNSIGNED_INT8, // uint
3706 TextureFormat::CHANNELTYPE_LAST, // float
3707 };
3708 static const TextureFormat::ChannelType s_size16[tcu::TEXTURECHANNELCLASS_LAST] = {
3709 TextureFormat::SNORM_INT16, // snorm
3710 TextureFormat::UNORM_INT16, // unorm
3711 TextureFormat::SIGNED_INT16, // sint
3712 TextureFormat::UNSIGNED_INT16, // uint
3713 TextureFormat::HALF_FLOAT, // float
3714 };
3715 static const TextureFormat::ChannelType s_size32[tcu::TEXTURECHANNELCLASS_LAST] = {
3716 TextureFormat::SNORM_INT32, // snorm
3717 TextureFormat::UNORM_INT32, // unorm
3718 TextureFormat::SIGNED_INT32, // sint
3719 TextureFormat::UNSIGNED_INT32, // uint
3720 TextureFormat::FLOAT, // float
3721 };
3722
3723 static const TextureFormat::ChannelType s_size64[tcu::TEXTURECHANNELCLASS_LAST] = {
3724 TextureFormat::CHANNELTYPE_LAST, // snorm
3725 TextureFormat::CHANNELTYPE_LAST, // unorm
3726 TextureFormat::SIGNED_INT64, // sint
3727 TextureFormat::UNSIGNED_INT64, // uint
3728 TextureFormat::FLOAT64, // float
3729 };
3730
3731 TextureFormat::ChannelType chnType = TextureFormat::CHANNELTYPE_LAST;
3732
3733 if (sizeBits == 8)
3734 chnType = s_size8[type];
3735 else if (sizeBits == 16)
3736 chnType = s_size16[type];
3737 else if (sizeBits == 32)
3738 chnType = s_size32[type];
3739 else if (sizeBits == 64)
3740 chnType = s_size64[type];
3741
3742 if (chnType != TextureFormat::CHANNELTYPE_LAST)
3743 return TextureFormat(TextureFormat::R, chnType);
3744 }
3745 else
3746 {
3747 if (type == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT && offsetBits == 6 && sizeBits == 10)
3748 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_10);
3749 else if (type == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT && offsetBits == 4 && sizeBits == 12)
3750 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_12);
3751 }
3752
3753 TCU_THROW(InternalError, "Channel access format is not supported");
3754 }
3755
getChannelAccess(const PlanarFormatDescription & formatInfo,const tcu::UVec2 & size,const uint32_t * planeRowPitches,void * const * planePtrs,uint32_t channelNdx)3756 tcu::PixelBufferAccess getChannelAccess(const PlanarFormatDescription &formatInfo, const tcu::UVec2 &size,
3757 const uint32_t *planeRowPitches, void *const *planePtrs, uint32_t channelNdx)
3758 {
3759 DE_ASSERT(formatInfo.hasChannelNdx(channelNdx));
3760
3761 const uint32_t planeNdx = formatInfo.channels[channelNdx].planeNdx;
3762 const uint32_t planeOffsetBytes = formatInfo.channels[channelNdx].offsetBits / 8;
3763 const uint32_t valueOffsetBits = formatInfo.channels[channelNdx].offsetBits % 8;
3764 const uint32_t pixelStrideBytes = formatInfo.channels[channelNdx].strideBytes;
3765
3766 DE_ASSERT(size.x() % (formatInfo.blockWidth * formatInfo.planes[planeNdx].widthDivisor) == 0);
3767 DE_ASSERT(size.y() % (formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor) == 0);
3768
3769 const uint32_t accessHeight = size.y() / (formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor);
3770 const uint32_t elementSizeBytes = formatInfo.planes[planeNdx].elementSizeBytes;
3771 const uint32_t rowPitch = planeRowPitches[planeNdx];
3772
3773 DE_ASSERT(elementSizeBytes % pixelStrideBytes == 0);
3774
3775 tcu::IVec3 texDivider(
3776 std::max(formatInfo.blockWidth * formatInfo.planes[planeNdx].widthDivisor * pixelStrideBytes / elementSizeBytes,
3777 1u),
3778 std::max(formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor * pixelStrideBytes /
3779 elementSizeBytes,
3780 1u),
3781 1);
3782
3783 return tcu::PixelBufferAccess(getChannelAccessFormat((tcu::TextureChannelClass)formatInfo.channels[channelNdx].type,
3784 valueOffsetBits, formatInfo.channels[channelNdx].sizeBits),
3785 tcu::IVec3((int)size.x(), (int)size.y(), 1),
3786 tcu::IVec3((int)pixelStrideBytes, (int)rowPitch, (int)(accessHeight * rowPitch)),
3787 texDivider, (uint8_t *)planePtrs[planeNdx] + planeOffsetBytes);
3788 }
3789
getChannelAccess(const PlanarFormatDescription & formatInfo,const tcu::UVec2 & size,const uint32_t * planeRowPitches,const void * const * planePtrs,uint32_t channelNdx)3790 tcu::ConstPixelBufferAccess getChannelAccess(const PlanarFormatDescription &formatInfo, const tcu::UVec2 &size,
3791 const uint32_t *planeRowPitches, const void *const *planePtrs,
3792 uint32_t channelNdx)
3793 {
3794 return getChannelAccess(formatInfo, size, planeRowPitches, const_cast<void *const *>(planePtrs), channelNdx);
3795 }
3796
getChannelAccess(const PlanarFormatDescription & formatInfo,const tcu::UVec3 & size,const uint32_t * planeRowPitches,void * const * planePtrs,uint32_t channelNdx)3797 tcu::PixelBufferAccess getChannelAccess(const PlanarFormatDescription &formatInfo, const tcu::UVec3 &size,
3798 const uint32_t *planeRowPitches, void *const *planePtrs, uint32_t channelNdx)
3799 {
3800 DE_ASSERT(formatInfo.hasChannelNdx(channelNdx));
3801
3802 const uint32_t planeNdx = formatInfo.channels[channelNdx].planeNdx;
3803 const uint32_t planeOffsetBytes = formatInfo.channels[channelNdx].offsetBits / 8;
3804 const uint32_t valueOffsetBits = formatInfo.channels[channelNdx].offsetBits % 8;
3805 const uint32_t pixelStrideBytes = formatInfo.channels[channelNdx].strideBytes;
3806
3807 DE_ASSERT(size.x() % (formatInfo.blockWidth * formatInfo.planes[planeNdx].widthDivisor) == 0);
3808 DE_ASSERT(size.y() % (formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor) == 0);
3809
3810 const uint32_t accessHeight = size.y() / (formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor);
3811 const uint32_t elementSizeBytes = formatInfo.planes[planeNdx].elementSizeBytes;
3812 const uint32_t rowPitch = planeRowPitches[planeNdx];
3813
3814 DE_ASSERT(elementSizeBytes % pixelStrideBytes == 0);
3815
3816 tcu::IVec3 texDivider(
3817 std::max(formatInfo.blockWidth * formatInfo.planes[planeNdx].widthDivisor * pixelStrideBytes / elementSizeBytes,
3818 1u),
3819 std::max(formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor * pixelStrideBytes /
3820 elementSizeBytes,
3821 1u),
3822 1);
3823
3824 return tcu::PixelBufferAccess(getChannelAccessFormat((tcu::TextureChannelClass)formatInfo.channels[channelNdx].type,
3825 valueOffsetBits, formatInfo.channels[channelNdx].sizeBits),
3826 tcu::IVec3((int)size.x(), (int)size.y(), (int)size.z()),
3827 tcu::IVec3((int)pixelStrideBytes, (int)rowPitch, (int)(accessHeight * rowPitch)),
3828 texDivider, (uint8_t *)planePtrs[planeNdx] + planeOffsetBytes);
3829 }
3830
getChannelAccess(const PlanarFormatDescription & formatInfo,const tcu::UVec3 & size,const uint32_t * planeRowPitches,const void * const * planePtrs,uint32_t channelNdx)3831 tcu::ConstPixelBufferAccess getChannelAccess(const PlanarFormatDescription &formatInfo, const tcu::UVec3 &size,
3832 const uint32_t *planeRowPitches, const void *const *planePtrs,
3833 uint32_t channelNdx)
3834 {
3835 return getChannelAccess(formatInfo, size, planeRowPitches, const_cast<void *const *>(planePtrs), channelNdx);
3836 }
3837
imageUtilSelfTest(void)3838 void imageUtilSelfTest(void)
3839 {
3840 for (int formatNdx = 0; formatNdx < VK_CORE_FORMAT_LAST; formatNdx++)
3841 {
3842 const VkFormat format = (VkFormat)formatNdx;
3843
3844 if (format == VK_FORMAT_R64_UINT || format == VK_FORMAT_R64_SINT || format == VK_FORMAT_R64G64_UINT ||
3845 format == VK_FORMAT_R64G64_SINT || format == VK_FORMAT_R64G64B64_UINT ||
3846 format == VK_FORMAT_R64G64B64_SINT || format == VK_FORMAT_R64G64B64A64_UINT ||
3847 format == VK_FORMAT_R64G64B64A64_SINT)
3848 continue; // \todo [2015-12-05 pyry] Add framework support for (u)int64 channel type
3849
3850 if (format != VK_FORMAT_UNDEFINED && !isCompressedFormat(format))
3851 {
3852 const tcu::TextureFormat tcuFormat = mapVkFormat(format);
3853 const VkFormat remappedFormat = mapTextureFormat(tcuFormat);
3854
3855 DE_TEST_ASSERT(isValid(tcuFormat));
3856
3857 if (fullTextureFormatRoundTripSupported(format))
3858 DE_TEST_ASSERT(format == remappedFormat);
3859 }
3860 }
3861
3862 for (int formatNdx = VK_FORMAT_G8B8G8R8_422_UNORM; formatNdx <= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM; formatNdx++)
3863 {
3864 const VkFormat format = (VkFormat)formatNdx;
3865 const PlanarFormatDescription &info = getPlanarFormatDescription(format);
3866
3867 DE_TEST_ASSERT(isYCbCrFormat(format));
3868 DE_TEST_ASSERT(de::inRange<uint8_t>(info.numPlanes, 1u, 3u));
3869 DE_TEST_ASSERT(info.numPlanes == getPlaneCount(format));
3870 }
3871
3872 for (int formatNdx = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT; formatNdx <= VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT;
3873 formatNdx++)
3874 {
3875 const VkFormat format = (VkFormat)formatNdx;
3876 const PlanarFormatDescription &info = getPlanarFormatDescription(format);
3877
3878 DE_TEST_ASSERT(isYCbCrFormat(format));
3879 DE_TEST_ASSERT(de::inRange<uint8_t>(info.numPlanes, 1u, 3u));
3880 DE_TEST_ASSERT(info.numPlanes == getPlaneCount(format));
3881 }
3882 }
3883
3884 struct CompressedFormatParameters
3885 {
3886 VkFormat format;
3887 uint32_t blockBytes;
3888 uint32_t blockWidth;
3889 uint32_t blockHeight;
3890 };
3891
3892 CompressedFormatParameters compressedFormatParameters[VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_BC1_RGB_UNORM_BLOCK +
3893 1] = {{VK_FORMAT_BC1_RGB_UNORM_BLOCK, 8, 4, 4},
3894 {VK_FORMAT_BC1_RGB_SRGB_BLOCK, 8, 4, 4},
3895 {VK_FORMAT_BC1_RGBA_UNORM_BLOCK, 8, 4, 4},
3896 {VK_FORMAT_BC1_RGBA_SRGB_BLOCK, 8, 4, 4},
3897 {VK_FORMAT_BC2_UNORM_BLOCK, 16, 4, 4},
3898 {VK_FORMAT_BC2_SRGB_BLOCK, 16, 4, 4},
3899 {VK_FORMAT_BC3_UNORM_BLOCK, 16, 4, 4},
3900 {VK_FORMAT_BC3_SRGB_BLOCK, 16, 4, 4},
3901 {VK_FORMAT_BC4_UNORM_BLOCK, 8, 4, 4},
3902 {VK_FORMAT_BC4_SNORM_BLOCK, 8, 4, 4},
3903 {VK_FORMAT_BC5_UNORM_BLOCK, 16, 4, 4},
3904 {VK_FORMAT_BC5_SNORM_BLOCK, 16, 4, 4},
3905 {VK_FORMAT_BC6H_UFLOAT_BLOCK, 16, 4, 4},
3906 {VK_FORMAT_BC6H_SFLOAT_BLOCK, 16, 4, 4},
3907 {VK_FORMAT_BC7_UNORM_BLOCK, 16, 4, 4},
3908 {VK_FORMAT_BC7_SRGB_BLOCK, 16, 4, 4},
3909 {VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, 8, 4, 4},
3910 {VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, 8, 4, 4},
3911 {VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, 8, 4, 4},
3912 {VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, 8, 4, 4},
3913 {VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, 16, 4, 4},
3914 {VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, 16, 4, 4},
3915 {VK_FORMAT_EAC_R11_UNORM_BLOCK, 8, 4, 4},
3916 {VK_FORMAT_EAC_R11_SNORM_BLOCK, 8, 4, 4},
3917 {VK_FORMAT_EAC_R11G11_UNORM_BLOCK, 16, 4, 4},
3918 {VK_FORMAT_EAC_R11G11_SNORM_BLOCK, 16, 4, 4},
3919 {VK_FORMAT_ASTC_4x4_UNORM_BLOCK, 16, 4, 4},
3920 {VK_FORMAT_ASTC_4x4_SRGB_BLOCK, 16, 4, 4},
3921 {VK_FORMAT_ASTC_5x4_UNORM_BLOCK, 16, 5, 4},
3922 {VK_FORMAT_ASTC_5x4_SRGB_BLOCK, 16, 5, 4},
3923 {VK_FORMAT_ASTC_5x5_UNORM_BLOCK, 16, 5, 5},
3924 {VK_FORMAT_ASTC_5x5_SRGB_BLOCK, 16, 5, 5},
3925 {VK_FORMAT_ASTC_6x5_UNORM_BLOCK, 16, 6, 5},
3926 {VK_FORMAT_ASTC_6x5_SRGB_BLOCK, 16, 6, 5},
3927 {VK_FORMAT_ASTC_6x6_UNORM_BLOCK, 16, 6, 6},
3928 {VK_FORMAT_ASTC_6x6_SRGB_BLOCK, 16, 6, 6},
3929 {VK_FORMAT_ASTC_8x5_UNORM_BLOCK, 16, 8, 5},
3930 {VK_FORMAT_ASTC_8x5_SRGB_BLOCK, 16, 8, 5},
3931 {VK_FORMAT_ASTC_8x6_UNORM_BLOCK, 16, 8, 6},
3932 {VK_FORMAT_ASTC_8x6_SRGB_BLOCK, 16, 8, 6},
3933 {VK_FORMAT_ASTC_8x8_UNORM_BLOCK, 16, 8, 8},
3934 {VK_FORMAT_ASTC_8x8_SRGB_BLOCK, 16, 8, 8},
3935 {VK_FORMAT_ASTC_10x5_UNORM_BLOCK, 16, 10, 5},
3936 {VK_FORMAT_ASTC_10x5_SRGB_BLOCK, 16, 10, 5},
3937 {VK_FORMAT_ASTC_10x6_UNORM_BLOCK, 16, 10, 6},
3938 {VK_FORMAT_ASTC_10x6_SRGB_BLOCK, 16, 10, 6},
3939 {VK_FORMAT_ASTC_10x8_UNORM_BLOCK, 16, 10, 8},
3940 {VK_FORMAT_ASTC_10x8_SRGB_BLOCK, 16, 10, 8},
3941 {VK_FORMAT_ASTC_10x10_UNORM_BLOCK, 16, 10, 10},
3942 {VK_FORMAT_ASTC_10x10_SRGB_BLOCK, 16, 10, 10},
3943 {VK_FORMAT_ASTC_12x10_UNORM_BLOCK, 16, 12, 10},
3944 {VK_FORMAT_ASTC_12x10_SRGB_BLOCK, 16, 12, 10},
3945 {VK_FORMAT_ASTC_12x12_UNORM_BLOCK, 16, 12, 12},
3946 {VK_FORMAT_ASTC_12x12_SRGB_BLOCK, 16, 12, 12}};
3947
getFormatComponentWidth(const VkFormat format,const uint32_t componentNdx)3948 uint32_t getFormatComponentWidth(const VkFormat format, const uint32_t componentNdx)
3949 {
3950 const bool isAlphaOnly = isAlphaOnlyFormat(format);
3951 const tcu::TextureFormat tcuFormat(mapVkFormat(format));
3952 const uint32_t componentCount(isAlphaOnly ? 4u : tcu::getNumUsedChannels(tcuFormat.order));
3953
3954 if (isAlphaOnly && componentCount < 3u)
3955 return 0; // RGB has no width for A8_UNORM
3956
3957 if (componentNdx >= componentCount)
3958 DE_FATAL("Component index out of range");
3959 else
3960 {
3961 switch (tcuFormat.type)
3962 {
3963 case tcu::TextureFormat::UNORM_INT8:
3964 case tcu::TextureFormat::SNORM_INT8:
3965 case tcu::TextureFormat::UNSIGNED_INT8:
3966 case tcu::TextureFormat::SIGNED_INT8:
3967 return 8;
3968
3969 case tcu::TextureFormat::UNORM_SHORT_10:
3970 return 10;
3971
3972 case tcu::TextureFormat::UNORM_SHORT_12:
3973 return 12;
3974
3975 case tcu::TextureFormat::UNORM_INT16:
3976 case tcu::TextureFormat::SNORM_INT16:
3977 case tcu::TextureFormat::UNSIGNED_INT16:
3978 case tcu::TextureFormat::SIGNED_INT16:
3979 case tcu::TextureFormat::HALF_FLOAT:
3980 return 16;
3981
3982 case tcu::TextureFormat::UNORM_INT24:
3983 case tcu::TextureFormat::UNSIGNED_INT24:
3984 return 24;
3985
3986 case tcu::TextureFormat::UNORM_INT32:
3987 case tcu::TextureFormat::SNORM_INT32:
3988 case tcu::TextureFormat::UNSIGNED_INT32:
3989 case tcu::TextureFormat::SIGNED_INT32:
3990 case tcu::TextureFormat::FLOAT:
3991 return 32;
3992
3993 case tcu::TextureFormat::FLOAT64:
3994 case tcu::TextureFormat::UNSIGNED_INT64:
3995 case tcu::TextureFormat::SIGNED_INT64:
3996 return 64;
3997
3998 // Packed formats
3999 case tcu::TextureFormat::UNORM_SHORT_4444:
4000 case tcu::TextureFormat::UNSIGNED_SHORT_4444:
4001 return 4;
4002
4003 case tcu::TextureFormat::UNORM_SHORT_565:
4004 case tcu::TextureFormat::UNSIGNED_SHORT_565:
4005 return (componentNdx == 1 ? 6 : 5);
4006
4007 case tcu::TextureFormat::UNSIGNED_INT_24_8:
4008 case tcu::TextureFormat::UNSIGNED_INT_24_8_REV:
4009 case tcu::TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV:
4010 return (componentNdx == 0 ? 24 : 8);
4011
4012 case tcu::TextureFormat::UNORM_SHORT_1555:
4013 return (componentNdx == 0 ? 1 : 5);
4014
4015 case tcu::TextureFormat::UNORM_INT_1010102_REV:
4016 case tcu::TextureFormat::SNORM_INT_1010102_REV:
4017 case tcu::TextureFormat::UNSIGNED_INT_1010102_REV:
4018 case tcu::TextureFormat::SIGNED_INT_1010102_REV:
4019 return (componentNdx == 3 ? 2 : 10);
4020
4021 default:
4022 DE_FATAL("Format unimplemented");
4023 }
4024 }
4025
4026 return 0;
4027 }
4028
getRepresentableDiffUnorm(const VkFormat format,const uint32_t componentNdx)4029 float getRepresentableDiffUnorm(const VkFormat format, const uint32_t componentNdx)
4030 {
4031 const uint32_t size(getFormatComponentWidth(format, componentNdx));
4032
4033 return 1.0f / float((1 << (size)) - 1);
4034 }
4035
getRepresentableDiffSnorm(const VkFormat format,const uint32_t componentNdx)4036 float getRepresentableDiffSnorm(const VkFormat format, const uint32_t componentNdx)
4037 {
4038 const uint32_t size(getFormatComponentWidth(format, componentNdx));
4039
4040 return 1.0f / float((1 << (size - 1)) - 1);
4041 }
4042
getBlockSizeInBytes(const VkFormat compressedFormat)4043 uint32_t getBlockSizeInBytes(const VkFormat compressedFormat)
4044 {
4045 uint32_t formatNdx = static_cast<uint32_t>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
4046
4047 DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
4048 DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
4049
4050 return compressedFormatParameters[formatNdx].blockBytes;
4051 }
4052
getBlockWidth(const VkFormat compressedFormat)4053 uint32_t getBlockWidth(const VkFormat compressedFormat)
4054 {
4055 uint32_t formatNdx = static_cast<uint32_t>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
4056
4057 DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
4058 DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
4059
4060 return compressedFormatParameters[formatNdx].blockWidth;
4061 }
4062
getBlockHeight(const VkFormat compressedFormat)4063 uint32_t getBlockHeight(const VkFormat compressedFormat)
4064 {
4065 uint32_t formatNdx = static_cast<uint32_t>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
4066
4067 DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
4068 DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
4069
4070 return compressedFormatParameters[formatNdx].blockHeight;
4071 }
4072
mapFilterMode(tcu::Sampler::FilterMode filterMode)4073 VkFilter mapFilterMode(tcu::Sampler::FilterMode filterMode)
4074 {
4075 DE_STATIC_ASSERT(tcu::Sampler::FILTERMODE_LAST == 9);
4076
4077 switch (filterMode)
4078 {
4079 case tcu::Sampler::NEAREST:
4080 return VK_FILTER_NEAREST;
4081 case tcu::Sampler::LINEAR:
4082 return VK_FILTER_LINEAR;
4083 case tcu::Sampler::CUBIC:
4084 return VK_FILTER_CUBIC_EXT;
4085 case tcu::Sampler::NEAREST_MIPMAP_NEAREST:
4086 return VK_FILTER_NEAREST;
4087 case tcu::Sampler::NEAREST_MIPMAP_LINEAR:
4088 return VK_FILTER_NEAREST;
4089 case tcu::Sampler::LINEAR_MIPMAP_NEAREST:
4090 return VK_FILTER_LINEAR;
4091 case tcu::Sampler::LINEAR_MIPMAP_LINEAR:
4092 return VK_FILTER_LINEAR;
4093 case tcu::Sampler::CUBIC_MIPMAP_NEAREST:
4094 return VK_FILTER_CUBIC_EXT;
4095 case tcu::Sampler::CUBIC_MIPMAP_LINEAR:
4096 return VK_FILTER_CUBIC_EXT;
4097 default:
4098 DE_FATAL("Illegal filter mode");
4099 return (VkFilter)0;
4100 }
4101 }
4102
mapMipmapMode(tcu::Sampler::FilterMode filterMode)4103 VkSamplerMipmapMode mapMipmapMode(tcu::Sampler::FilterMode filterMode)
4104 {
4105 DE_STATIC_ASSERT(tcu::Sampler::FILTERMODE_LAST == 9);
4106
4107 // \note VkSamplerCreateInfo doesn't have a flag for disabling mipmapping. Instead
4108 // minLod = 0 and maxLod = 0.25 should be used to match OpenGL NEAREST and LINEAR
4109 // filtering mode behavior.
4110
4111 switch (filterMode)
4112 {
4113 case tcu::Sampler::NEAREST:
4114 return VK_SAMPLER_MIPMAP_MODE_NEAREST;
4115 case tcu::Sampler::LINEAR:
4116 return VK_SAMPLER_MIPMAP_MODE_NEAREST;
4117 case tcu::Sampler::CUBIC:
4118 return VK_SAMPLER_MIPMAP_MODE_NEAREST;
4119 case tcu::Sampler::NEAREST_MIPMAP_NEAREST:
4120 return VK_SAMPLER_MIPMAP_MODE_NEAREST;
4121 case tcu::Sampler::NEAREST_MIPMAP_LINEAR:
4122 return VK_SAMPLER_MIPMAP_MODE_LINEAR;
4123 case tcu::Sampler::LINEAR_MIPMAP_NEAREST:
4124 return VK_SAMPLER_MIPMAP_MODE_NEAREST;
4125 case tcu::Sampler::LINEAR_MIPMAP_LINEAR:
4126 return VK_SAMPLER_MIPMAP_MODE_LINEAR;
4127 case tcu::Sampler::CUBIC_MIPMAP_NEAREST:
4128 return VK_SAMPLER_MIPMAP_MODE_NEAREST;
4129 case tcu::Sampler::CUBIC_MIPMAP_LINEAR:
4130 return VK_SAMPLER_MIPMAP_MODE_LINEAR;
4131 default:
4132 DE_FATAL("Illegal filter mode");
4133 return (VkSamplerMipmapMode)0;
4134 }
4135 }
4136
mapWrapMode(tcu::Sampler::WrapMode wrapMode)4137 VkSamplerAddressMode mapWrapMode(tcu::Sampler::WrapMode wrapMode)
4138 {
4139 switch (wrapMode)
4140 {
4141 case tcu::Sampler::CLAMP_TO_EDGE:
4142 return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
4143 case tcu::Sampler::CLAMP_TO_BORDER:
4144 return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
4145 case tcu::Sampler::REPEAT_GL:
4146 return VK_SAMPLER_ADDRESS_MODE_REPEAT;
4147 case tcu::Sampler::MIRRORED_REPEAT_GL:
4148 return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
4149 case tcu::Sampler::MIRRORED_ONCE:
4150 return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
4151 default:
4152 DE_FATAL("Wrap mode can't be mapped to Vulkan");
4153 return (vk::VkSamplerAddressMode)0;
4154 }
4155 }
4156
mapCompareMode(tcu::Sampler::CompareMode mode)4157 vk::VkCompareOp mapCompareMode(tcu::Sampler::CompareMode mode)
4158 {
4159 switch (mode)
4160 {
4161 case tcu::Sampler::COMPAREMODE_NONE:
4162 return vk::VK_COMPARE_OP_NEVER;
4163 case tcu::Sampler::COMPAREMODE_LESS:
4164 return vk::VK_COMPARE_OP_LESS;
4165 case tcu::Sampler::COMPAREMODE_LESS_OR_EQUAL:
4166 return vk::VK_COMPARE_OP_LESS_OR_EQUAL;
4167 case tcu::Sampler::COMPAREMODE_GREATER:
4168 return vk::VK_COMPARE_OP_GREATER;
4169 case tcu::Sampler::COMPAREMODE_GREATER_OR_EQUAL:
4170 return vk::VK_COMPARE_OP_GREATER_OR_EQUAL;
4171 case tcu::Sampler::COMPAREMODE_EQUAL:
4172 return vk::VK_COMPARE_OP_EQUAL;
4173 case tcu::Sampler::COMPAREMODE_NOT_EQUAL:
4174 return vk::VK_COMPARE_OP_NOT_EQUAL;
4175 case tcu::Sampler::COMPAREMODE_ALWAYS:
4176 return vk::VK_COMPARE_OP_ALWAYS;
4177 case tcu::Sampler::COMPAREMODE_NEVER:
4178 return vk::VK_COMPARE_OP_NEVER;
4179 default:
4180 DE_FATAL("Illegal compare mode");
4181 return (vk::VkCompareOp)0;
4182 }
4183 }
4184
mapBorderColor(tcu::TextureChannelClass channelClass,const rr::GenericVec4 & color)4185 static VkBorderColor mapBorderColor(tcu::TextureChannelClass channelClass, const rr::GenericVec4 &color)
4186 {
4187 if (channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER)
4188 {
4189 const tcu::UVec4 uColor = color.get<uint32_t>();
4190
4191 if (uColor == tcu::UVec4(0, 0, 0, 0))
4192 return VK_BORDER_COLOR_INT_TRANSPARENT_BLACK;
4193 else if (uColor == tcu::UVec4(0, 0, 0, 1))
4194 return VK_BORDER_COLOR_INT_OPAQUE_BLACK;
4195 else if (uColor == tcu::UVec4(1, 1, 1, 1))
4196 return VK_BORDER_COLOR_INT_OPAQUE_WHITE;
4197 else
4198 return VK_BORDER_COLOR_INT_CUSTOM_EXT;
4199 }
4200 else if (channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER)
4201 {
4202 const tcu::IVec4 sColor = color.get<int32_t>();
4203
4204 if (sColor == tcu::IVec4(0, 0, 0, 0))
4205 return VK_BORDER_COLOR_INT_TRANSPARENT_BLACK;
4206 else if (sColor == tcu::IVec4(0, 0, 0, 1))
4207 return VK_BORDER_COLOR_INT_OPAQUE_BLACK;
4208 else if (sColor == tcu::IVec4(1, 1, 1, 1))
4209 return VK_BORDER_COLOR_INT_OPAQUE_WHITE;
4210 else
4211 return VK_BORDER_COLOR_INT_CUSTOM_EXT;
4212 }
4213 else
4214 {
4215 const tcu::Vec4 fColor = color.get<float>();
4216
4217 if (fColor == tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f))
4218 return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
4219 else if (fColor == tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f))
4220 return VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
4221 else if (fColor == tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f))
4222 return VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
4223 else
4224 return VK_BORDER_COLOR_FLOAT_CUSTOM_EXT;
4225 }
4226
4227 // note: never reached
4228 DE_FATAL("Unsupported border color");
4229 return VK_BORDER_COLOR_MAX_ENUM;
4230 }
4231
mapSampler(const tcu::Sampler & sampler,const tcu::TextureFormat & format,float minLod,float maxLod,bool unnormal)4232 VkSamplerCreateInfo mapSampler(const tcu::Sampler &sampler, const tcu::TextureFormat &format, float minLod,
4233 float maxLod, bool unnormal)
4234 {
4235 const bool compareEnabled = (sampler.compare != tcu::Sampler::COMPAREMODE_NONE);
4236 const VkCompareOp compareOp = (compareEnabled) ? (mapCompareMode(sampler.compare)) : (VK_COMPARE_OP_ALWAYS);
4237 const VkBorderColor borderColor = mapBorderColor(getTextureChannelClass(format.type), sampler.borderColor);
4238 const bool isMipmapEnabled =
4239 (sampler.minFilter != tcu::Sampler::NEAREST && sampler.minFilter != tcu::Sampler::LINEAR &&
4240 sampler.minFilter != tcu::Sampler::CUBIC);
4241 #ifndef CTS_USES_VULKANSC
4242 const VkSamplerCreateFlags flags =
4243 sampler.seamlessCubeMap ? 0u : (VkSamplerCreateFlags)VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT;
4244 #else
4245 const VkSamplerCreateFlags flags = 0u;
4246 #endif // CTS_USES_VULKANSC
4247
4248 const VkSamplerCreateInfo createInfo = {
4249 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
4250 nullptr,
4251 flags,
4252 mapFilterMode(sampler.magFilter), // magFilter
4253 mapFilterMode(sampler.minFilter), // minFilter
4254 mapMipmapMode(sampler.minFilter), // mipMode
4255 mapWrapMode(sampler.wrapS), // addressU
4256 mapWrapMode(sampler.wrapT), // addressV
4257 mapWrapMode(sampler.wrapR), // addressW
4258 0.0f, // mipLodBias
4259 VK_FALSE, // anisotropyEnable
4260 1.0f, // maxAnisotropy
4261 (VkBool32)(compareEnabled ? VK_TRUE : VK_FALSE), // compareEnable
4262 compareOp, // compareOp
4263 (isMipmapEnabled ? minLod : 0.0f), // minLod
4264 (isMipmapEnabled ? maxLod : (unnormal ? 0.0f : 0.25f)), // maxLod
4265 borderColor, // borderColor
4266 (VkBool32)(sampler.normalizedCoords ? VK_FALSE : VK_TRUE), // unnormalizedCoords
4267 };
4268
4269 return createInfo;
4270 }
4271
mapVkColor(const VkClearColorValue & color)4272 rr::GenericVec4 mapVkColor(const VkClearColorValue &color)
4273 {
4274 rr::GenericVec4 value;
4275
4276 static_assert(sizeof(rr::GenericVec4) == sizeof(VkClearColorValue),
4277 "GenericVec4 and VkClearColorValue size mismatch");
4278 deMemcpy(&value, &color, sizeof(rr::GenericVec4));
4279 return value;
4280 }
4281
mapVkColor(const rr::GenericVec4 & color)4282 VkClearColorValue mapVkColor(const rr::GenericVec4 &color)
4283 {
4284 VkClearColorValue value;
4285
4286 static_assert(sizeof(rr::GenericVec4) == sizeof(VkClearColorValue),
4287 "GenericVec4 and VkClearColorValue size mismatch");
4288 deMemcpy(&value, &color, sizeof(VkClearColorValue));
4289 return value;
4290 }
4291
mapVkSampler(const VkSamplerCreateInfo & samplerCreateInfo)4292 tcu::Sampler mapVkSampler(const VkSamplerCreateInfo &samplerCreateInfo)
4293 {
4294 // \note minLod & maxLod are not supported by tcu::Sampler. LOD must be clamped
4295 // before passing it to tcu::Texture*::sample*()
4296
4297 tcu::Sampler::ReductionMode reductionMode = tcu::Sampler::WEIGHTED_AVERAGE;
4298 rr::GenericVec4 borderColorValue;
4299
4300 void const *pNext = samplerCreateInfo.pNext;
4301 while (pNext != nullptr)
4302 {
4303 const VkStructureType nextType = *reinterpret_cast<const VkStructureType *>(pNext);
4304 switch (nextType)
4305 {
4306 case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
4307 {
4308 const VkSamplerReductionModeCreateInfo reductionModeCreateInfo =
4309 *reinterpret_cast<const VkSamplerReductionModeCreateInfo *>(pNext);
4310 reductionMode = mapVkSamplerReductionMode(reductionModeCreateInfo.reductionMode);
4311 pNext = reinterpret_cast<const VkSamplerReductionModeCreateInfo *>(pNext)->pNext;
4312 break;
4313 }
4314 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
4315 pNext = reinterpret_cast<const VkSamplerYcbcrConversionInfo *>(pNext)->pNext;
4316 break;
4317 case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
4318 {
4319 const VkSamplerCustomBorderColorCreateInfoEXT customBorderColorCreateInfo =
4320 *reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT *>(pNext);
4321 borderColorValue = mapVkColor(customBorderColorCreateInfo.customBorderColor);
4322 pNext = reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT *>(pNext)->pNext;
4323 break;
4324 }
4325 default:
4326 TCU_FAIL("Unrecognized sType in chained sampler create info");
4327 }
4328 }
4329
4330 tcu::Sampler sampler(mapVkSamplerAddressMode(samplerCreateInfo.addressModeU),
4331 mapVkSamplerAddressMode(samplerCreateInfo.addressModeV),
4332 mapVkSamplerAddressMode(samplerCreateInfo.addressModeW),
4333 mapVkMinTexFilter(samplerCreateInfo.minFilter, samplerCreateInfo.mipmapMode),
4334 mapVkMagTexFilter(samplerCreateInfo.magFilter), 0.0f,
4335 !samplerCreateInfo.unnormalizedCoordinates,
4336 samplerCreateInfo.compareEnable ? mapVkSamplerCompareOp(samplerCreateInfo.compareOp) :
4337 tcu::Sampler::COMPAREMODE_NONE,
4338 0, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),
4339 #ifndef CTS_USES_VULKANSC
4340 !(samplerCreateInfo.flags & VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT),
4341 #else
4342 true,
4343 #endif // CTS_USES_VULKANSC
4344 tcu::Sampler::MODE_DEPTH, reductionMode);
4345
4346 if (samplerCreateInfo.anisotropyEnable)
4347 TCU_THROW(InternalError, "Anisotropic filtering is not supported by tcu::Sampler");
4348
4349 switch (samplerCreateInfo.borderColor)
4350 {
4351 case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
4352 sampler.borderColor = tcu::UVec4(0, 0, 0, 1);
4353 break;
4354 case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
4355 sampler.borderColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
4356 break;
4357 case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
4358 sampler.borderColor = tcu::UVec4(1, 1, 1, 1);
4359 break;
4360 case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
4361 sampler.borderColor = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f);
4362 break;
4363 case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
4364 sampler.borderColor = tcu::UVec4(0, 0, 0, 0);
4365 break;
4366 case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
4367 sampler.borderColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
4368 break;
4369 case VK_BORDER_COLOR_FLOAT_CUSTOM_EXT:
4370 case VK_BORDER_COLOR_INT_CUSTOM_EXT:
4371 sampler.borderColor = borderColorValue;
4372 break;
4373
4374 default:
4375 DE_ASSERT(false);
4376 break;
4377 }
4378
4379 return sampler;
4380 }
4381
mapVkSamplerCompareOp(VkCompareOp compareOp)4382 tcu::Sampler::CompareMode mapVkSamplerCompareOp(VkCompareOp compareOp)
4383 {
4384 switch (compareOp)
4385 {
4386 case VK_COMPARE_OP_NEVER:
4387 return tcu::Sampler::COMPAREMODE_NEVER;
4388 case VK_COMPARE_OP_LESS:
4389 return tcu::Sampler::COMPAREMODE_LESS;
4390 case VK_COMPARE_OP_EQUAL:
4391 return tcu::Sampler::COMPAREMODE_EQUAL;
4392 case VK_COMPARE_OP_LESS_OR_EQUAL:
4393 return tcu::Sampler::COMPAREMODE_LESS_OR_EQUAL;
4394 case VK_COMPARE_OP_GREATER:
4395 return tcu::Sampler::COMPAREMODE_GREATER;
4396 case VK_COMPARE_OP_NOT_EQUAL:
4397 return tcu::Sampler::COMPAREMODE_NOT_EQUAL;
4398 case VK_COMPARE_OP_GREATER_OR_EQUAL:
4399 return tcu::Sampler::COMPAREMODE_GREATER_OR_EQUAL;
4400 case VK_COMPARE_OP_ALWAYS:
4401 return tcu::Sampler::COMPAREMODE_ALWAYS;
4402 default:
4403 break;
4404 }
4405
4406 DE_ASSERT(false);
4407 return tcu::Sampler::COMPAREMODE_LAST;
4408 }
4409
mapVkSamplerAddressMode(VkSamplerAddressMode addressMode)4410 tcu::Sampler::WrapMode mapVkSamplerAddressMode(VkSamplerAddressMode addressMode)
4411 {
4412 switch (addressMode)
4413 {
4414 case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:
4415 return tcu::Sampler::CLAMP_TO_EDGE;
4416 case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER:
4417 return tcu::Sampler::CLAMP_TO_BORDER;
4418 case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT:
4419 return tcu::Sampler::MIRRORED_REPEAT_GL;
4420 case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE:
4421 return tcu::Sampler::MIRRORED_ONCE;
4422 case VK_SAMPLER_ADDRESS_MODE_REPEAT:
4423 return tcu::Sampler::REPEAT_GL;
4424 default:
4425 break;
4426 }
4427
4428 DE_ASSERT(false);
4429 return tcu::Sampler::WRAPMODE_LAST;
4430 }
4431
mapVkSamplerReductionMode(VkSamplerReductionMode reductionMode)4432 tcu::Sampler::ReductionMode mapVkSamplerReductionMode(VkSamplerReductionMode reductionMode)
4433 {
4434 switch (reductionMode)
4435 {
4436 case VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE:
4437 return tcu::Sampler::WEIGHTED_AVERAGE;
4438 case VK_SAMPLER_REDUCTION_MODE_MIN:
4439 return tcu::Sampler::MIN;
4440 case VK_SAMPLER_REDUCTION_MODE_MAX:
4441 return tcu::Sampler::MAX;
4442 default:
4443 break;
4444 }
4445
4446 DE_ASSERT(false);
4447 return tcu::Sampler::REDUCTIONMODE_LAST;
4448 }
4449
mapVkMinTexFilter(VkFilter filter,VkSamplerMipmapMode mipMode)4450 tcu::Sampler::FilterMode mapVkMinTexFilter(VkFilter filter, VkSamplerMipmapMode mipMode)
4451 {
4452 switch (filter)
4453 {
4454 case VK_FILTER_LINEAR:
4455 switch (mipMode)
4456 {
4457 case VK_SAMPLER_MIPMAP_MODE_LINEAR:
4458 return tcu::Sampler::LINEAR_MIPMAP_LINEAR;
4459 case VK_SAMPLER_MIPMAP_MODE_NEAREST:
4460 return tcu::Sampler::LINEAR_MIPMAP_NEAREST;
4461 default:
4462 break;
4463 }
4464 break;
4465
4466 case VK_FILTER_NEAREST:
4467 switch (mipMode)
4468 {
4469 case VK_SAMPLER_MIPMAP_MODE_LINEAR:
4470 return tcu::Sampler::NEAREST_MIPMAP_LINEAR;
4471 case VK_SAMPLER_MIPMAP_MODE_NEAREST:
4472 return tcu::Sampler::NEAREST_MIPMAP_NEAREST;
4473 default:
4474 break;
4475 }
4476 break;
4477 case VK_FILTER_CUBIC_EXT:
4478 switch (mipMode)
4479 {
4480 case VK_SAMPLER_MIPMAP_MODE_LINEAR:
4481 return tcu::Sampler::CUBIC_MIPMAP_LINEAR;
4482 case VK_SAMPLER_MIPMAP_MODE_NEAREST:
4483 return tcu::Sampler::CUBIC_MIPMAP_NEAREST;
4484 default:
4485 break;
4486 }
4487 break;
4488
4489 default:
4490 break;
4491 }
4492
4493 DE_ASSERT(false);
4494 return tcu::Sampler::FILTERMODE_LAST;
4495 }
4496
mapVkMagTexFilter(VkFilter filter)4497 tcu::Sampler::FilterMode mapVkMagTexFilter(VkFilter filter)
4498 {
4499 switch (filter)
4500 {
4501 case VK_FILTER_LINEAR:
4502 return tcu::Sampler::LINEAR;
4503 case VK_FILTER_NEAREST:
4504 return tcu::Sampler::NEAREST;
4505 case VK_FILTER_CUBIC_EXT:
4506 return tcu::Sampler::CUBIC;
4507 default:
4508 break;
4509 }
4510
4511 DE_ASSERT(false);
4512 return tcu::Sampler::FILTERMODE_LAST;
4513 }
4514
4515 //! Get a format that matches the layout in buffer memory used for a
4516 //! buffer<->image copy on a depth/stencil format.
getDepthCopyFormat(VkFormat combinedFormat)4517 tcu::TextureFormat getDepthCopyFormat(VkFormat combinedFormat)
4518 {
4519 switch (combinedFormat)
4520 {
4521 case VK_FORMAT_D16_UNORM:
4522 case VK_FORMAT_X8_D24_UNORM_PACK32:
4523 case VK_FORMAT_D32_SFLOAT:
4524 return mapVkFormat(combinedFormat);
4525
4526 case VK_FORMAT_D16_UNORM_S8_UINT:
4527 return mapVkFormat(VK_FORMAT_D16_UNORM);
4528 case VK_FORMAT_D24_UNORM_S8_UINT:
4529 return mapVkFormat(VK_FORMAT_X8_D24_UNORM_PACK32);
4530 case VK_FORMAT_D32_SFLOAT_S8_UINT:
4531 return mapVkFormat(VK_FORMAT_D32_SFLOAT);
4532
4533 case VK_FORMAT_S8_UINT:
4534 default:
4535 DE_FATAL("Unexpected depth/stencil format");
4536 return tcu::TextureFormat();
4537 }
4538 }
4539
4540 //! Get a format that matches the layout in buffer memory used for a
4541 //! buffer<->image copy on a depth/stencil format.
getStencilCopyFormat(VkFormat combinedFormat)4542 tcu::TextureFormat getStencilCopyFormat(VkFormat combinedFormat)
4543 {
4544 switch (combinedFormat)
4545 {
4546 case VK_FORMAT_D16_UNORM_S8_UINT:
4547 case VK_FORMAT_D24_UNORM_S8_UINT:
4548 case VK_FORMAT_D32_SFLOAT_S8_UINT:
4549 case VK_FORMAT_S8_UINT:
4550 return mapVkFormat(VK_FORMAT_S8_UINT);
4551
4552 case VK_FORMAT_D16_UNORM:
4553 case VK_FORMAT_X8_D24_UNORM_PACK32:
4554 case VK_FORMAT_D32_SFLOAT:
4555 default:
4556 DE_FATAL("Unexpected depth/stencil format");
4557 return tcu::TextureFormat();
4558 }
4559 }
4560
getImageAspectFlags(const tcu::TextureFormat textureFormat)4561 VkImageAspectFlags getImageAspectFlags(const tcu::TextureFormat textureFormat)
4562 {
4563 VkImageAspectFlags imageAspectFlags = 0;
4564
4565 if (tcu::hasDepthComponent(textureFormat.order))
4566 imageAspectFlags |= VK_IMAGE_ASPECT_DEPTH_BIT;
4567
4568 if (tcu::hasStencilComponent(textureFormat.order))
4569 imageAspectFlags |= VK_IMAGE_ASPECT_STENCIL_BIT;
4570
4571 if (imageAspectFlags == 0)
4572 imageAspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;
4573
4574 return imageAspectFlags;
4575 }
4576
mipLevelExtents(const VkExtent3D & baseExtents,const uint32_t mipLevel)4577 VkExtent3D mipLevelExtents(const VkExtent3D &baseExtents, const uint32_t mipLevel)
4578 {
4579 VkExtent3D result;
4580
4581 result.width = std::max(baseExtents.width >> mipLevel, 1u);
4582 result.height = std::max(baseExtents.height >> mipLevel, 1u);
4583 result.depth = std::max(baseExtents.depth >> mipLevel, 1u);
4584
4585 return result;
4586 }
4587
alignedDivide(const VkExtent3D & extent,const VkExtent3D & divisor)4588 tcu::UVec3 alignedDivide(const VkExtent3D &extent, const VkExtent3D &divisor)
4589 {
4590 tcu::UVec3 result;
4591
4592 result.x() = extent.width / divisor.width + ((extent.width % divisor.width != 0) ? 1u : 0u);
4593 result.y() = extent.height / divisor.height + ((extent.height % divisor.height != 0) ? 1u : 0u);
4594 result.z() = extent.depth / divisor.depth + ((extent.depth % divisor.depth != 0) ? 1u : 0u);
4595
4596 return result;
4597 }
4598
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)4599 void copyBufferToImage(const DeviceInterface &vk, const VkCommandBuffer &cmdBuffer, const VkBuffer &buffer,
4600 VkDeviceSize bufferSize, const std::vector<VkBufferImageCopy> ©Regions,
4601 VkImageAspectFlags imageAspectFlags, uint32_t mipLevels, uint32_t arrayLayers, VkImage destImage,
4602 VkImageLayout destImageLayout, VkPipelineStageFlags destImageDstStageFlags,
4603 VkAccessFlags destImageDstAccessMask, uint32_t baseMipLevel)
4604 {
4605 // Barriers for copying buffer to image
4606 const VkBufferMemoryBarrier preBufferBarrier = {
4607 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
4608 nullptr, // const void* pNext;
4609 VK_ACCESS_HOST_WRITE_BIT, // VkAccessFlags srcAccessMask;
4610 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
4611 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
4612 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
4613 buffer, // VkBuffer buffer;
4614 0u, // VkDeviceSize offset;
4615 bufferSize // VkDeviceSize size;
4616 };
4617
4618 const VkImageMemoryBarrier preImageBarrier = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4619 nullptr, // const void* pNext;
4620 0u, // VkAccessFlags srcAccessMask;
4621 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
4622 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
4623 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
4624 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
4625 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
4626 destImage, // VkImage image;
4627 {
4628 // VkImageSubresourceRange subresourceRange;
4629 imageAspectFlags, // VkImageAspectFlags aspect;
4630 baseMipLevel, // uint32_t baseMipLevel;
4631 mipLevels, // uint32_t mipLevels;
4632 0u, // uint32_t baseArraySlice;
4633 arrayLayers // uint32_t arraySize;
4634 }};
4635
4636 const VkImageMemoryBarrier postImageBarrier = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4637 nullptr, // const void* pNext;
4638 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
4639 destImageDstAccessMask, // VkAccessFlags dstAccessMask;
4640 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
4641 destImageLayout, // VkImageLayout newLayout;
4642 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
4643 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
4644 destImage, // VkImage image;
4645 {
4646 // VkImageSubresourceRange subresourceRange;
4647 imageAspectFlags, // VkImageAspectFlags aspect;
4648 baseMipLevel, // uint32_t baseMipLevel;
4649 mipLevels, // uint32_t mipLevels;
4650 0u, // uint32_t baseArraySlice;
4651 arrayLayers // uint32_t arraySize;
4652 }};
4653
4654 // Copy buffer to image
4655 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0,
4656 0, nullptr, 1, &preBufferBarrier, 1, &preImageBarrier);
4657 vk.cmdCopyBufferToImage(cmdBuffer, buffer, destImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
4658 (uint32_t)copyRegions.size(), copyRegions.data());
4659 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, destImageDstStageFlags, (VkDependencyFlags)0, 0,
4660 nullptr, 0, nullptr, 1, &postImageBarrier);
4661 }
4662
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)4663 void copyBufferToImage(const DeviceInterface &vk, VkDevice device, VkQueue queue, uint32_t queueFamilyIndex,
4664 const VkBuffer &buffer, VkDeviceSize bufferSize,
4665 const std::vector<VkBufferImageCopy> ©Regions, const VkSemaphore *waitSemaphore,
4666 VkImageAspectFlags imageAspectFlags, uint32_t mipLevels, uint32_t arrayLayers, VkImage destImage,
4667 VkImageLayout destImageLayout, VkPipelineStageFlags destImageDstStageFlags,
4668 VkAccessFlags destImageDstAccessMask, const VkCommandPool *externalCommandPool,
4669 uint32_t baseMipLevel)
4670 {
4671 Move<VkCommandPool> cmdPool;
4672 VkCommandPool activeCmdPool;
4673 if (externalCommandPool == nullptr)
4674 {
4675 // Create local command pool
4676 cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
4677 activeCmdPool = *cmdPool;
4678 }
4679 else
4680 {
4681 // Use external command pool if available
4682 activeCmdPool = *externalCommandPool;
4683 }
4684
4685 Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, activeCmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
4686 Move<VkFence> fence = createFence(vk, device);
4687
4688 const VkCommandBufferBeginInfo cmdBufferBeginInfo = {
4689 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
4690 nullptr, // const void* pNext;
4691 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
4692 nullptr,
4693 };
4694
4695 VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
4696 copyBufferToImage(vk, *cmdBuffer, buffer, bufferSize, copyRegions, imageAspectFlags, mipLevels, arrayLayers,
4697 destImage, destImageLayout, destImageDstStageFlags, destImageDstAccessMask, baseMipLevel);
4698 VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
4699
4700 const VkPipelineStageFlags pipelineStageFlags = VK_PIPELINE_STAGE_TRANSFER_BIT;
4701
4702 const VkSubmitInfo submitInfo = {
4703 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
4704 nullptr, // const void* pNext;
4705 waitSemaphore ? 1u : 0u, // uint32_t waitSemaphoreCount;
4706 waitSemaphore, // const VkSemaphore* pWaitSemaphores;
4707 &pipelineStageFlags, // const VkPipelineStageFlags* pWaitDstStageMask;
4708 1u, // uint32_t commandBufferCount;
4709 &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
4710 0u, // uint32_t signalSemaphoreCount;
4711 nullptr // const VkSemaphore* pSignalSemaphores;
4712 };
4713
4714 try
4715 {
4716 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
4717 VK_CHECK(vk.waitForFences(device, 1, &fence.get(), true, ~(0ull) /* infinity */));
4718 }
4719 catch (...)
4720 {
4721 VK_CHECK(vk.deviceWaitIdle(device));
4722 throw;
4723 }
4724 }
4725
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)4726 void copyImageToBuffer(const DeviceInterface &vk, VkCommandBuffer cmdBuffer, VkImage image, VkBuffer buffer,
4727 tcu::IVec2 size, VkAccessFlags srcAccessMask, VkImageLayout oldLayout, uint32_t numLayers,
4728 VkImageAspectFlags barrierAspect, VkImageAspectFlags copyAspect,
4729 VkPipelineStageFlags srcStageMask)
4730 {
4731 const VkImageMemoryBarrier imageBarrier = {
4732 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4733 nullptr, // const void* pNext;
4734 srcAccessMask, // VkAccessFlags srcAccessMask;
4735 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
4736 oldLayout, // VkImageLayout oldLayout;
4737 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
4738 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
4739 VK_QUEUE_FAMILY_IGNORED, // uint32_t destQueueFamilyIndex;
4740 image, // VkImage image;
4741 makeImageSubresourceRange(barrierAspect, 0u, 1u, 0, numLayers) // VkImageSubresourceRange subresourceRange;
4742 };
4743
4744 vk.cmdPipelineBarrier(cmdBuffer, srcStageMask, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, nullptr, 0u, nullptr, 1u,
4745 &imageBarrier);
4746
4747 const VkImageSubresourceLayers subresource = {
4748 copyAspect, // VkImageAspectFlags aspectMask;
4749 0u, // uint32_t mipLevel;
4750 0u, // uint32_t baseArrayLayer;
4751 numLayers // uint32_t layerCount;
4752 };
4753
4754 const VkBufferImageCopy region = {
4755 0ull, // VkDeviceSize bufferOffset;
4756 0u, // uint32_t bufferRowLength;
4757 0u, // uint32_t bufferImageHeight;
4758 subresource, // VkImageSubresourceLayers imageSubresource;
4759 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
4760 makeExtent3D(size.x(), size.y(), 1u) // VkExtent3D imageExtent;
4761 };
4762
4763 vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, 1u, ®ion);
4764
4765 const VkBufferMemoryBarrier bufferBarrier = {
4766 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
4767 nullptr, // const void* pNext;
4768 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
4769 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
4770 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
4771 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
4772 buffer, // VkBuffer buffer;
4773 0ull, // VkDeviceSize offset;
4774 VK_WHOLE_SIZE // VkDeviceSize size;
4775 };
4776
4777 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, nullptr, 1u,
4778 &bufferBarrier, 0u, nullptr);
4779 }
4780
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)4781 void copyImageToBuffer(const DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkBuffer buffer,
4782 vk::VkFormat format, tcu::IVec2 size, uint32_t mipLevel, vk::VkAccessFlags srcAccessMask,
4783 vk::VkImageLayout oldLayout, uint32_t numLayers, VkImageAspectFlags barrierAspect,
4784 VkImageAspectFlags copyAspect)
4785 {
4786 const VkImageMemoryBarrier imageBarrier = {
4787 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4788 nullptr, // const void* pNext;
4789 srcAccessMask, // VkAccessFlags srcAccessMask;
4790 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
4791 oldLayout, // VkImageLayout oldLayout;
4792 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
4793 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
4794 VK_QUEUE_FAMILY_IGNORED, // uint32_t destQueueFamilyIndex;
4795 image, // VkImage image;
4796 makeImageSubresourceRange(barrierAspect, mipLevel, 1u, 0,
4797 numLayers) // VkImageSubresourceRange subresourceRange;
4798 };
4799
4800 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u,
4801 nullptr, 0u, nullptr, 1u, &imageBarrier);
4802
4803 const VkImageSubresourceLayers subresource = {
4804 copyAspect, // VkImageAspectFlags aspectMask;
4805 mipLevel, // uint32_t mipLevel;
4806 0u, // uint32_t baseArrayLayer;
4807 numLayers // uint32_t layerCount;
4808 };
4809
4810 VkDeviceSize offset = 0ull;
4811 uint32_t width = size.x();
4812 uint32_t height = size.y();
4813 uint32_t pixelSize = tcu::getPixelSize(mapVkFormat(format));
4814
4815 for (uint32_t level = 0; level < mipLevel; ++level)
4816 {
4817 offset += (width * height * pixelSize);
4818 height /= 2;
4819 width /= 2;
4820 }
4821
4822 const VkBufferImageCopy region = {
4823 offset, // VkDeviceSize bufferOffset;
4824 0u, // uint32_t bufferRowLength;
4825 0u, // uint32_t bufferImageHeight;
4826 subresource, // VkImageSubresourceLayers imageSubresource;
4827 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
4828 makeExtent3D(width, height, 1u) // VkExtent3D imageExtent;
4829 };
4830
4831 vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, 1u, ®ion);
4832
4833 const VkBufferMemoryBarrier bufferBarrier = {
4834 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
4835 nullptr, // const void* pNext;
4836 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
4837 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
4838 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
4839 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
4840 buffer, // VkBuffer buffer;
4841 offset, // VkDeviceSize offset;
4842 VK_WHOLE_SIZE // VkDeviceSize size;
4843 };
4844
4845 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, nullptr, 1u,
4846 &bufferBarrier, 0u, nullptr);
4847 }
4848
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)4849 void clearColorImage(const DeviceInterface &vk, const VkDevice device, const VkQueue queue, uint32_t queueFamilyIndex,
4850 VkImage image, VkClearColorValue clearColor, VkImageLayout oldLayout, VkImageLayout newLayout,
4851 VkAccessFlags dstAccessFlags, VkPipelineStageFlags dstStageFlags, uint32_t baseArrayLayer,
4852 uint32_t layerCount, uint32_t baseMipLevel, uint32_t levelCount)
4853 {
4854 Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
4855 Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
4856
4857 const VkImageSubresourceRange subresourceRange = {
4858 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
4859 baseMipLevel, // uint32_t baseMipLevel
4860 levelCount, // uint32_t levelCount
4861 baseArrayLayer, // uint32_t baseArrayLayer
4862 layerCount, // uint32_t layerCount
4863 };
4864
4865 const VkImageMemoryBarrier preImageBarrier = {
4866 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4867 nullptr, // const void* pNext;
4868 0u, // VkAccessFlags srcAccessMask;
4869 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
4870 oldLayout, // VkImageLayout oldLayout;
4871 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
4872 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
4873 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
4874 image, // VkImage image;
4875 subresourceRange // VkImageSubresourceRange subresourceRange;
4876 };
4877
4878 const VkImageMemoryBarrier postImageBarrier = {
4879 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4880 nullptr, // const void* pNext;
4881 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
4882 dstAccessFlags, // VkAccessFlags dstAccessMask;
4883 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
4884 newLayout, // VkImageLayout newLayout;
4885 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
4886 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
4887 image, // VkImage image;
4888 subresourceRange // VkImageSubresourceRange subresourceRange;
4889 };
4890
4891 beginCommandBuffer(vk, *cmdBuffer);
4892 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0,
4893 0, nullptr, 0, nullptr, 1, &preImageBarrier);
4894 vk.cmdClearColorImage(*cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColor, 1, &subresourceRange);
4895 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, dstStageFlags, (VkDependencyFlags)0, 0, nullptr,
4896 0, nullptr, 1, &postImageBarrier);
4897 endCommandBuffer(vk, *cmdBuffer);
4898
4899 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
4900 }
4901
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)4902 void clearColorImage(const DeviceInterface &vk, const VkDevice device, const VkQueue queue, uint32_t queueFamilyIndex,
4903 VkImage image, tcu::Vec4 clearColor, VkImageLayout oldLayout, VkImageLayout newLayout,
4904 VkPipelineStageFlags dstStageFlags, uint32_t baseArrayLayer, uint32_t layerCount,
4905 uint32_t baseMipLevel, uint32_t levelCount)
4906 {
4907 clearColorImage(vk, device, queue, queueFamilyIndex, image, makeClearValueColor(clearColor).color, oldLayout,
4908 newLayout, VK_ACCESS_SHADER_WRITE_BIT, dstStageFlags, baseArrayLayer, layerCount, baseMipLevel,
4909 levelCount);
4910 }
4911
generateChessboardCopyRegions(uint32_t tileSize,uint32_t imageWidth,uint32_t imageHeight,uint32_t tileIdx,VkImageAspectFlags aspectMask)4912 std::vector<VkBufferImageCopy> generateChessboardCopyRegions(uint32_t tileSize, uint32_t imageWidth,
4913 uint32_t imageHeight, uint32_t tileIdx,
4914 VkImageAspectFlags aspectMask)
4915 {
4916 std::vector<VkBufferImageCopy> copyRegions;
4917
4918 for (uint32_t x = 0; x < (uint32_t)deFloatCeil((float)imageWidth / (float)tileSize); x++)
4919 for (uint32_t y = 0; y < (uint32_t)deFloatCeil((float)imageHeight / (float)tileSize); y++)
4920 {
4921 if ((x + tileIdx) % 2 == y % 2)
4922 continue;
4923
4924 const uint32_t tileWidth = de::min(tileSize, imageWidth - tileSize * x);
4925 const uint32_t tileHeight = de::min(tileSize, imageHeight - tileSize * y);
4926
4927 const VkOffset3D offset = {
4928 (int32_t)x * (int32_t)tileWidth, // int32_t x
4929 (int32_t)y * (int32_t)tileHeight, // int32_t y
4930 0 // int32_t z
4931 };
4932
4933 const VkExtent3D extent = {
4934 tileWidth, // uint32_t width
4935 tileHeight, // uint32_t height
4936 1u // uint32_t depth
4937 };
4938
4939 const VkImageSubresourceLayers subresourceLayers = {
4940 aspectMask, // VkImageAspectFlags aspectMask
4941 0u, // uint32_t mipLevel
4942 0u, // uint32_t baseArrayLayer
4943 1u, // uint32_t layerCount
4944 };
4945
4946 const VkBufferImageCopy copy = {
4947 (VkDeviceSize)0, // VkDeviceSize bufferOffset
4948 0u, // uint32_t bufferRowLength
4949 0u, // uint32_t bufferImageHeight
4950 subresourceLayers, // VkImageSubresourceLayers imageSubresource
4951 offset, // VkOffset3D imageOffset
4952 extent // VkExtent3D imageExtent
4953 };
4954
4955 copyRegions.push_back(copy);
4956 }
4957
4958 return copyRegions;
4959 }
4960
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)4961 void initColorImageChessboardPattern(const DeviceInterface &vk, const VkDevice device, const VkQueue queue,
4962 uint32_t queueFamilyIndex, Allocator &allocator, VkImage image, VkFormat format,
4963 tcu::Vec4 colorValue0, tcu::Vec4 colorValue1, uint32_t imageWidth,
4964 uint32_t imageHeight, uint32_t tileSize, VkImageLayout oldLayout,
4965 VkImageLayout newLayout, VkPipelineStageFlags dstStageFlags)
4966 {
4967 Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
4968 Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
4969 const tcu::TextureFormat tcuFormat = mapVkFormat(format);
4970 const tcu::Vec4 colorValues[] = {colorValue0, colorValue1};
4971 const uint32_t bufferSize = tileSize * tileSize * tcuFormat.getPixelSize();
4972
4973 const VkImageSubresourceRange subresourceRange = {
4974 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
4975 0u, // uint32_t baseMipLevel
4976 1u, // uint32_t levelCount
4977 0u, // uint32_t baseArrayLayer
4978 1u // uint32_t layerCount
4979 };
4980
4981 const VkImageMemoryBarrier preImageBarrier = {
4982 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4983 nullptr, // const void* pNext;
4984 0u, // VkAccessFlags srcAccessMask;
4985 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
4986 oldLayout, // VkImageLayout oldLayout;
4987 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
4988 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
4989 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
4990 image, // VkImage image;
4991 subresourceRange // VkImageSubresourceRange subresourceRange;
4992 };
4993
4994 const VkImageMemoryBarrier postImageBarrier = {
4995 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
4996 nullptr, // const void* pNext;
4997 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
4998 VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags dstAccessMask;
4999 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
5000 newLayout, // VkImageLayout newLayout;
5001 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
5002 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
5003 image, // VkImage image;
5004 subresourceRange // VkImageSubresourceRange subresourceRange;
5005 };
5006
5007 // Create staging buffers for both color values
5008 Move<VkBuffer> buffers[2];
5009 de::MovePtr<Allocation> bufferAllocs[2];
5010
5011 const VkBufferCreateInfo bufferParams = {
5012 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType
5013 nullptr, // const void* pNext
5014 0u, // VkBufferCreateFlags flags
5015 (VkDeviceSize)bufferSize, // VkDeviceSize size
5016 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage
5017 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
5018 0u, // uint32_t queueFamilyIndexCount
5019 nullptr // const uint32_t* pQueueFamilyIndices
5020 };
5021
5022 for (uint32_t bufferIdx = 0; bufferIdx < 2; bufferIdx++)
5023 {
5024 buffers[bufferIdx] = createBuffer(vk, device, &bufferParams);
5025 bufferAllocs[bufferIdx] = allocator.allocate(getBufferMemoryRequirements(vk, device, *buffers[bufferIdx]),
5026 MemoryRequirement::HostVisible);
5027 VK_CHECK(vk.bindBufferMemory(device, *buffers[bufferIdx], bufferAllocs[bufferIdx]->getMemory(),
5028 bufferAllocs[bufferIdx]->getOffset()));
5029
5030 uint32_t *dstPtr = (uint32_t *)bufferAllocs[bufferIdx]->getHostPtr();
5031 tcu::PixelBufferAccess access(tcuFormat, tileSize, tileSize, 1, dstPtr);
5032
5033 for (uint32_t x = 0; x < tileSize; x++)
5034 for (uint32_t y = 0; y < tileSize; y++)
5035 access.setPixel(colorValues[bufferIdx], x, y, 0);
5036
5037 flushAlloc(vk, device, *bufferAllocs[bufferIdx]);
5038 }
5039
5040 beginCommandBuffer(vk, *cmdBuffer);
5041 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0,
5042 0, nullptr, 0, nullptr, 1, &preImageBarrier);
5043
5044 for (uint32_t bufferIdx = 0; bufferIdx < 2; bufferIdx++)
5045 {
5046 std::vector<VkBufferImageCopy> copyRegions =
5047 generateChessboardCopyRegions(tileSize, imageWidth, imageHeight, bufferIdx, VK_IMAGE_ASPECT_COLOR_BIT);
5048
5049 vk.cmdCopyBufferToImage(*cmdBuffer, *buffers[bufferIdx], image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
5050 (uint32_t)copyRegions.size(), copyRegions.data());
5051 }
5052
5053 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, dstStageFlags, (VkDependencyFlags)0, 0, nullptr,
5054 0, nullptr, 1, &postImageBarrier);
5055
5056 endCommandBuffer(vk, *cmdBuffer);
5057
5058 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
5059 }
5060
copyDepthStencilImageToBuffers(const DeviceInterface & vk,VkCommandBuffer cmdBuffer,VkImage image,VkBuffer depthBuffer,VkBuffer stencilBuffer,tcu::IVec2 size,VkAccessFlags srcAccessMask,VkImageLayout oldLayout,uint32_t numLayers)5061 void copyDepthStencilImageToBuffers(const DeviceInterface &vk, VkCommandBuffer cmdBuffer, VkImage image,
5062 VkBuffer depthBuffer, VkBuffer stencilBuffer, tcu::IVec2 size,
5063 VkAccessFlags srcAccessMask, VkImageLayout oldLayout, uint32_t numLayers)
5064 {
5065 const VkImageAspectFlags aspect = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
5066 const VkImageMemoryBarrier imageBarrier = {
5067 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
5068 nullptr, // const void* pNext;
5069 srcAccessMask, // VkAccessFlags srcAccessMask;
5070 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
5071 oldLayout, // VkImageLayout oldLayout;
5072 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
5073 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
5074 VK_QUEUE_FAMILY_IGNORED, // uint32_t destQueueFamilyIndex;
5075 image, // VkImage image;
5076 makeImageSubresourceRange(aspect, 0u, 1u, 0, numLayers) // VkImageSubresourceRange subresourceRange;
5077 };
5078
5079 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u,
5080 nullptr, 0u, nullptr, 1u, &imageBarrier);
5081
5082 const VkImageSubresourceLayers subresourceDepth = {
5083 VK_IMAGE_ASPECT_DEPTH_BIT, // VkImageAspectFlags aspectMask;
5084 0u, // uint32_t mipLevel;
5085 0u, // uint32_t baseArrayLayer;
5086 numLayers // uint32_t layerCount;
5087 };
5088
5089 const VkBufferImageCopy regionDepth = {
5090 0ull, // VkDeviceSize bufferOffset;
5091 0u, // uint32_t bufferRowLength;
5092 0u, // uint32_t bufferImageHeight;
5093 subresourceDepth, // VkImageSubresourceLayers imageSubresource;
5094 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
5095 makeExtent3D(size.x(), size.y(), 1u) // VkExtent3D imageExtent;
5096 };
5097
5098 const VkImageSubresourceLayers subresourceStencil = {
5099 VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask;
5100 0u, // uint32_t mipLevel;
5101 0u, // uint32_t baseArrayLayer;
5102 numLayers // uint32_t layerCount;
5103 };
5104
5105 const VkBufferImageCopy regionStencil = {
5106 0ull, // VkDeviceSize bufferOffset;
5107 0u, // uint32_t bufferRowLength;
5108 0u, // uint32_t bufferImageHeight;
5109 subresourceStencil, // VkImageSubresourceLayers imageSubresource;
5110 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
5111 makeExtent3D(size.x(), size.y(), 1u) // VkExtent3D imageExtent;
5112 };
5113
5114 vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, depthBuffer, 1u, ®ionDepth);
5115 vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, stencilBuffer, 1u, ®ionStencil);
5116
5117 const VkBufferMemoryBarrier bufferBarriers[] = {
5118 {
5119 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
5120 nullptr, // const void* pNext;
5121 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
5122 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
5123 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
5124 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
5125 depthBuffer, // VkBuffer buffer;
5126 0ull, // VkDeviceSize offset;
5127 VK_WHOLE_SIZE // VkDeviceSize size;
5128 },
5129 {
5130 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
5131 nullptr, // const void* pNext;
5132 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
5133 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
5134 VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex;
5135 VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex;
5136 stencilBuffer, // VkBuffer buffer;
5137 0ull, // VkDeviceSize offset;
5138 VK_WHOLE_SIZE // VkDeviceSize size;
5139 }};
5140
5141 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, nullptr, 2u,
5142 bufferBarriers, 0u, nullptr);
5143 }
5144
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)5145 void clearDepthStencilImage(const DeviceInterface &vk, const VkDevice device, const VkQueue queue,
5146 uint32_t queueFamilyIndex, VkImage image, VkFormat format, float depthValue,
5147 uint32_t stencilValue, VkImageLayout oldLayout, VkImageLayout newLayout,
5148 VkAccessFlags dstAccessFlags, VkPipelineStageFlags dstStageFlags)
5149 {
5150 Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
5151 Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
5152
5153 const VkClearDepthStencilValue clearValue = makeClearValueDepthStencil(depthValue, stencilValue).depthStencil;
5154 const auto aspectMask = getImageAspectFlags(mapVkFormat(format));
5155
5156 const VkImageSubresourceRange subresourceRange = {
5157 aspectMask, // VkImageAspectFlags aspectMask
5158 0u, // uint32_t baseMipLevel
5159 1u, // uint32_t levelCount
5160 0u, // uint32_t baseArrayLayer
5161 1u // uint32_t layerCount
5162 };
5163
5164 const VkImageMemoryBarrier preImageBarrier = {
5165 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
5166 nullptr, // const void* pNext;
5167 0u, // VkAccessFlags srcAccessMask;
5168 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
5169 oldLayout, // VkImageLayout oldLayout;
5170 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
5171 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
5172 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
5173 image, // VkImage image;
5174 subresourceRange // VkImageSubresourceRange subresourceRange;
5175 };
5176
5177 const VkImageMemoryBarrier postImageBarrier = {
5178 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
5179 nullptr, // const void* pNext;
5180 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
5181 dstAccessFlags, // VkAccessFlags dstAccessMask;
5182 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
5183 newLayout, // VkImageLayout newLayout;
5184 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
5185 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
5186 image, // VkImage image;
5187 subresourceRange // VkImageSubresourceRange subresourceRange;
5188 };
5189
5190 beginCommandBuffer(vk, *cmdBuffer);
5191 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0,
5192 0, nullptr, 0, nullptr, 1, &preImageBarrier);
5193 vk.cmdClearDepthStencilImage(*cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearValue, 1,
5194 &subresourceRange);
5195 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, dstStageFlags, (VkDependencyFlags)0, 0, nullptr,
5196 0, nullptr, 1, &postImageBarrier);
5197 endCommandBuffer(vk, *cmdBuffer);
5198
5199 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
5200 }
5201
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)5202 void initDepthStencilImageChessboardPattern(const DeviceInterface &vk, const VkDevice device, const VkQueue queue,
5203 uint32_t queueFamilyIndex, Allocator &allocator, VkImage image,
5204 VkFormat format, float depthValue0, float depthValue1,
5205 uint32_t stencilValue0, uint32_t stencilValue1, uint32_t imageWidth,
5206 uint32_t imageHeight, uint32_t tileSize, VkImageLayout oldLayout,
5207 VkImageLayout newLayout, VkPipelineStageFlags dstStageFlags)
5208 {
5209 Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
5210 Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
5211
5212 const uint32_t depthBufferSize = tileSize * tileSize * 4;
5213 const uint32_t stencilBufferSize = tileSize * tileSize;
5214 const float depthValues[] = {depthValue0, depthValue1};
5215 const uint32_t stencilValues[] = {stencilValue0, stencilValue1};
5216 const tcu::TextureFormat tcuFormat = mapVkFormat(format);
5217
5218 const VkImageSubresourceRange subresourceRange = {
5219 VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask
5220 0u, // uint32_t baseMipLevel
5221 1u, // uint32_t levelCount
5222 0u, // uint32_t baseArrayLayer
5223 1u // uint32_t layerCount
5224 };
5225
5226 const VkImageMemoryBarrier preImageBarrier = {
5227 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
5228 nullptr, // const void* pNext;
5229 0u, // VkAccessFlags srcAccessMask;
5230 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
5231 oldLayout, // VkImageLayout oldLayout;
5232 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
5233 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
5234 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
5235 image, // VkImage image;
5236 subresourceRange // VkImageSubresourceRange subresourceRange;
5237 };
5238
5239 const VkImageMemoryBarrier postImageBarrier = {
5240 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
5241 nullptr, // const void* pNext;
5242 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
5243 VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags dstAccessMask;
5244 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
5245 newLayout, // VkImageLayout newLayout;
5246 queueFamilyIndex, // uint32_t srcQueueFamilyIndex;
5247 queueFamilyIndex, // uint32_t dstQueueFamilyIndex;
5248 image, // VkImage image;
5249 subresourceRange // VkImageSubresourceRange subresourceRange;
5250 };
5251
5252 // Create staging buffers for depth and stencil values
5253 Move<VkBuffer> depthBuffers[2];
5254 de::MovePtr<Allocation> depthBufferAllocs[2];
5255 Move<VkBuffer> stencilBuffers[2];
5256 de::MovePtr<Allocation> stencilBufferAllocs[2];
5257
5258 const VkBufferCreateInfo depthBufferParams = {
5259 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType
5260 nullptr, // const void* pNext
5261 0u, // VkBufferCreateFlags flags
5262 (VkDeviceSize)depthBufferSize, // VkDeviceSize size
5263 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage
5264 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
5265 0u, // uint32_t queueFamilyIndexCount
5266 nullptr // const uint32_t* pQueueFamilyIndices
5267 };
5268
5269 const VkBufferCreateInfo stencilBufferParams = {
5270 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType
5271 nullptr, // const void* pNext
5272 0u, // VkBufferCreateFlags flags
5273 (VkDeviceSize)stencilBufferSize, // VkDeviceSize size
5274 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage
5275 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
5276 0u, // uint32_t queueFamilyIndexCount
5277 nullptr // const uint32_t* pQueueFamilyIndices
5278 };
5279
5280 for (uint32_t bufferIdx = 0; bufferIdx < 2; bufferIdx++)
5281 {
5282 depthBuffers[bufferIdx] = createBuffer(vk, device, &depthBufferParams);
5283 depthBufferAllocs[bufferIdx] = allocator.allocate(
5284 getBufferMemoryRequirements(vk, device, *depthBuffers[bufferIdx]), MemoryRequirement::HostVisible);
5285 VK_CHECK(vk.bindBufferMemory(device, *depthBuffers[bufferIdx], depthBufferAllocs[bufferIdx]->getMemory(),
5286 depthBufferAllocs[bufferIdx]->getOffset()));
5287 stencilBuffers[bufferIdx] = createBuffer(vk, device, &stencilBufferParams);
5288 stencilBufferAllocs[bufferIdx] = allocator.allocate(
5289 getBufferMemoryRequirements(vk, device, *stencilBuffers[bufferIdx]), MemoryRequirement::HostVisible);
5290 VK_CHECK(vk.bindBufferMemory(device, *stencilBuffers[bufferIdx], stencilBufferAllocs[bufferIdx]->getMemory(),
5291 stencilBufferAllocs[bufferIdx]->getOffset()));
5292
5293 uint32_t *depthPtr = (uint32_t *)depthBufferAllocs[bufferIdx]->getHostPtr();
5294 uint32_t *stencilPtr = (uint32_t *)stencilBufferAllocs[bufferIdx]->getHostPtr();
5295
5296 if (format == VK_FORMAT_D24_UNORM_S8_UINT)
5297 {
5298 tcu::PixelBufferAccess access(tcuFormat, tileSize, tileSize, 1, depthPtr);
5299
5300 for (uint32_t x = 0; x < tileSize; x++)
5301 for (uint32_t y = 0; y < tileSize; y++)
5302 access.setPixDepth(depthValues[bufferIdx], x, y, 0);
5303 }
5304 else
5305 {
5306 DE_ASSERT(format == VK_FORMAT_D32_SFLOAT_S8_UINT);
5307
5308 for (uint32_t i = 0; i < tileSize * tileSize; i++)
5309 ((float *)depthPtr)[i] = depthValues[bufferIdx];
5310 }
5311
5312 deMemset(stencilPtr, stencilValues[bufferIdx], stencilBufferSize);
5313 flushAlloc(vk, device, *depthBufferAllocs[bufferIdx]);
5314 flushAlloc(vk, device, *stencilBufferAllocs[bufferIdx]);
5315 }
5316
5317 beginCommandBuffer(vk, *cmdBuffer);
5318 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0,
5319 0, nullptr, 0, nullptr, 1, &preImageBarrier);
5320
5321 for (uint32_t bufferIdx = 0; bufferIdx < 2; bufferIdx++)
5322 {
5323 std::vector<VkBufferImageCopy> copyRegionsDepth =
5324 generateChessboardCopyRegions(tileSize, imageWidth, imageHeight, bufferIdx, VK_IMAGE_ASPECT_DEPTH_BIT);
5325 std::vector<VkBufferImageCopy> copyRegionsStencil =
5326 generateChessboardCopyRegions(tileSize, imageWidth, imageHeight, bufferIdx, VK_IMAGE_ASPECT_STENCIL_BIT);
5327
5328 vk.cmdCopyBufferToImage(*cmdBuffer, *depthBuffers[bufferIdx], image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
5329 (uint32_t)copyRegionsDepth.size(), copyRegionsDepth.data());
5330 vk.cmdCopyBufferToImage(*cmdBuffer, *stencilBuffers[bufferIdx], image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
5331 (uint32_t)copyRegionsStencil.size(), copyRegionsStencil.data());
5332 }
5333
5334 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, dstStageFlags, (VkDependencyFlags)0, 0, nullptr,
5335 0, nullptr, 1, &postImageBarrier);
5336
5337 endCommandBuffer(vk, *cmdBuffer);
5338
5339 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
5340 }
5341
makeDefaultImageSubresourceRange()5342 vk::VkImageSubresourceRange makeDefaultImageSubresourceRange()
5343 {
5344 return vk::makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
5345 }
5346
makeDefaultImageSubresourceLayers()5347 vk::VkImageSubresourceLayers makeDefaultImageSubresourceLayers()
5348 {
5349 return makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u);
5350 }
5351
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)5352 ImageWithBuffer::ImageWithBuffer(const DeviceInterface &vkd, const VkDevice device, Allocator &alloc,
5353 vk::VkExtent3D extent, vk::VkFormat imageFormat, vk::VkImageUsageFlags usage,
5354 vk::VkImageType imageType, vk::VkImageSubresourceRange ssr, uint32_t arrayLayers,
5355 vk::VkSampleCountFlagBits samples, vk::VkImageTiling tiling, uint32_t mipLevels,
5356 vk::VkSharingMode sharingMode)
5357 {
5358
5359 if (imageType == VK_IMAGE_TYPE_3D)
5360 DE_ASSERT(arrayLayers == 1);
5361 DE_ASSERT(extent.width > 0 && extent.height > 0 && extent.depth > 0);
5362 DE_ASSERT(mipLevels > 0 && arrayLayers > 0);
5363
5364 // Color attachment.
5365 const VkImageCreateInfo colorAttachmentCreateInfo = {
5366 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
5367 nullptr, // const void* pNext;
5368 0u, // VkImageCreateFlags flags;
5369 imageType, // VkImageType imageType;
5370 imageFormat, // VkFormat format;
5371 extent, // VkExtent3D extent;
5372 mipLevels, // uint32_t mipLevels;
5373 arrayLayers, // uint32_t arrayLayers;
5374 samples, // VkSampleCountFlagBits samples;
5375 tiling, // VkImageTiling tiling;
5376 usage, // VkImageUsageFlags usage;
5377 sharingMode, // VkSharingMode sharingMode;
5378 0u, // uint32_t queueFamilyIndexCount;
5379 nullptr, // const uint32_t* pQueueFamilyIndices;
5380 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
5381 };
5382 image = std::unique_ptr<ImageWithMemory>(
5383 new ImageWithMemory(vkd, device, alloc, colorAttachmentCreateInfo, MemoryRequirement::Any));
5384
5385 VkImageViewType viewType;
5386 switch (imageType)
5387 {
5388 case VK_IMAGE_TYPE_1D:
5389 viewType = ((arrayLayers == 1) ? VK_IMAGE_VIEW_TYPE_1D : VK_IMAGE_VIEW_TYPE_1D_ARRAY);
5390 break;
5391 case VK_IMAGE_TYPE_2D:
5392 viewType = ((arrayLayers == 1) ? VK_IMAGE_VIEW_TYPE_2D : VK_IMAGE_VIEW_TYPE_2D_ARRAY);
5393 break;
5394 case VK_IMAGE_TYPE_3D:
5395 viewType = VK_IMAGE_VIEW_TYPE_3D;
5396 break;
5397 default:
5398 viewType = VK_IMAGE_VIEW_TYPE_LAST;
5399 DE_ASSERT(imageType <= VK_IMAGE_TYPE_3D);
5400 }
5401
5402 // Color attachment view.
5403 imageView = makeImageView(vkd, device, (*image).get(), viewType, imageFormat, ssr);
5404
5405 // Verification buffer.
5406 const auto tcuFormat = mapVkFormat(imageFormat);
5407 const auto verificationBufferSize =
5408 tcuFormat.getPixelSize() * extent.width * extent.height * arrayLayers * extent.depth;
5409 const auto verificationBufferCreateInfo =
5410 makeBufferCreateInfo(verificationBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
5411
5412 buffer = std::unique_ptr<BufferWithMemory>(
5413 new BufferWithMemory(vkd, device, alloc, verificationBufferCreateInfo, MemoryRequirement::HostVisible));
5414 size = verificationBufferSize;
5415 }
5416
getImage() const5417 VkImage ImageWithBuffer::getImage() const
5418 {
5419 return (*image).get();
5420 }
5421
getImageView() const5422 VkImageView ImageWithBuffer::getImageView() const
5423 {
5424 return imageView.get();
5425 }
5426
getBuffer() const5427 VkBuffer ImageWithBuffer::getBuffer() const
5428 {
5429 return (*buffer).get();
5430 }
5431
getBufferSize() const5432 VkDeviceSize ImageWithBuffer::getBufferSize() const
5433 {
5434 return size;
5435 }
5436
getImageAllocation() const5437 Allocation &ImageWithBuffer::getImageAllocation() const
5438 {
5439 return (*image).getAllocation();
5440 }
5441
getBufferAllocation() const5442 Allocation &ImageWithBuffer::getBufferAllocation() const
5443 {
5444 return (*buffer).getAllocation();
5445 }
5446
5447 #ifndef CTS_USES_VULKANSC
5448
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)5449 void allocateAndBindSparseImage(const DeviceInterface &vk, VkDevice device, const VkPhysicalDevice physicalDevice,
5450 const InstanceInterface &instance, const VkImageCreateInfo &imageCreateInfo,
5451 const VkSemaphore &signalSemaphore, VkQueue queue, Allocator &allocator,
5452 std::vector<de::SharedPtr<Allocation>> &allocations, tcu::TextureFormat format,
5453 VkImage destImage)
5454 {
5455 const VkImageAspectFlags imageAspectFlags = getImageAspectFlags(format);
5456 const VkPhysicalDeviceProperties deviceProperties = getPhysicalDeviceProperties(instance, physicalDevice);
5457 const VkPhysicalDeviceMemoryProperties deviceMemoryProperties =
5458 getPhysicalDeviceMemoryProperties(instance, physicalDevice);
5459 uint32_t sparseMemoryReqCount = 0;
5460
5461 // Check if the image format supports sparse operations
5462 if (!checkSparseImageFormatSupport(physicalDevice, instance, imageCreateInfo))
5463 TCU_THROW(NotSupportedError, "The image format does not support sparse operations.");
5464
5465 vk.getImageSparseMemoryRequirements(device, destImage, &sparseMemoryReqCount, nullptr);
5466
5467 DE_ASSERT(sparseMemoryReqCount != 0);
5468
5469 std::vector<VkSparseImageMemoryRequirements> sparseImageMemoryRequirements;
5470 sparseImageMemoryRequirements.resize(sparseMemoryReqCount);
5471
5472 vk.getImageSparseMemoryRequirements(device, destImage, &sparseMemoryReqCount, &sparseImageMemoryRequirements[0]);
5473
5474 const uint32_t noMatchFound = ~((uint32_t)0);
5475
5476 std::vector<uint32_t> aspectIndices;
5477
5478 VkImageAspectFlags memReqAspectFlags = 0;
5479
5480 for (uint32_t memoryReqNdx = 0; memoryReqNdx < sparseMemoryReqCount; ++memoryReqNdx)
5481 {
5482 if (sparseImageMemoryRequirements[memoryReqNdx].formatProperties.aspectMask & imageAspectFlags)
5483 {
5484 aspectIndices.push_back(memoryReqNdx);
5485 memReqAspectFlags |= sparseImageMemoryRequirements[memoryReqNdx].formatProperties.aspectMask;
5486 }
5487 }
5488
5489 uint32_t metadataAspectIndex = noMatchFound;
5490 for (uint32_t memoryReqNdx = 0; memoryReqNdx < sparseMemoryReqCount; ++memoryReqNdx)
5491 {
5492 if (sparseImageMemoryRequirements[memoryReqNdx].formatProperties.aspectMask & VK_IMAGE_ASPECT_METADATA_BIT)
5493 {
5494 metadataAspectIndex = memoryReqNdx;
5495 break;
5496 }
5497 }
5498
5499 if (memReqAspectFlags != imageAspectFlags)
5500 TCU_THROW(NotSupportedError, "Required image aspect not supported.");
5501
5502 const VkMemoryRequirements memoryRequirements = getImageMemoryRequirements(vk, device, destImage);
5503
5504 uint32_t memoryType = noMatchFound;
5505 for (uint32_t memoryTypeNdx = 0; memoryTypeNdx < deviceMemoryProperties.memoryTypeCount; ++memoryTypeNdx)
5506 {
5507 if ((memoryRequirements.memoryTypeBits & (1u << memoryTypeNdx)) != 0 &&
5508 MemoryRequirement::Any.matchesHeap(deviceMemoryProperties.memoryTypes[memoryTypeNdx].propertyFlags))
5509 {
5510 memoryType = memoryTypeNdx;
5511 break;
5512 }
5513 }
5514
5515 if (memoryType == noMatchFound)
5516 TCU_THROW(NotSupportedError, "No matching memory type found.");
5517
5518 if (memoryRequirements.size > deviceProperties.limits.sparseAddressSpaceSize)
5519 TCU_THROW(NotSupportedError, "Required memory size for sparse resource exceeds device limits.");
5520
5521 std::vector<VkSparseImageMemoryBind> imageResidencyMemoryBinds;
5522 std::vector<VkSparseMemoryBind> imageMipTailMemoryBinds;
5523
5524 for (uint32_t aspectIndex : aspectIndices)
5525 {
5526 const VkSparseImageMemoryRequirements aspectRequirements = sparseImageMemoryRequirements[aspectIndex];
5527 VkExtent3D blockSize = aspectRequirements.formatProperties.imageGranularity;
5528
5529 for (uint32_t layerNdx = 0; layerNdx < imageCreateInfo.arrayLayers; ++layerNdx)
5530 {
5531 for (uint32_t mipLevelNdx = 0; mipLevelNdx < aspectRequirements.imageMipTailFirstLod; ++mipLevelNdx)
5532 {
5533 const VkExtent3D mipExtent = mipLevelExtents(imageCreateInfo.extent, mipLevelNdx);
5534 const tcu::UVec3 numSparseBinds = alignedDivide(mipExtent, blockSize);
5535 const tcu::UVec3 lastBlockExtent = tcu::UVec3(
5536 mipExtent.width % blockSize.width ? mipExtent.width % blockSize.width : blockSize.width,
5537 mipExtent.height % blockSize.height ? mipExtent.height % blockSize.height : blockSize.height,
5538 mipExtent.depth % blockSize.depth ? mipExtent.depth % blockSize.depth : blockSize.depth);
5539
5540 for (uint32_t z = 0; z < numSparseBinds.z(); ++z)
5541 for (uint32_t y = 0; y < numSparseBinds.y(); ++y)
5542 for (uint32_t x = 0; x < numSparseBinds.x(); ++x)
5543 {
5544 const VkMemoryRequirements allocRequirements = {
5545 // 28.7.5 alignment shows the block size in bytes
5546 memoryRequirements.alignment, // VkDeviceSize size;
5547 memoryRequirements.alignment, // VkDeviceSize alignment;
5548 memoryRequirements.memoryTypeBits, // uint32_t memoryTypeBits;
5549 };
5550
5551 de::SharedPtr<Allocation> allocation(
5552 allocator.allocate(allocRequirements, MemoryRequirement::Any).release());
5553 allocations.push_back(allocation);
5554
5555 VkOffset3D offset;
5556 offset.x = x * blockSize.width;
5557 offset.y = y * blockSize.height;
5558 offset.z = z * blockSize.depth;
5559
5560 VkExtent3D extent;
5561 extent.width = (x == numSparseBinds.x() - 1) ? lastBlockExtent.x() : blockSize.width;
5562 extent.height = (y == numSparseBinds.y() - 1) ? lastBlockExtent.y() : blockSize.height;
5563 extent.depth = (z == numSparseBinds.z() - 1) ? lastBlockExtent.z() : blockSize.depth;
5564
5565 const VkSparseImageMemoryBind imageMemoryBind = {
5566 {
5567 aspectRequirements.formatProperties.aspectMask, // VkImageAspectFlags aspectMask;
5568 mipLevelNdx, // uint32_t mipLevel;
5569 layerNdx, // uint32_t arrayLayer;
5570 }, // VkImageSubresource subresource;
5571 offset, // VkOffset3D offset;
5572 extent, // VkExtent3D extent;
5573 allocation->getMemory(), // VkDeviceMemory memory;
5574 allocation->getOffset(), // VkDeviceSize memoryOffset;
5575 0u, // VkSparseMemoryBindFlags flags;
5576 };
5577
5578 imageResidencyMemoryBinds.push_back(imageMemoryBind);
5579 }
5580 }
5581
5582 // Handle MIP tail. There are two cases to consider here:
5583 //
5584 // 1) VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT is requested by the driver: each layer needs a separate tail.
5585 // 2) otherwise: only one tail is needed.
5586 if (aspectRequirements.imageMipTailSize > 0)
5587 {
5588 if (layerNdx == 0 ||
5589 (aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) == 0)
5590 {
5591 const VkMemoryRequirements allocRequirements = {
5592 aspectRequirements.imageMipTailSize, // VkDeviceSize size;
5593 memoryRequirements.alignment, // VkDeviceSize alignment;
5594 memoryRequirements.memoryTypeBits, // uint32_t memoryTypeBits;
5595 };
5596
5597 const de::SharedPtr<Allocation> allocation(
5598 allocator.allocate(allocRequirements, MemoryRequirement::Any).release());
5599
5600 const VkSparseMemoryBind imageMipTailMemoryBind = {
5601 aspectRequirements.imageMipTailOffset +
5602 layerNdx * aspectRequirements.imageMipTailStride, // VkDeviceSize resourceOffset;
5603 aspectRequirements.imageMipTailSize, // VkDeviceSize size;
5604 allocation->getMemory(), // VkDeviceMemory memory;
5605 allocation->getOffset(), // VkDeviceSize memoryOffset;
5606 0u, // VkSparseMemoryBindFlags flags;
5607 };
5608
5609 allocations.push_back(allocation);
5610
5611 imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
5612 }
5613 }
5614
5615 // Handle Metadata. Similarly to MIP tail in aspectRequirements, there are two cases to consider here:
5616 //
5617 // 1) VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT is requested by the driver: each layer needs a separate tail.
5618 // 2) otherwise:
5619 if (metadataAspectIndex != noMatchFound)
5620 {
5621 const VkSparseImageMemoryRequirements metadataAspectRequirements =
5622 sparseImageMemoryRequirements[metadataAspectIndex];
5623
5624 if (layerNdx == 0 || (metadataAspectRequirements.formatProperties.flags &
5625 VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) == 0)
5626 {
5627 const VkMemoryRequirements metadataAllocRequirements = {
5628 metadataAspectRequirements.imageMipTailSize, // VkDeviceSize size;
5629 memoryRequirements.alignment, // VkDeviceSize alignment;
5630 memoryRequirements.memoryTypeBits, // uint32_t memoryTypeBits;
5631 };
5632 const de::SharedPtr<Allocation> metadataAllocation(
5633 allocator.allocate(metadataAllocRequirements, MemoryRequirement::Any).release());
5634
5635 const VkSparseMemoryBind metadataMipTailMemoryBind = {
5636 metadataAspectRequirements.imageMipTailOffset +
5637 layerNdx * metadataAspectRequirements.imageMipTailStride, // VkDeviceSize resourceOffset;
5638 metadataAspectRequirements.imageMipTailSize, // VkDeviceSize size;
5639 metadataAllocation->getMemory(), // VkDeviceMemory memory;
5640 metadataAllocation->getOffset(), // VkDeviceSize memoryOffset;
5641 VK_SPARSE_MEMORY_BIND_METADATA_BIT // VkSparseMemoryBindFlags flags;
5642 };
5643
5644 allocations.push_back(metadataAllocation);
5645
5646 imageMipTailMemoryBinds.push_back(metadataMipTailMemoryBind);
5647 }
5648 }
5649 }
5650 }
5651
5652 VkBindSparseInfo bindSparseInfo = {
5653 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, //VkStructureType sType;
5654 nullptr, //const void* pNext;
5655 0u, //uint32_t waitSemaphoreCount;
5656 nullptr, //const VkSemaphore* pWaitSemaphores;
5657 0u, //uint32_t bufferBindCount;
5658 nullptr, //const VkSparseBufferMemoryBindInfo* pBufferBinds;
5659 0u, //uint32_t imageOpaqueBindCount;
5660 nullptr, //const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
5661 0u, //uint32_t imageBindCount;
5662 nullptr, //const VkSparseImageMemoryBindInfo* pImageBinds;
5663 1u, //uint32_t signalSemaphoreCount;
5664 &signalSemaphore //const VkSemaphore* pSignalSemaphores;
5665 };
5666
5667 VkSparseImageMemoryBindInfo imageResidencyBindInfo;
5668 VkSparseImageOpaqueMemoryBindInfo imageMipTailBindInfo;
5669
5670 if (imageResidencyMemoryBinds.size() > 0)
5671 {
5672 imageResidencyBindInfo.image = destImage;
5673 imageResidencyBindInfo.bindCount = static_cast<uint32_t>(imageResidencyMemoryBinds.size());
5674 imageResidencyBindInfo.pBinds = &imageResidencyMemoryBinds[0];
5675
5676 bindSparseInfo.imageBindCount = 1u;
5677 bindSparseInfo.pImageBinds = &imageResidencyBindInfo;
5678 }
5679
5680 if (imageMipTailMemoryBinds.size() > 0)
5681 {
5682 imageMipTailBindInfo.image = destImage;
5683 imageMipTailBindInfo.bindCount = static_cast<uint32_t>(imageMipTailMemoryBinds.size());
5684 imageMipTailBindInfo.pBinds = &imageMipTailMemoryBinds[0];
5685
5686 bindSparseInfo.imageOpaqueBindCount = 1u;
5687 bindSparseInfo.pImageOpaqueBinds = &imageMipTailBindInfo;
5688 }
5689
5690 VK_CHECK(vk.queueBindSparse(queue, 1u, &bindSparseInfo, VK_NULL_HANDLE));
5691 }
5692
checkSparseImageFormatSupport(const VkPhysicalDevice physicalDevice,const InstanceInterface & instance,const VkFormat format,const VkImageType imageType,const VkSampleCountFlagBits sampleCount,const VkImageUsageFlags usageFlags,const VkImageTiling imageTiling)5693 bool checkSparseImageFormatSupport(const VkPhysicalDevice physicalDevice, const InstanceInterface &instance,
5694 const VkFormat format, const VkImageType imageType,
5695 const VkSampleCountFlagBits sampleCount, const VkImageUsageFlags usageFlags,
5696 const VkImageTiling imageTiling)
5697 {
5698 const auto propVec = getPhysicalDeviceSparseImageFormatProperties(instance, physicalDevice, format, imageType,
5699 sampleCount, usageFlags, imageTiling);
5700 return (propVec.size() != 0);
5701 }
5702
checkSparseImageFormatSupport(const VkPhysicalDevice physicalDevice,const InstanceInterface & instance,const VkImageCreateInfo & imageCreateInfo)5703 bool checkSparseImageFormatSupport(const VkPhysicalDevice physicalDevice, const InstanceInterface &instance,
5704 const VkImageCreateInfo &imageCreateInfo)
5705 {
5706 return checkSparseImageFormatSupport(physicalDevice, instance, imageCreateInfo.format, imageCreateInfo.imageType,
5707 imageCreateInfo.samples, imageCreateInfo.usage, imageCreateInfo.tiling);
5708 }
5709 #endif // CTS_USES_VULKANSC
5710
5711 } // namespace vk
5712