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