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