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 "tcuTextureUtil.hpp" 28 29 namespace vk 30 { 31 32 bool isFloatFormat (VkFormat format) 33 { 34 return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_FLOATING_POINT; 35 } 36 37 bool isUnormFormat (VkFormat format) 38 { 39 return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 40 } 41 42 bool isSnormFormat (VkFormat format) 43 { 44 return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT; 45 } 46 47 bool isIntFormat (VkFormat format) 48 { 49 return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER; 50 } 51 52 bool isUintFormat (VkFormat format) 53 { 54 return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER; 55 } 56 57 bool isDepthStencilFormat (VkFormat format) 58 { 59 if (isCompressedFormat(format)) 60 return false; 61 62 const tcu::TextureFormat tcuFormat = mapVkFormat(format); 63 return tcuFormat.order == tcu::TextureFormat::D || tcuFormat.order == tcu::TextureFormat::S || tcuFormat.order == tcu::TextureFormat::DS; 64 } 65 66 bool isSrgbFormat (VkFormat format) 67 { 68 switch (mapVkFormat(format).order) 69 { 70 case tcu::TextureFormat::sR: 71 case tcu::TextureFormat::sRG: 72 case tcu::TextureFormat::sRGB: 73 case tcu::TextureFormat::sRGBA: 74 case tcu::TextureFormat::sBGR: 75 case tcu::TextureFormat::sBGRA: 76 return true; 77 78 default: 79 return false; 80 } 81 } 82 83 bool isCompressedFormat (VkFormat format) 84 { 85 // update this mapping if VkFormat changes 86 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185); 87 88 switch (format) 89 { 90 case VK_FORMAT_BC1_RGB_UNORM_BLOCK: 91 case VK_FORMAT_BC1_RGB_SRGB_BLOCK: 92 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: 93 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: 94 case VK_FORMAT_BC2_UNORM_BLOCK: 95 case VK_FORMAT_BC2_SRGB_BLOCK: 96 case VK_FORMAT_BC3_UNORM_BLOCK: 97 case VK_FORMAT_BC3_SRGB_BLOCK: 98 case VK_FORMAT_BC4_UNORM_BLOCK: 99 case VK_FORMAT_BC4_SNORM_BLOCK: 100 case VK_FORMAT_BC5_UNORM_BLOCK: 101 case VK_FORMAT_BC5_SNORM_BLOCK: 102 case VK_FORMAT_BC6H_UFLOAT_BLOCK: 103 case VK_FORMAT_BC6H_SFLOAT_BLOCK: 104 case VK_FORMAT_BC7_UNORM_BLOCK: 105 case VK_FORMAT_BC7_SRGB_BLOCK: 106 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: 107 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: 108 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: 109 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: 110 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: 111 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: 112 case VK_FORMAT_EAC_R11_UNORM_BLOCK: 113 case VK_FORMAT_EAC_R11_SNORM_BLOCK: 114 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: 115 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: 116 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: 117 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: 118 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: 119 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: 120 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: 121 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: 122 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: 123 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: 124 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: 125 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: 126 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: 127 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: 128 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: 129 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: 130 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: 131 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: 132 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: 133 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: 134 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: 135 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: 136 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: 137 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: 138 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: 139 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: 140 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: 141 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: 142 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: 143 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: 144 return true; 145 146 default: 147 return false; 148 } 149 } 150 151 bool isYCbCrFormat (VkFormat format) 152 { 153 switch (format) 154 { 155 case VK_FORMAT_G8B8G8R8_422_UNORM_KHR: 156 case VK_FORMAT_B8G8R8G8_422_UNORM_KHR: 157 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR: 158 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR: 159 case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR: 160 case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR: 161 case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR: 162 case VK_FORMAT_R10X6_UNORM_PACK16_KHR: 163 case VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR: 164 case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: 165 case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: 166 case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: 167 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: 168 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: 169 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: 170 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: 171 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: 172 case VK_FORMAT_R12X4_UNORM_PACK16_KHR: 173 case VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR: 174 case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: 175 case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: 176 case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: 177 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: 178 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: 179 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: 180 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: 181 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: 182 case VK_FORMAT_G16B16G16R16_422_UNORM_KHR: 183 case VK_FORMAT_B16G16R16G16_422_UNORM_KHR: 184 case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR: 185 case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR: 186 case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR: 187 case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR: 188 case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR: 189 return true; 190 191 default: 192 return false; 193 } 194 } 195 196 const PlanarFormatDescription& getYCbCrPlanarFormatDescription (VkFormat format) 197 { 198 using tcu::TextureFormat; 199 200 const deUint32 chanR = PlanarFormatDescription::CHANNEL_R; 201 const deUint32 chanG = PlanarFormatDescription::CHANNEL_G; 202 const deUint32 chanB = PlanarFormatDescription::CHANNEL_B; 203 const deUint32 chanA = PlanarFormatDescription::CHANNEL_A; 204 205 const deUint8 unorm = (deUint8)tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 206 207 static const PlanarFormatDescription s_formatInfo[] = 208 { 209 // VK_FORMAT_G8B8G8R8_422_UNORM_KHR 210 { 211 1, // planes 212 chanR|chanG|chanB, 213 { 214 // Size WDiv HDiv 215 { 4, 2, 1 }, 216 { 0, 0, 0 }, 217 { 0, 0, 0 }, 218 }, 219 { 220 // Plane Type Offs Size Stride 221 { 0, unorm, 24, 8, 4 }, // R 222 { 0, unorm, 0, 8, 2 }, // G 223 { 0, unorm, 8, 8, 4 }, // B 224 { 0, 0, 0, 0, 0 } 225 } 226 }, 227 // VK_FORMAT_B8G8R8G8_422_UNORM_KHR 228 { 229 1, // planes 230 chanR|chanG|chanB, 231 { 232 // Size WDiv HDiv 233 { 4, 2, 1 }, 234 { 0, 0, 0 }, 235 { 0, 0, 0 }, 236 }, 237 { 238 // Plane Type Offs Size Stride 239 { 0, unorm, 16, 8, 4 }, // R 240 { 0, unorm, 8, 8, 2 }, // G 241 { 0, unorm, 0, 8, 4 }, // B 242 { 0, 0, 0, 0, 0 } 243 } 244 }, 245 // VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR 246 { 247 3, // planes 248 chanR|chanG|chanB, 249 { 250 // Size WDiv HDiv 251 { 1, 1, 1 }, 252 { 1, 2, 2 }, 253 { 1, 2, 2 }, 254 }, 255 { 256 // Plane Type Offs Size Stride 257 { 2, unorm, 0, 8, 1 }, // R 258 { 0, unorm, 0, 8, 1 }, // G 259 { 1, unorm, 0, 8, 1 }, // B 260 { 0, 0, 0, 0, 0 } 261 } 262 }, 263 // VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR 264 { 265 2, // planes 266 chanR|chanG|chanB, 267 { 268 // Size WDiv HDiv 269 { 1, 1, 1 }, 270 { 2, 2, 2 }, 271 { 0, 0, 0 }, 272 }, 273 { 274 // Plane Type Offs Size Stride 275 { 1, unorm, 8, 8, 2 }, // R 276 { 0, unorm, 0, 8, 1 }, // G 277 { 1, unorm, 0, 8, 2 }, // B 278 { 0, 0, 0, 0, 0 } 279 } 280 }, 281 // VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR 282 { 283 3, // planes 284 chanR|chanG|chanB, 285 { 286 // Size WDiv HDiv 287 { 1, 1, 1 }, 288 { 1, 2, 1 }, 289 { 1, 2, 1 }, 290 }, 291 { 292 // Plane Type Offs Size Stride 293 { 2, unorm, 0, 8, 1 }, // R 294 { 0, unorm, 0, 8, 1 }, // G 295 { 1, unorm, 0, 8, 1 }, // B 296 { 0, 0, 0, 0, 0 } 297 } 298 }, 299 // VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR 300 { 301 2, // planes 302 chanR|chanG|chanB, 303 { 304 // Size WDiv HDiv 305 { 1, 1, 1 }, 306 { 2, 2, 1 }, 307 { 0, 0, 0 }, 308 }, 309 { 310 // Plane Type Offs Size Stride 311 { 1, unorm, 8, 8, 2 }, // R 312 { 0, unorm, 0, 8, 1 }, // G 313 { 1, unorm, 0, 8, 2 }, // B 314 { 0, 0, 0, 0, 0 } 315 } 316 }, 317 // VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR 318 { 319 3, // planes 320 chanR|chanG|chanB, 321 { 322 // Size WDiv HDiv 323 { 1, 1, 1 }, 324 { 1, 1, 1 }, 325 { 1, 1, 1 }, 326 }, 327 { 328 // Plane Type Offs Size Stride 329 { 2, unorm, 0, 8, 1 }, // R 330 { 0, unorm, 0, 8, 1 }, // G 331 { 1, unorm, 0, 8, 1 }, // B 332 { 0, 0, 0, 0, 0 } 333 } 334 }, 335 // VK_FORMAT_R10X6_UNORM_PACK16_KHR 336 { 337 1, // planes 338 chanR, 339 { 340 // Size WDiv HDiv 341 { 2, 1, 1 }, 342 { 0, 0, 0 }, 343 { 0, 0, 0 }, 344 }, 345 { 346 // Plane Type Offs Size Stride 347 { 0, unorm, 6, 10, 2 }, // R 348 { 0, 0, 0, 0, 0 }, 349 { 0, 0, 0, 0, 0 }, 350 { 0, 0, 0, 0, 0 }, 351 } 352 }, 353 // VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR 354 { 355 1, // planes 356 chanR|chanG, 357 { 358 // Size WDiv HDiv 359 { 4, 1, 1 }, 360 { 0, 0, 0 }, 361 { 0, 0, 0 }, 362 }, 363 { 364 // Plane Type Offs Size Stride 365 { 0, unorm, 6, 10, 4 }, // R 366 { 0, unorm, 22, 10, 4 }, // G 367 { 0, 0, 0, 0, 0 }, 368 { 0, 0, 0, 0, 0 }, 369 } 370 }, 371 // VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR 372 { 373 1, // planes 374 chanR|chanG|chanB|chanA, 375 { 376 // Size WDiv HDiv 377 { 8, 1, 1 }, 378 { 0, 0, 0 }, 379 { 0, 0, 0 }, 380 }, 381 { 382 // Plane Type Offs Size Stride 383 { 0, unorm, 6, 10, 8 }, // R 384 { 0, unorm, 22, 10, 8 }, // G 385 { 0, unorm, 38, 10, 8 }, // B 386 { 0, unorm, 54, 10, 8 }, // A 387 } 388 }, 389 // VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR 390 { 391 1, // planes 392 chanR|chanG|chanB, 393 { 394 // Size WDiv HDiv 395 { 8, 2, 1 }, 396 { 0, 0, 0 }, 397 { 0, 0, 0 }, 398 }, 399 { 400 // Plane Type Offs Size Stride 401 { 0, unorm, 54, 10, 8 }, // R 402 { 0, unorm, 6, 10, 4 }, // G 403 { 0, unorm, 22, 10, 8 }, // B 404 { 0, 0, 0, 0, 0 } 405 } 406 }, 407 // VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR 408 { 409 1, // planes 410 chanR|chanG|chanB, 411 { 412 // Size WDiv HDiv 413 { 8, 2, 1 }, 414 { 0, 0, 0 }, 415 { 0, 0, 0 }, 416 }, 417 { 418 // Plane Type Offs Size Stride 419 { 0, unorm, 38, 10, 8 }, // R 420 { 0, unorm, 22, 10, 4 }, // G 421 { 0, unorm, 6, 10, 8 }, // B 422 { 0, 0, 0, 0, 0 } 423 } 424 }, 425 // VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR 426 { 427 3, // planes 428 chanR|chanG|chanB, 429 { 430 // Size WDiv HDiv 431 { 2, 1, 1 }, 432 { 2, 2, 2 }, 433 { 2, 2, 2 }, 434 }, 435 { 436 // Plane Type Offs Size Stride 437 { 2, unorm, 6, 10, 2 }, // R 438 { 0, unorm, 6, 10, 2 }, // G 439 { 1, unorm, 6, 10, 2 }, // B 440 { 0, 0, 0, 0, 0 } 441 } 442 }, 443 // VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR 444 { 445 2, // planes 446 chanR|chanG|chanB, 447 { 448 // Size WDiv HDiv 449 { 2, 1, 1 }, 450 { 4, 2, 2 }, 451 { 0, 0, 0 }, 452 }, 453 { 454 // Plane Type Offs Size Stride 455 { 1, unorm, 22, 10, 4 }, // R 456 { 0, unorm, 6, 10, 2 }, // G 457 { 1, unorm, 6, 10, 4 }, // B 458 { 0, 0, 0, 0, 0 } 459 } 460 }, 461 // VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR 462 { 463 3, // planes 464 chanR|chanG|chanB, 465 { 466 // Size WDiv HDiv 467 { 2, 1, 1 }, 468 { 2, 2, 1 }, 469 { 2, 2, 1 }, 470 }, 471 { 472 // Plane Type Offs Size Stride 473 { 2, unorm, 6, 10, 2 }, // R 474 { 0, unorm, 6, 10, 2 }, // G 475 { 1, unorm, 6, 10, 2 }, // B 476 { 0, 0, 0, 0, 0 } 477 } 478 }, 479 // VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR 480 { 481 2, // planes 482 chanR|chanG|chanB, 483 { 484 // Size WDiv HDiv 485 { 2, 1, 1 }, 486 { 4, 2, 1 }, 487 { 0, 0, 0 }, 488 }, 489 { 490 // Plane Type Offs Size Stride 491 { 1, unorm, 22, 10, 4 }, // R 492 { 0, unorm, 6, 10, 2 }, // G 493 { 1, unorm, 6, 10, 4 }, // B 494 { 0, 0, 0, 0, 0 } 495 } 496 }, 497 // VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR 498 { 499 3, // planes 500 chanR|chanG|chanB, 501 { 502 // Size WDiv HDiv 503 { 2, 1, 1 }, 504 { 2, 1, 1 }, 505 { 2, 1, 1 }, 506 }, 507 { 508 // Plane Type Offs Size Stride 509 { 2, unorm, 6, 10, 2 }, // R 510 { 0, unorm, 6, 10, 2 }, // G 511 { 1, unorm, 6, 10, 2 }, // B 512 { 0, 0, 0, 0, 0 } 513 } 514 }, 515 // VK_FORMAT_R12X4_UNORM_PACK16_KHR 516 { 517 1, // planes 518 chanR, 519 { 520 // Size WDiv HDiv 521 { 2, 1, 1 }, 522 { 0, 0, 0 }, 523 { 0, 0, 0 }, 524 }, 525 { 526 // Plane Type Offs Size Stride 527 { 0, unorm, 4, 12, 2 }, // R 528 { 0, 0, 0, 0, 0 }, 529 { 0, 0, 0, 0, 0 }, 530 { 0, 0, 0, 0, 0 }, 531 } 532 }, 533 // VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR 534 { 535 1, // planes 536 chanR|chanG, 537 { 538 // Size WDiv HDiv 539 { 4, 1, 1 }, 540 { 0, 0, 0 }, 541 { 0, 0, 0 }, 542 }, 543 { 544 // Plane Type Offs Size Stride 545 { 0, unorm, 4, 12, 4 }, // R 546 { 0, unorm, 20, 12, 4 }, // G 547 { 0, 0, 0, 0, 0 }, 548 { 0, 0, 0, 0, 0 }, 549 } 550 }, 551 // VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR 552 { 553 1, // planes 554 chanR|chanG|chanB|chanA, 555 { 556 // Size WDiv HDiv 557 { 8, 1, 1 }, 558 { 0, 0, 0 }, 559 { 0, 0, 0 }, 560 }, 561 { 562 // Plane Type Offs Size Stride 563 { 0, unorm, 4, 12, 8 }, // R 564 { 0, unorm, 20, 12, 8 }, // G 565 { 0, unorm, 36, 12, 8 }, // B 566 { 0, unorm, 52, 12, 8 }, // A 567 } 568 }, 569 // VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR 570 { 571 1, // planes 572 chanR|chanG|chanB, 573 { 574 // Size WDiv HDiv 575 { 8, 2, 1 }, 576 { 0, 0, 0 }, 577 { 0, 0, 0 }, 578 }, 579 { 580 // Plane Type Offs Size Stride 581 { 0, unorm, 52, 12, 8 }, // R 582 { 0, unorm, 4, 12, 4 }, // G 583 { 0, unorm, 20, 12, 8 }, // B 584 { 0, 0, 0, 0, 0 } 585 } 586 }, 587 // VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR 588 { 589 1, // planes 590 chanR|chanG|chanB, 591 { 592 // Size WDiv HDiv 593 { 8, 2, 1 }, 594 { 0, 0, 0 }, 595 { 0, 0, 0 }, 596 }, 597 { 598 // Plane Type Offs Size Stride 599 { 0, unorm, 36, 12, 8 }, // R 600 { 0, unorm, 20, 12, 4 }, // G 601 { 0, unorm, 4, 12, 8 }, // B 602 { 0, 0, 0, 0, 0 } 603 } 604 }, 605 // VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR 606 { 607 3, // planes 608 chanR|chanG|chanB, 609 { 610 // Size WDiv HDiv 611 { 2, 1, 1 }, 612 { 2, 2, 2 }, 613 { 2, 2, 2 }, 614 }, 615 { 616 // Plane Type Offs Size Stride 617 { 2, unorm, 4, 12, 2 }, // R 618 { 0, unorm, 4, 12, 2 }, // G 619 { 1, unorm, 4, 12, 2 }, // B 620 { 0, 0, 0, 0, 0 } 621 } 622 }, 623 // VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR 624 { 625 2, // planes 626 chanR|chanG|chanB, 627 { 628 // Size WDiv HDiv 629 { 2, 1, 1 }, 630 { 4, 2, 2 }, 631 { 0, 0, 0 }, 632 }, 633 { 634 // Plane Type Offs Size Stride 635 { 1, unorm, 20, 12, 4 }, // R 636 { 0, unorm, 4, 12, 2 }, // G 637 { 1, unorm, 4, 12, 4 }, // B 638 { 0, 0, 0, 0, 0 } 639 } 640 }, 641 // VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR 642 { 643 3, // planes 644 chanR|chanG|chanB, 645 { 646 // Size WDiv HDiv 647 { 2, 1, 1 }, 648 { 2, 2, 1 }, 649 { 2, 2, 1 }, 650 }, 651 { 652 // Plane Type Offs Size Stride 653 { 2, unorm, 4, 12, 2 }, // R 654 { 0, unorm, 4, 12, 2 }, // G 655 { 1, unorm, 4, 12, 2 }, // B 656 { 0, 0, 0, 0, 0 } 657 } 658 }, 659 // VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR 660 { 661 2, // planes 662 chanR|chanG|chanB, 663 { 664 // Size WDiv HDiv 665 { 2, 1, 1 }, 666 { 4, 2, 1 }, 667 { 0, 0, 0 }, 668 }, 669 { 670 // Plane Type Offs Size Stride 671 { 1, unorm, 20, 12, 4 }, // R 672 { 0, unorm, 4, 12, 2 }, // G 673 { 1, unorm, 4, 12, 4 }, // B 674 { 0, 0, 0, 0, 0 } 675 } 676 }, 677 // VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR 678 { 679 3, // planes 680 chanR|chanG|chanB, 681 { 682 // Size WDiv HDiv 683 { 2, 1, 1 }, 684 { 2, 1, 1 }, 685 { 2, 1, 1 }, 686 }, 687 { 688 // Plane Type Offs Size Stride 689 { 2, unorm, 4, 12, 2 }, // R 690 { 0, unorm, 4, 12, 2 }, // G 691 { 1, unorm, 4, 12, 2 }, // B 692 { 0, 0, 0, 0, 0 } 693 } 694 }, 695 // VK_FORMAT_G16B16G16R16_422_UNORM_KHR 696 { 697 1, // planes 698 chanR|chanG|chanB, 699 { 700 // Size WDiv HDiv 701 { 8, 2, 1 }, 702 { 0, 0, 0 }, 703 { 0, 0, 0 }, 704 }, 705 { 706 // Plane Type Offs Size Stride 707 { 0, unorm, 48, 16, 8 }, // R 708 { 0, unorm, 0, 16, 4 }, // G 709 { 0, unorm, 16, 16, 8 }, // B 710 { 0, 0, 0, 0, 0 } 711 } 712 }, 713 // VK_FORMAT_B16G16R16G16_422_UNORM_KHR 714 { 715 1, // planes 716 chanR|chanG|chanB, 717 { 718 // Size WDiv HDiv 719 { 8, 2, 1 }, 720 { 0, 0, 0 }, 721 { 0, 0, 0 }, 722 }, 723 { 724 // Plane Type Offs Size Stride 725 { 0, unorm, 32, 16, 8 }, // R 726 { 0, unorm, 16, 16, 4 }, // G 727 { 0, unorm, 0, 16, 8 }, // B 728 { 0, 0, 0, 0, 0 } 729 } 730 }, 731 // VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR 732 { 733 3, // planes 734 chanR|chanG|chanB, 735 { 736 // Size WDiv HDiv 737 { 2, 1, 1 }, 738 { 2, 2, 2 }, 739 { 2, 2, 2 }, 740 }, 741 { 742 // Plane Type Offs Size Stride 743 { 2, unorm, 0, 16, 2 }, // R 744 { 0, unorm, 0, 16, 2 }, // G 745 { 1, unorm, 0, 16, 2 }, // B 746 { 0, 0, 0, 0, 0 } 747 } 748 }, 749 // VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR 750 { 751 2, // planes 752 chanR|chanG|chanB, 753 { 754 // Size WDiv HDiv 755 { 2, 1, 1 }, 756 { 4, 2, 2 }, 757 { 0, 0, 0 }, 758 }, 759 { 760 // Plane Type Offs Size Stride 761 { 1, unorm, 16, 16, 4 }, // R 762 { 0, unorm, 0, 16, 2 }, // G 763 { 1, unorm, 0, 16, 4 }, // B 764 { 0, 0, 0, 0, 0 } 765 } 766 }, 767 // VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR 768 { 769 3, // planes 770 chanR|chanG|chanB, 771 { 772 // Size WDiv HDiv 773 { 2, 1, 1 }, 774 { 2, 2, 1 }, 775 { 2, 2, 1 }, 776 }, 777 { 778 // Plane Type Offs Size Stride 779 { 2, unorm, 0, 16, 2 }, // R 780 { 0, unorm, 0, 16, 2 }, // G 781 { 1, unorm, 0, 16, 2 }, // B 782 { 0, 0, 0, 0, 0 } 783 } 784 }, 785 // VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR 786 { 787 2, // planes 788 chanR|chanG|chanB, 789 { 790 // Size WDiv HDiv 791 { 2, 1, 1 }, 792 { 4, 2, 1 }, 793 { 0, 0, 0 }, 794 }, 795 { 796 // Plane Type Offs Size Stride 797 { 1, unorm, 16, 16, 4 }, // R 798 { 0, unorm, 0, 16, 2 }, // G 799 { 1, unorm, 0, 16, 4 }, // B 800 { 0, 0, 0, 0, 0 } 801 } 802 }, 803 // VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR 804 { 805 3, // planes 806 chanR|chanG|chanB, 807 { 808 // Size WDiv HDiv 809 { 2, 1, 1 }, 810 { 2, 1, 1 }, 811 { 2, 1, 1 }, 812 }, 813 { 814 // Plane Type Offs Size Stride 815 { 2, unorm, 0, 16, 2 }, // R 816 { 0, unorm, 0, 16, 2 }, // G 817 { 1, unorm, 0, 16, 2 }, // B 818 { 0, 0, 0, 0, 0 } 819 } 820 }, 821 }; 822 823 const size_t offset = (size_t)VK_FORMAT_G8B8G8R8_422_UNORM_KHR; 824 825 DE_ASSERT(de::inBounds<size_t>((size_t)format, offset, offset+(size_t)DE_LENGTH_OF_ARRAY(s_formatInfo))); 826 827 return s_formatInfo[(size_t)format-offset]; 828 } 829 830 PlanarFormatDescription getCorePlanarFormatDescription (VkFormat format) 831 { 832 const deUint8 unorm = (deUint8)tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; 833 834 const deUint8 chanR = (deUint8)PlanarFormatDescription::CHANNEL_R; 835 const deUint8 chanG = (deUint8)PlanarFormatDescription::CHANNEL_G; 836 const deUint8 chanB = (deUint8)PlanarFormatDescription::CHANNEL_B; 837 const deUint8 chanA = (deUint8)PlanarFormatDescription::CHANNEL_A; 838 839 DE_ASSERT(de::inBounds<deUint32>(format, VK_FORMAT_UNDEFINED+1, VK_CORE_FORMAT_LAST)); 840 841 #if (DE_ENDIANNESS != DE_LITTLE_ENDIAN) 842 # error "Big-endian is not supported" 843 #endif 844 845 switch (format) 846 { 847 case VK_FORMAT_R8_UNORM: 848 { 849 const PlanarFormatDescription desc = 850 { 851 1, // planes 852 chanR, 853 { 854 // Size WDiv HDiv 855 { 1, 1, 1 }, 856 { 0, 0, 0 }, 857 { 0, 0, 0 }, 858 }, 859 { 860 // Plane Type Offs Size Stride 861 { 0, unorm, 0, 8, 1 }, // R 862 { 0, 0, 0, 0, 0 }, // G 863 { 0, 0, 0, 0, 0 }, // B 864 { 0, 0, 0, 0, 0 } // A 865 } 866 }; 867 return desc; 868 } 869 870 case VK_FORMAT_R8G8_UNORM: 871 { 872 const PlanarFormatDescription desc = 873 { 874 1, // planes 875 chanR|chanG, 876 { 877 // Size WDiv HDiv 878 { 2, 1, 1 }, 879 { 0, 0, 0 }, 880 { 0, 0, 0 }, 881 }, 882 { 883 // Plane Type Offs Size Stride 884 { 0, unorm, 0, 8, 2 }, // R 885 { 0, unorm, 8, 8, 2 }, // G 886 { 0, 0, 0, 0, 0 }, // B 887 { 0, 0, 0, 0, 0 } // A 888 } 889 }; 890 return desc; 891 } 892 893 case VK_FORMAT_R16_UNORM: 894 { 895 const PlanarFormatDescription desc = 896 { 897 1, // planes 898 chanR, 899 { 900 // Size WDiv HDiv 901 { 2, 1, 1 }, 902 { 0, 0, 0 }, 903 { 0, 0, 0 }, 904 }, 905 { 906 // Plane Type Offs Size Stride 907 { 0, unorm, 0, 16, 2 }, // R 908 { 0, 0, 0, 0, 0 }, // G 909 { 0, 0, 0, 0, 0 }, // B 910 { 0, 0, 0, 0, 0 } // A 911 } 912 }; 913 return desc; 914 } 915 916 case VK_FORMAT_R16G16_UNORM: 917 { 918 const PlanarFormatDescription desc = 919 { 920 1, // planes 921 chanR|chanG, 922 { 923 // Size WDiv HDiv 924 { 4, 1, 1 }, 925 { 0, 0, 0 }, 926 { 0, 0, 0 }, 927 }, 928 { 929 // Plane Type Offs Size Stride 930 { 0, unorm, 0, 16, 4 }, // R 931 { 0, unorm, 16, 16, 4 }, // G 932 { 0, 0, 0, 0, 0 }, // B 933 { 0, 0, 0, 0, 0 } // A 934 } 935 }; 936 return desc; 937 } 938 939 case VK_FORMAT_B10G11R11_UFLOAT_PACK32: 940 { 941 const PlanarFormatDescription desc = 942 { 943 1, // planes 944 chanR|chanG|chanB, 945 { 946 // Size WDiv HDiv 947 { 4, 1, 1 }, 948 { 0, 0, 0 }, 949 { 0, 0, 0 }, 950 }, 951 { 952 // Plane Type Offs Size Stride 953 { 0, unorm, 0, 11, 4 }, // R 954 { 0, unorm, 11, 11, 4 }, // G 955 { 0, unorm, 22, 10, 4 }, // B 956 { 0, 0, 0, 0, 0 } // A 957 } 958 }; 959 return desc; 960 } 961 962 case VK_FORMAT_R4G4_UNORM_PACK8: 963 { 964 const PlanarFormatDescription desc = 965 { 966 1, // planes 967 chanR|chanG, 968 { 969 // Size WDiv HDiv 970 { 1, 1, 1 }, 971 { 0, 0, 0 }, 972 { 0, 0, 0 }, 973 }, 974 { 975 // Plane Type Offs Size Stride 976 { 0, unorm, 4, 4, 1 }, // R 977 { 0, unorm, 0, 4, 1 }, // G 978 { 0, 0, 0, 0, 0 }, // B 979 { 0, 0, 0, 0, 0 } // A 980 } 981 }; 982 return desc; 983 } 984 985 case VK_FORMAT_R4G4B4A4_UNORM_PACK16: 986 { 987 const PlanarFormatDescription desc = 988 { 989 1, // planes 990 chanR|chanG|chanB|chanA, 991 { 992 // Size WDiv HDiv 993 { 2, 1, 1 }, 994 { 0, 0, 0 }, 995 { 0, 0, 0 }, 996 }, 997 { 998 // Plane Type Offs Size Stride 999 { 0, unorm, 12, 4, 2 }, // R 1000 { 0, unorm, 8, 4, 2 }, // G 1001 { 0, unorm, 4, 4, 2 }, // B 1002 { 0, unorm, 0, 4, 2 } // A 1003 } 1004 }; 1005 return desc; 1006 } 1007 1008 case VK_FORMAT_B4G4R4A4_UNORM_PACK16: 1009 { 1010 const PlanarFormatDescription desc = 1011 { 1012 1, // planes 1013 chanR|chanG|chanB|chanA, 1014 { 1015 // Size WDiv HDiv 1016 { 2, 1, 1 }, 1017 { 0, 0, 0 }, 1018 { 0, 0, 0 }, 1019 }, 1020 { 1021 // Plane Type Offs Size Stride 1022 { 0, unorm, 4, 4, 2 }, // R 1023 { 0, unorm, 8, 4, 2 }, // G 1024 { 0, unorm, 12, 4, 2 }, // B 1025 { 0, unorm, 0, 4, 2 } // A 1026 } 1027 }; 1028 return desc; 1029 } 1030 1031 case VK_FORMAT_R5G6B5_UNORM_PACK16: 1032 { 1033 const PlanarFormatDescription desc = 1034 { 1035 1, // planes 1036 chanR|chanG|chanB, 1037 { 1038 // Size WDiv HDiv 1039 { 2, 1, 1 }, 1040 { 0, 0, 0 }, 1041 { 0, 0, 0 }, 1042 }, 1043 { 1044 // Plane Type Offs Size Stride 1045 { 0, unorm, 11, 5, 2 }, // R 1046 { 0, unorm, 5, 6, 2 }, // G 1047 { 0, unorm, 0, 5, 2 }, // B 1048 { 0, 0, 0, 0, 0 } // A 1049 } 1050 }; 1051 return desc; 1052 } 1053 1054 case VK_FORMAT_B5G6R5_UNORM_PACK16: 1055 { 1056 const PlanarFormatDescription desc = 1057 { 1058 1, // planes 1059 chanR|chanG|chanB, 1060 { 1061 // Size WDiv HDiv 1062 { 2, 1, 1 }, 1063 { 0, 0, 0 }, 1064 { 0, 0, 0 }, 1065 }, 1066 { 1067 // Plane Type Offs Size Stride 1068 { 0, unorm, 0, 5, 2 }, // R 1069 { 0, unorm, 5, 6, 2 }, // G 1070 { 0, unorm, 11, 5, 2 }, // B 1071 { 0, 0, 0, 0, 0 } // A 1072 } 1073 }; 1074 return desc; 1075 } 1076 1077 case VK_FORMAT_R5G5B5A1_UNORM_PACK16: 1078 { 1079 const PlanarFormatDescription desc = 1080 { 1081 1, // planes 1082 chanR|chanG|chanB|chanA, 1083 { 1084 // Size WDiv HDiv 1085 { 2, 1, 1 }, 1086 { 0, 0, 0 }, 1087 { 0, 0, 0 }, 1088 }, 1089 { 1090 // Plane Type Offs Size Stride 1091 { 0, unorm, 11, 5, 2 }, // R 1092 { 0, unorm, 6, 5, 2 }, // G 1093 { 0, unorm, 1, 5, 2 }, // B 1094 { 0, unorm, 0, 1, 2 } // A 1095 } 1096 }; 1097 return desc; 1098 } 1099 1100 case VK_FORMAT_B5G5R5A1_UNORM_PACK16: 1101 { 1102 const PlanarFormatDescription desc = 1103 { 1104 1, // planes 1105 chanR|chanG|chanB|chanA, 1106 { 1107 // Size WDiv HDiv 1108 { 2, 1, 1 }, 1109 { 0, 0, 0 }, 1110 { 0, 0, 0 }, 1111 }, 1112 { 1113 // Plane Type Offs Size Stride 1114 { 0, unorm, 1, 5, 2 }, // R 1115 { 0, unorm, 6, 5, 2 }, // G 1116 { 0, unorm, 11, 5, 2 }, // B 1117 { 0, unorm, 0, 1, 2 } // A 1118 } 1119 }; 1120 return desc; 1121 } 1122 1123 case VK_FORMAT_A1R5G5B5_UNORM_PACK16: 1124 { 1125 const PlanarFormatDescription desc = 1126 { 1127 1, // planes 1128 chanR|chanG|chanB|chanA, 1129 { 1130 // Size WDiv HDiv 1131 { 2, 1, 1 }, 1132 { 0, 0, 0 }, 1133 { 0, 0, 0 }, 1134 }, 1135 { 1136 // Plane Type Offs Size Stride 1137 { 0, unorm, 10, 5, 2 }, // R 1138 { 0, unorm, 5, 5, 2 }, // G 1139 { 0, unorm, 0, 5, 2 }, // B 1140 { 0, unorm, 15, 1, 2 } // A 1141 } 1142 }; 1143 return desc; 1144 } 1145 1146 case VK_FORMAT_R8G8B8_UNORM: 1147 { 1148 const PlanarFormatDescription desc = 1149 { 1150 1, // planes 1151 chanR|chanG|chanB, 1152 { 1153 // Size WDiv HDiv 1154 { 3, 1, 1 }, 1155 { 0, 0, 0 }, 1156 { 0, 0, 0 }, 1157 }, 1158 { 1159 // Plane Type Offs Size Stride 1160 { 0, unorm, 0, 8, 3 }, // R 1161 { 0, unorm, 8, 8, 3 }, // G 1162 { 0, unorm, 16, 8, 3 }, // B 1163 { 0, 0, 0, 0, 0 } // A 1164 } 1165 }; 1166 return desc; 1167 } 1168 1169 case VK_FORMAT_B8G8R8_UNORM: 1170 { 1171 const PlanarFormatDescription desc = 1172 { 1173 1, // planes 1174 chanR|chanG|chanB, 1175 { 1176 // Size WDiv HDiv 1177 { 3, 1, 1 }, 1178 { 0, 0, 0 }, 1179 { 0, 0, 0 }, 1180 }, 1181 { 1182 // Plane Type Offs Size Stride 1183 { 0, unorm, 16, 8, 3 }, // R 1184 { 0, unorm, 8, 8, 3 }, // G 1185 { 0, unorm, 0, 8, 3 }, // B 1186 { 0, 0, 0, 0, 0 } // A 1187 } 1188 }; 1189 return desc; 1190 } 1191 1192 case VK_FORMAT_R8G8B8A8_UNORM: 1193 case VK_FORMAT_A8B8G8R8_UNORM_PACK32: 1194 { 1195 const PlanarFormatDescription desc = 1196 { 1197 1, // planes 1198 chanR|chanG|chanB|chanA, 1199 { 1200 // Size WDiv HDiv 1201 { 4, 1, 1 }, 1202 { 0, 0, 0 }, 1203 { 0, 0, 0 }, 1204 }, 1205 { 1206 // Plane Type Offs Size Stride 1207 { 0, unorm, 0, 8, 4 }, // R 1208 { 0, unorm, 8, 8, 4 }, // G 1209 { 0, unorm, 16, 8, 4 }, // B 1210 { 0, unorm, 24, 8, 4 } // A 1211 } 1212 }; 1213 return desc; 1214 } 1215 1216 case VK_FORMAT_B8G8R8A8_UNORM: 1217 { 1218 const PlanarFormatDescription desc = 1219 { 1220 1, // planes 1221 chanR|chanG|chanB|chanA, 1222 { 1223 // Size WDiv HDiv 1224 { 4, 1, 1 }, 1225 { 0, 0, 0 }, 1226 { 0, 0, 0 }, 1227 }, 1228 { 1229 // Plane Type Offs Size Stride 1230 { 0, unorm, 16, 8, 4 }, // R 1231 { 0, unorm, 8, 8, 4 }, // G 1232 { 0, unorm, 0, 8, 4 }, // B 1233 { 0, unorm, 24, 8, 4 } // A 1234 } 1235 }; 1236 return desc; 1237 } 1238 1239 case VK_FORMAT_A2R10G10B10_UNORM_PACK32: 1240 { 1241 const PlanarFormatDescription desc = 1242 { 1243 1, // planes 1244 chanR|chanG|chanB|chanA, 1245 { 1246 // Size WDiv HDiv 1247 { 4, 1, 1 }, 1248 { 0, 0, 0 }, 1249 { 0, 0, 0 }, 1250 }, 1251 { 1252 // Plane Type Offs Size Stride 1253 { 0, unorm, 20, 10, 4 }, // R 1254 { 0, unorm, 10, 10, 4 }, // G 1255 { 0, unorm, 0, 10, 4 }, // B 1256 { 0, unorm, 30, 2, 4 } // A 1257 } 1258 }; 1259 return desc; 1260 } 1261 1262 case VK_FORMAT_A2B10G10R10_UNORM_PACK32: 1263 { 1264 const PlanarFormatDescription desc = 1265 { 1266 1, // planes 1267 chanR|chanG|chanB|chanA, 1268 { 1269 // Size WDiv HDiv 1270 { 4, 1, 1 }, 1271 { 0, 0, 0 }, 1272 { 0, 0, 0 }, 1273 }, 1274 { 1275 // Plane Type Offs Size Stride 1276 { 0, unorm, 0, 10, 4 }, // R 1277 { 0, unorm, 10, 10, 4 }, // G 1278 { 0, unorm, 20, 10, 4 }, // B 1279 { 0, unorm, 30, 2, 4 } // A 1280 } 1281 }; 1282 return desc; 1283 } 1284 1285 case VK_FORMAT_R16G16B16_UNORM: 1286 { 1287 const PlanarFormatDescription desc = 1288 { 1289 1, // planes 1290 chanR|chanG|chanB, 1291 { 1292 // Size WDiv HDiv 1293 { 6, 1, 1 }, 1294 { 0, 0, 0 }, 1295 { 0, 0, 0 }, 1296 }, 1297 { 1298 // Plane Type Offs Size Stride 1299 { 0, unorm, 0, 16, 6 }, // R 1300 { 0, unorm, 16, 16, 6 }, // G 1301 { 0, unorm, 32, 16, 6 }, // B 1302 { 0, 0, 0, 0, 0 } // A 1303 } 1304 }; 1305 return desc; 1306 } 1307 1308 case VK_FORMAT_R16G16B16A16_UNORM: 1309 { 1310 const PlanarFormatDescription desc = 1311 { 1312 1, // planes 1313 chanR|chanG|chanB|chanA, 1314 { 1315 // Size WDiv HDiv 1316 { 16, 1, 1 }, 1317 { 0, 0, 0 }, 1318 { 0, 0, 0 }, 1319 }, 1320 { 1321 // Plane Type Offs Size Stride 1322 { 0, unorm, 0, 16, 8 }, // R 1323 { 0, unorm, 16, 16, 8 }, // G 1324 { 0, unorm, 32, 16, 8 }, // B 1325 { 0, unorm, 48, 16, 8 } // A 1326 } 1327 }; 1328 return desc; 1329 } 1330 1331 default: 1332 TCU_THROW(InternalError, "Not implemented"); 1333 } 1334 } 1335 1336 PlanarFormatDescription getPlanarFormatDescription (VkFormat format) 1337 { 1338 if (isYCbCrFormat(format)) 1339 return getYCbCrPlanarFormatDescription(format); 1340 else 1341 return getCorePlanarFormatDescription(format); 1342 } 1343 1344 int getPlaneCount (VkFormat format) 1345 { 1346 switch (format) 1347 { 1348 case VK_FORMAT_G8B8G8R8_422_UNORM_KHR: 1349 case VK_FORMAT_B8G8R8G8_422_UNORM_KHR: 1350 case VK_FORMAT_R10X6_UNORM_PACK16_KHR: 1351 case VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR: 1352 case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: 1353 case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: 1354 case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: 1355 case VK_FORMAT_R12X4_UNORM_PACK16_KHR: 1356 case VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR: 1357 case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: 1358 case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: 1359 case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: 1360 case VK_FORMAT_G16B16G16R16_422_UNORM_KHR: 1361 case VK_FORMAT_B16G16R16G16_422_UNORM_KHR: 1362 return 1; 1363 1364 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR: 1365 case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR: 1366 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: 1367 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: 1368 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: 1369 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: 1370 case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR: 1371 case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR: 1372 return 2; 1373 1374 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR: 1375 case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR: 1376 case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR: 1377 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: 1378 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: 1379 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: 1380 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: 1381 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: 1382 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: 1383 case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR: 1384 case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR: 1385 case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR: 1386 return 3; 1387 1388 default: 1389 DE_FATAL("Not YCbCr format"); 1390 return 0; 1391 } 1392 } 1393 1394 VkImageAspectFlagBits getPlaneAspect (deUint32 planeNdx) 1395 { 1396 DE_ASSERT(de::inBounds(planeNdx, 0u, 3u)); 1397 return (VkImageAspectFlagBits)(VK_IMAGE_ASPECT_PLANE_0_BIT_KHR << planeNdx); 1398 } 1399 1400 deUint32 getAspectPlaneNdx (VkImageAspectFlagBits flags) 1401 { 1402 switch (flags) 1403 { 1404 case VK_IMAGE_ASPECT_PLANE_0_BIT_KHR: return 0; 1405 case VK_IMAGE_ASPECT_PLANE_1_BIT_KHR: return 1; 1406 case VK_IMAGE_ASPECT_PLANE_2_BIT_KHR: return 2; 1407 default: 1408 DE_FATAL("Invalid plane aspect"); 1409 return 0; 1410 } 1411 } 1412 1413 bool isChromaSubsampled (VkFormat format) 1414 { 1415 switch (format) 1416 { 1417 case VK_FORMAT_G8B8G8R8_422_UNORM_KHR: 1418 case VK_FORMAT_B8G8R8G8_422_UNORM_KHR: 1419 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR: 1420 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR: 1421 case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR: 1422 case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR: 1423 case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR: 1424 case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: 1425 case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: 1426 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: 1427 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: 1428 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: 1429 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: 1430 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: 1431 case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: 1432 case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: 1433 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: 1434 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: 1435 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: 1436 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: 1437 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: 1438 case VK_FORMAT_G16B16G16R16_422_UNORM_KHR: 1439 case VK_FORMAT_B16G16R16G16_422_UNORM_KHR: 1440 case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR: 1441 case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR: 1442 case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR: 1443 case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR: 1444 case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR: 1445 return true; 1446 1447 default: 1448 return false; 1449 } 1450 } 1451 1452 bool isSupportedByFramework (VkFormat format) 1453 { 1454 if (format == VK_FORMAT_UNDEFINED || format > VK_CORE_FORMAT_LAST) 1455 return false; 1456 1457 switch (format) 1458 { 1459 case VK_FORMAT_R64_UINT: 1460 case VK_FORMAT_R64_SINT: 1461 case VK_FORMAT_R64_SFLOAT: 1462 case VK_FORMAT_R64G64_UINT: 1463 case VK_FORMAT_R64G64_SINT: 1464 case VK_FORMAT_R64G64_SFLOAT: 1465 case VK_FORMAT_R64G64B64_UINT: 1466 case VK_FORMAT_R64G64B64_SINT: 1467 case VK_FORMAT_R64G64B64_SFLOAT: 1468 case VK_FORMAT_R64G64B64A64_UINT: 1469 case VK_FORMAT_R64G64B64A64_SINT: 1470 case VK_FORMAT_R64G64B64A64_SFLOAT: 1471 // \todo [2016-12-01 pyry] Support 64-bit channel types 1472 return false; 1473 1474 case VK_FORMAT_BC1_RGB_UNORM_BLOCK: 1475 case VK_FORMAT_BC1_RGB_SRGB_BLOCK: 1476 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: 1477 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: 1478 case VK_FORMAT_BC2_UNORM_BLOCK: 1479 case VK_FORMAT_BC2_SRGB_BLOCK: 1480 case VK_FORMAT_BC3_UNORM_BLOCK: 1481 case VK_FORMAT_BC3_SRGB_BLOCK: 1482 case VK_FORMAT_BC4_UNORM_BLOCK: 1483 case VK_FORMAT_BC4_SNORM_BLOCK: 1484 case VK_FORMAT_BC5_UNORM_BLOCK: 1485 case VK_FORMAT_BC5_SNORM_BLOCK: 1486 case VK_FORMAT_BC6H_UFLOAT_BLOCK: 1487 case VK_FORMAT_BC6H_SFLOAT_BLOCK: 1488 case VK_FORMAT_BC7_UNORM_BLOCK: 1489 case VK_FORMAT_BC7_SRGB_BLOCK: 1490 return false; 1491 1492 default: 1493 return true; 1494 } 1495 } 1496 1497 VkFormat mapTextureFormat (const tcu::TextureFormat& format) 1498 { 1499 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST < (1<<16)); 1500 DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELTYPE_LAST < (1<<16)); 1501 1502 #define PACK_FMT(ORDER, TYPE) ((int(ORDER) << 16) | int(TYPE)) 1503 #define FMT_CASE(ORDER, TYPE) PACK_FMT(tcu::TextureFormat::ORDER, tcu::TextureFormat::TYPE) 1504 1505 // update this mapping if VkFormat changes 1506 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185); 1507 1508 switch (PACK_FMT(format.order, format.type)) 1509 { 1510 case FMT_CASE(RG, UNORM_BYTE_44): return VK_FORMAT_R4G4_UNORM_PACK8; 1511 case FMT_CASE(RGB, UNORM_SHORT_565): return VK_FORMAT_R5G6B5_UNORM_PACK16; 1512 case FMT_CASE(RGBA, UNORM_SHORT_4444): return VK_FORMAT_R4G4B4A4_UNORM_PACK16; 1513 case FMT_CASE(RGBA, UNORM_SHORT_5551): return VK_FORMAT_R5G5B5A1_UNORM_PACK16; 1514 1515 case FMT_CASE(BGR, UNORM_SHORT_565): return VK_FORMAT_B5G6R5_UNORM_PACK16; 1516 case FMT_CASE(BGRA, UNORM_SHORT_4444): return VK_FORMAT_B4G4R4A4_UNORM_PACK16; 1517 case FMT_CASE(BGRA, UNORM_SHORT_5551): return VK_FORMAT_B5G5R5A1_UNORM_PACK16; 1518 1519 case FMT_CASE(ARGB, UNORM_SHORT_1555): return VK_FORMAT_A1R5G5B5_UNORM_PACK16; 1520 1521 case FMT_CASE(R, UNORM_INT8): return VK_FORMAT_R8_UNORM; 1522 case FMT_CASE(R, SNORM_INT8): return VK_FORMAT_R8_SNORM; 1523 case FMT_CASE(R, UNSIGNED_INT8): return VK_FORMAT_R8_UINT; 1524 case FMT_CASE(R, SIGNED_INT8): return VK_FORMAT_R8_SINT; 1525 case FMT_CASE(sR, UNORM_INT8): return VK_FORMAT_R8_SRGB; 1526 1527 case FMT_CASE(RG, UNORM_INT8): return VK_FORMAT_R8G8_UNORM; 1528 case FMT_CASE(RG, SNORM_INT8): return VK_FORMAT_R8G8_SNORM; 1529 case FMT_CASE(RG, UNSIGNED_INT8): return VK_FORMAT_R8G8_UINT; 1530 case FMT_CASE(RG, SIGNED_INT8): return VK_FORMAT_R8G8_SINT; 1531 case FMT_CASE(sRG, UNORM_INT8): return VK_FORMAT_R8G8_SRGB; 1532 1533 case FMT_CASE(RGB, UNORM_INT8): return VK_FORMAT_R8G8B8_UNORM; 1534 case FMT_CASE(RGB, SNORM_INT8): return VK_FORMAT_R8G8B8_SNORM; 1535 case FMT_CASE(RGB, UNSIGNED_INT8): return VK_FORMAT_R8G8B8_UINT; 1536 case FMT_CASE(RGB, SIGNED_INT8): return VK_FORMAT_R8G8B8_SINT; 1537 case FMT_CASE(sRGB, UNORM_INT8): return VK_FORMAT_R8G8B8_SRGB; 1538 1539 case FMT_CASE(RGBA, UNORM_INT8): return VK_FORMAT_R8G8B8A8_UNORM; 1540 case FMT_CASE(RGBA, SNORM_INT8): return VK_FORMAT_R8G8B8A8_SNORM; 1541 case FMT_CASE(RGBA, UNSIGNED_INT8): return VK_FORMAT_R8G8B8A8_UINT; 1542 case FMT_CASE(RGBA, SIGNED_INT8): return VK_FORMAT_R8G8B8A8_SINT; 1543 case FMT_CASE(sRGBA, UNORM_INT8): return VK_FORMAT_R8G8B8A8_SRGB; 1544 1545 case FMT_CASE(RGBA, UNORM_INT_1010102_REV): return VK_FORMAT_A2B10G10R10_UNORM_PACK32; 1546 case FMT_CASE(RGBA, SNORM_INT_1010102_REV): return VK_FORMAT_A2B10G10R10_SNORM_PACK32; 1547 case FMT_CASE(RGBA, UNSIGNED_INT_1010102_REV): return VK_FORMAT_A2B10G10R10_UINT_PACK32; 1548 case FMT_CASE(RGBA, SIGNED_INT_1010102_REV): return VK_FORMAT_A2B10G10R10_SINT_PACK32; 1549 1550 case FMT_CASE(R, UNORM_INT16): return VK_FORMAT_R16_UNORM; 1551 case FMT_CASE(R, SNORM_INT16): return VK_FORMAT_R16_SNORM; 1552 case FMT_CASE(R, UNSIGNED_INT16): return VK_FORMAT_R16_UINT; 1553 case FMT_CASE(R, SIGNED_INT16): return VK_FORMAT_R16_SINT; 1554 case FMT_CASE(R, HALF_FLOAT): return VK_FORMAT_R16_SFLOAT; 1555 1556 case FMT_CASE(RG, UNORM_INT16): return VK_FORMAT_R16G16_UNORM; 1557 case FMT_CASE(RG, SNORM_INT16): return VK_FORMAT_R16G16_SNORM; 1558 case FMT_CASE(RG, UNSIGNED_INT16): return VK_FORMAT_R16G16_UINT; 1559 case FMT_CASE(RG, SIGNED_INT16): return VK_FORMAT_R16G16_SINT; 1560 case FMT_CASE(RG, HALF_FLOAT): return VK_FORMAT_R16G16_SFLOAT; 1561 1562 case FMT_CASE(RGB, UNORM_INT16): return VK_FORMAT_R16G16B16_UNORM; 1563 case FMT_CASE(RGB, SNORM_INT16): return VK_FORMAT_R16G16B16_SNORM; 1564 case FMT_CASE(RGB, UNSIGNED_INT16): return VK_FORMAT_R16G16B16_UINT; 1565 case FMT_CASE(RGB, SIGNED_INT16): return VK_FORMAT_R16G16B16_SINT; 1566 case FMT_CASE(RGB, HALF_FLOAT): return VK_FORMAT_R16G16B16_SFLOAT; 1567 1568 case FMT_CASE(RGBA, UNORM_INT16): return VK_FORMAT_R16G16B16A16_UNORM; 1569 case FMT_CASE(RGBA, SNORM_INT16): return VK_FORMAT_R16G16B16A16_SNORM; 1570 case FMT_CASE(RGBA, UNSIGNED_INT16): return VK_FORMAT_R16G16B16A16_UINT; 1571 case FMT_CASE(RGBA, SIGNED_INT16): return VK_FORMAT_R16G16B16A16_SINT; 1572 case FMT_CASE(RGBA, HALF_FLOAT): return VK_FORMAT_R16G16B16A16_SFLOAT; 1573 1574 case FMT_CASE(R, UNSIGNED_INT32): return VK_FORMAT_R32_UINT; 1575 case FMT_CASE(R, SIGNED_INT32): return VK_FORMAT_R32_SINT; 1576 case FMT_CASE(R, FLOAT): return VK_FORMAT_R32_SFLOAT; 1577 1578 case FMT_CASE(RG, UNSIGNED_INT32): return VK_FORMAT_R32G32_UINT; 1579 case FMT_CASE(RG, SIGNED_INT32): return VK_FORMAT_R32G32_SINT; 1580 case FMT_CASE(RG, FLOAT): return VK_FORMAT_R32G32_SFLOAT; 1581 1582 case FMT_CASE(RGB, UNSIGNED_INT32): return VK_FORMAT_R32G32B32_UINT; 1583 case FMT_CASE(RGB, SIGNED_INT32): return VK_FORMAT_R32G32B32_SINT; 1584 case FMT_CASE(RGB, FLOAT): return VK_FORMAT_R32G32B32_SFLOAT; 1585 1586 case FMT_CASE(RGBA, UNSIGNED_INT32): return VK_FORMAT_R32G32B32A32_UINT; 1587 case FMT_CASE(RGBA, SIGNED_INT32): return VK_FORMAT_R32G32B32A32_SINT; 1588 case FMT_CASE(RGBA, FLOAT): return VK_FORMAT_R32G32B32A32_SFLOAT; 1589 1590 case FMT_CASE(R, FLOAT64): return VK_FORMAT_R64_SFLOAT; 1591 case FMT_CASE(RG, FLOAT64): return VK_FORMAT_R64G64_SFLOAT; 1592 case FMT_CASE(RGB, FLOAT64): return VK_FORMAT_R64G64B64_SFLOAT; 1593 case FMT_CASE(RGBA, FLOAT64): return VK_FORMAT_R64G64B64A64_SFLOAT; 1594 1595 case FMT_CASE(RGB, UNSIGNED_INT_11F_11F_10F_REV): return VK_FORMAT_B10G11R11_UFLOAT_PACK32; 1596 case FMT_CASE(RGB, UNSIGNED_INT_999_E5_REV): return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32; 1597 1598 case FMT_CASE(BGR, UNORM_INT8): return VK_FORMAT_B8G8R8_UNORM; 1599 case FMT_CASE(BGR, SNORM_INT8): return VK_FORMAT_B8G8R8_SNORM; 1600 case FMT_CASE(BGR, UNSIGNED_INT8): return VK_FORMAT_B8G8R8_UINT; 1601 case FMT_CASE(BGR, SIGNED_INT8): return VK_FORMAT_B8G8R8_SINT; 1602 case FMT_CASE(sBGR, UNORM_INT8): return VK_FORMAT_B8G8R8_SRGB; 1603 1604 case FMT_CASE(BGRA, UNORM_INT8): return VK_FORMAT_B8G8R8A8_UNORM; 1605 case FMT_CASE(BGRA, SNORM_INT8): return VK_FORMAT_B8G8R8A8_SNORM; 1606 case FMT_CASE(BGRA, UNSIGNED_INT8): return VK_FORMAT_B8G8R8A8_UINT; 1607 case FMT_CASE(BGRA, SIGNED_INT8): return VK_FORMAT_B8G8R8A8_SINT; 1608 case FMT_CASE(sBGRA, UNORM_INT8): return VK_FORMAT_B8G8R8A8_SRGB; 1609 1610 case FMT_CASE(BGRA, UNORM_INT_1010102_REV): return VK_FORMAT_A2R10G10B10_UNORM_PACK32; 1611 case FMT_CASE(BGRA, SNORM_INT_1010102_REV): return VK_FORMAT_A2R10G10B10_SNORM_PACK32; 1612 case FMT_CASE(BGRA, UNSIGNED_INT_1010102_REV): return VK_FORMAT_A2R10G10B10_UINT_PACK32; 1613 case FMT_CASE(BGRA, SIGNED_INT_1010102_REV): return VK_FORMAT_A2R10G10B10_SINT_PACK32; 1614 1615 case FMT_CASE(D, UNORM_INT16): return VK_FORMAT_D16_UNORM; 1616 case FMT_CASE(D, UNSIGNED_INT_24_8_REV): return VK_FORMAT_X8_D24_UNORM_PACK32; 1617 case FMT_CASE(D, FLOAT): return VK_FORMAT_D32_SFLOAT; 1618 1619 case FMT_CASE(S, UNSIGNED_INT8): return VK_FORMAT_S8_UINT; 1620 1621 case FMT_CASE(DS, UNSIGNED_INT_16_8_8): return VK_FORMAT_D16_UNORM_S8_UINT; 1622 case FMT_CASE(DS, UNSIGNED_INT_24_8_REV): return VK_FORMAT_D24_UNORM_S8_UINT; 1623 case FMT_CASE(DS, FLOAT_UNSIGNED_INT_24_8_REV): return VK_FORMAT_D32_SFLOAT_S8_UINT; 1624 1625 1626 case FMT_CASE(R, UNORM_SHORT_10): return VK_FORMAT_R10X6_UNORM_PACK16_KHR; 1627 case FMT_CASE(RG, UNORM_SHORT_10): return VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR; 1628 case FMT_CASE(RGBA, UNORM_SHORT_10): return VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR; 1629 1630 case FMT_CASE(R, UNORM_SHORT_12): return VK_FORMAT_R12X4_UNORM_PACK16_KHR; 1631 case FMT_CASE(RG, UNORM_SHORT_12): return VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR; 1632 case FMT_CASE(RGBA, UNORM_SHORT_12): return VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR; 1633 1634 default: 1635 TCU_THROW(InternalError, "Unknown texture format"); 1636 } 1637 1638 #undef PACK_FMT 1639 #undef FMT_CASE 1640 } 1641 1642 VkFormat mapCompressedTextureFormat (const tcu::CompressedTexFormat format) 1643 { 1644 // update this mapping if CompressedTexFormat changes 1645 DE_STATIC_ASSERT(tcu::COMPRESSEDTEXFORMAT_LAST == 39); 1646 1647 switch (format) 1648 { 1649 case tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8: return VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; 1650 case tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8: return VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK; 1651 case tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1: return VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK; 1652 case tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: return VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK; 1653 case tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8: return VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; 1654 case tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8: return VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK; 1655 1656 case tcu::COMPRESSEDTEXFORMAT_EAC_R11: return VK_FORMAT_EAC_R11_UNORM_BLOCK; 1657 case tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_R11: return VK_FORMAT_EAC_R11_SNORM_BLOCK; 1658 case tcu::COMPRESSEDTEXFORMAT_EAC_RG11: return VK_FORMAT_EAC_R11G11_UNORM_BLOCK; 1659 case tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11: return VK_FORMAT_EAC_R11G11_SNORM_BLOCK; 1660 1661 case tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_RGBA: return VK_FORMAT_ASTC_4x4_UNORM_BLOCK; 1662 case tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_SRGB8_ALPHA8: return VK_FORMAT_ASTC_4x4_SRGB_BLOCK; 1663 case tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_RGBA: return VK_FORMAT_ASTC_5x4_UNORM_BLOCK; 1664 case tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_SRGB8_ALPHA8: return VK_FORMAT_ASTC_5x4_SRGB_BLOCK; 1665 case tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_RGBA: return VK_FORMAT_ASTC_5x5_UNORM_BLOCK; 1666 case tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8: return VK_FORMAT_ASTC_5x5_SRGB_BLOCK; 1667 case tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_RGBA: return VK_FORMAT_ASTC_6x5_UNORM_BLOCK; 1668 case tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_SRGB8_ALPHA8: return VK_FORMAT_ASTC_6x5_SRGB_BLOCK; 1669 case tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_RGBA: return VK_FORMAT_ASTC_6x6_UNORM_BLOCK; 1670 case tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_SRGB8_ALPHA8: return VK_FORMAT_ASTC_6x6_SRGB_BLOCK; 1671 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_RGBA: return VK_FORMAT_ASTC_8x5_UNORM_BLOCK; 1672 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_SRGB8_ALPHA8: return VK_FORMAT_ASTC_8x5_SRGB_BLOCK; 1673 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_RGBA: return VK_FORMAT_ASTC_8x6_UNORM_BLOCK; 1674 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8: return VK_FORMAT_ASTC_8x6_SRGB_BLOCK; 1675 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_RGBA: return VK_FORMAT_ASTC_8x8_UNORM_BLOCK; 1676 case tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_SRGB8_ALPHA8: return VK_FORMAT_ASTC_8x8_SRGB_BLOCK; 1677 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_RGBA: return VK_FORMAT_ASTC_10x5_UNORM_BLOCK; 1678 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_SRGB8_ALPHA8: return VK_FORMAT_ASTC_10x5_SRGB_BLOCK; 1679 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_RGBA: return VK_FORMAT_ASTC_10x6_UNORM_BLOCK; 1680 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_SRGB8_ALPHA8: return VK_FORMAT_ASTC_10x6_SRGB_BLOCK; 1681 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_RGBA: return VK_FORMAT_ASTC_10x8_UNORM_BLOCK; 1682 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_SRGB8_ALPHA8: return VK_FORMAT_ASTC_10x8_SRGB_BLOCK; 1683 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_RGBA: return VK_FORMAT_ASTC_10x10_UNORM_BLOCK; 1684 case tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_SRGB8_ALPHA8: return VK_FORMAT_ASTC_10x10_SRGB_BLOCK; 1685 case tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_RGBA: return VK_FORMAT_ASTC_12x10_UNORM_BLOCK; 1686 case tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_SRGB8_ALPHA8: return VK_FORMAT_ASTC_12x10_SRGB_BLOCK; 1687 case tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_RGBA: return VK_FORMAT_ASTC_12x12_UNORM_BLOCK; 1688 case tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_SRGB8_ALPHA8: return VK_FORMAT_ASTC_12x12_SRGB_BLOCK; 1689 1690 default: 1691 TCU_THROW(InternalError, "Unknown texture format"); 1692 return VK_FORMAT_UNDEFINED; 1693 } 1694 } 1695 1696 tcu::TextureFormat mapVkFormat (VkFormat format) 1697 { 1698 using tcu::TextureFormat; 1699 1700 // update this mapping if VkFormat changes 1701 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185); 1702 1703 switch (format) 1704 { 1705 case VK_FORMAT_R4G4_UNORM_PACK8: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_BYTE_44); 1706 case VK_FORMAT_R5G6B5_UNORM_PACK16: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_SHORT_565); 1707 case VK_FORMAT_R4G4B4A4_UNORM_PACK16: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_4444); 1708 case VK_FORMAT_R5G5B5A1_UNORM_PACK16: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_5551); 1709 1710 case VK_FORMAT_B5G6R5_UNORM_PACK16: return TextureFormat(TextureFormat::BGR, TextureFormat::UNORM_SHORT_565); 1711 case VK_FORMAT_B4G4R4A4_UNORM_PACK16: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_SHORT_4444); 1712 case VK_FORMAT_B5G5R5A1_UNORM_PACK16: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_SHORT_5551); 1713 1714 case VK_FORMAT_A1R5G5B5_UNORM_PACK16: return TextureFormat(TextureFormat::ARGB, TextureFormat::UNORM_SHORT_1555); 1715 1716 case VK_FORMAT_R8_UNORM: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT8); 1717 case VK_FORMAT_R8_SNORM: return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT8); 1718 case VK_FORMAT_R8_USCALED: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT8); 1719 case VK_FORMAT_R8_SSCALED: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT8); 1720 case VK_FORMAT_R8_UINT: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT8); 1721 case VK_FORMAT_R8_SINT: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT8); 1722 case VK_FORMAT_R8_SRGB: return TextureFormat(TextureFormat::sR, TextureFormat::UNORM_INT8); 1723 1724 case VK_FORMAT_R8G8_UNORM: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT8); 1725 case VK_FORMAT_R8G8_SNORM: return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT8); 1726 case VK_FORMAT_R8G8_USCALED: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT8); 1727 case VK_FORMAT_R8G8_SSCALED: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT8); 1728 case VK_FORMAT_R8G8_UINT: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT8); 1729 case VK_FORMAT_R8G8_SINT: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT8); 1730 case VK_FORMAT_R8G8_SRGB: return TextureFormat(TextureFormat::sRG, TextureFormat::UNORM_INT8); 1731 1732 case VK_FORMAT_R8G8B8_UNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8); 1733 case VK_FORMAT_R8G8B8_SNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::SNORM_INT8); 1734 case VK_FORMAT_R8G8B8_USCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT8); 1735 case VK_FORMAT_R8G8B8_SSCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT8); 1736 case VK_FORMAT_R8G8B8_UINT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT8); 1737 case VK_FORMAT_R8G8B8_SINT: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT8); 1738 case VK_FORMAT_R8G8B8_SRGB: return TextureFormat(TextureFormat::sRGB, TextureFormat::UNORM_INT8); 1739 1740 case VK_FORMAT_R8G8B8A8_UNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8); 1741 case VK_FORMAT_R8G8B8A8_SNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT8); 1742 case VK_FORMAT_R8G8B8A8_USCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8); 1743 case VK_FORMAT_R8G8B8A8_SSCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8); 1744 case VK_FORMAT_R8G8B8A8_UINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8); 1745 case VK_FORMAT_R8G8B8A8_SINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8); 1746 case VK_FORMAT_R8G8B8A8_SRGB: return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8); 1747 1748 case VK_FORMAT_R16_UNORM: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT16); 1749 case VK_FORMAT_R16_SNORM: return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT16); 1750 case VK_FORMAT_R16_USCALED: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT16); 1751 case VK_FORMAT_R16_SSCALED: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT16); 1752 case VK_FORMAT_R16_UINT: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT16); 1753 case VK_FORMAT_R16_SINT: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT16); 1754 case VK_FORMAT_R16_SFLOAT: return TextureFormat(TextureFormat::R, TextureFormat::HALF_FLOAT); 1755 1756 case VK_FORMAT_R16G16_UNORM: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT16); 1757 case VK_FORMAT_R16G16_SNORM: return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT16); 1758 case VK_FORMAT_R16G16_USCALED: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT16); 1759 case VK_FORMAT_R16G16_SSCALED: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT16); 1760 case VK_FORMAT_R16G16_UINT: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT16); 1761 case VK_FORMAT_R16G16_SINT: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT16); 1762 case VK_FORMAT_R16G16_SFLOAT: return TextureFormat(TextureFormat::RG, TextureFormat::HALF_FLOAT); 1763 1764 case VK_FORMAT_R16G16B16_UNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT16); 1765 case VK_FORMAT_R16G16B16_SNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::SNORM_INT16); 1766 case VK_FORMAT_R16G16B16_USCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT16); 1767 case VK_FORMAT_R16G16B16_SSCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT16); 1768 case VK_FORMAT_R16G16B16_UINT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT16); 1769 case VK_FORMAT_R16G16B16_SINT: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT16); 1770 case VK_FORMAT_R16G16B16_SFLOAT: return TextureFormat(TextureFormat::RGB, TextureFormat::HALF_FLOAT); 1771 1772 case VK_FORMAT_R16G16B16A16_UNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT16); 1773 case VK_FORMAT_R16G16B16A16_SNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT16); 1774 case VK_FORMAT_R16G16B16A16_USCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT16); 1775 case VK_FORMAT_R16G16B16A16_SSCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT16); 1776 case VK_FORMAT_R16G16B16A16_UINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT16); 1777 case VK_FORMAT_R16G16B16A16_SINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT16); 1778 case VK_FORMAT_R16G16B16A16_SFLOAT: return TextureFormat(TextureFormat::RGBA, TextureFormat::HALF_FLOAT); 1779 1780 case VK_FORMAT_R32_UINT: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT32); 1781 case VK_FORMAT_R32_SINT: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT32); 1782 case VK_FORMAT_R32_SFLOAT: return TextureFormat(TextureFormat::R, TextureFormat::FLOAT); 1783 1784 case VK_FORMAT_R32G32_UINT: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT32); 1785 case VK_FORMAT_R32G32_SINT: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT32); 1786 case VK_FORMAT_R32G32_SFLOAT: return TextureFormat(TextureFormat::RG, TextureFormat::FLOAT); 1787 1788 case VK_FORMAT_R32G32B32_UINT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT32); 1789 case VK_FORMAT_R32G32B32_SINT: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT32); 1790 case VK_FORMAT_R32G32B32_SFLOAT: return TextureFormat(TextureFormat::RGB, TextureFormat::FLOAT); 1791 1792 case VK_FORMAT_R32G32B32A32_UINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32); 1793 case VK_FORMAT_R32G32B32A32_SINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT32); 1794 case VK_FORMAT_R32G32B32A32_SFLOAT: return TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT); 1795 1796 case VK_FORMAT_R64_SFLOAT: return TextureFormat(TextureFormat::R, TextureFormat::FLOAT64); 1797 case VK_FORMAT_R64G64_SFLOAT: return TextureFormat(TextureFormat::RG, TextureFormat::FLOAT64); 1798 case VK_FORMAT_R64G64B64_SFLOAT: return TextureFormat(TextureFormat::RGB, TextureFormat::FLOAT64); 1799 case VK_FORMAT_R64G64B64A64_SFLOAT: return TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT64); 1800 1801 case VK_FORMAT_B10G11R11_UFLOAT_PACK32: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT_11F_11F_10F_REV); 1802 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT_999_E5_REV); 1803 1804 case VK_FORMAT_B8G8R8_UNORM: return TextureFormat(TextureFormat::BGR, TextureFormat::UNORM_INT8); 1805 case VK_FORMAT_B8G8R8_SNORM: return TextureFormat(TextureFormat::BGR, TextureFormat::SNORM_INT8); 1806 case VK_FORMAT_B8G8R8_USCALED: return TextureFormat(TextureFormat::BGR, TextureFormat::UNSIGNED_INT8); 1807 case VK_FORMAT_B8G8R8_SSCALED: return TextureFormat(TextureFormat::BGR, TextureFormat::SIGNED_INT8); 1808 case VK_FORMAT_B8G8R8_UINT: return TextureFormat(TextureFormat::BGR, TextureFormat::UNSIGNED_INT8); 1809 case VK_FORMAT_B8G8R8_SINT: return TextureFormat(TextureFormat::BGR, TextureFormat::SIGNED_INT8); 1810 case VK_FORMAT_B8G8R8_SRGB: return TextureFormat(TextureFormat::sBGR, TextureFormat::UNORM_INT8); 1811 1812 case VK_FORMAT_B8G8R8A8_UNORM: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_INT8); 1813 case VK_FORMAT_B8G8R8A8_SNORM: return TextureFormat(TextureFormat::BGRA, TextureFormat::SNORM_INT8); 1814 case VK_FORMAT_B8G8R8A8_USCALED: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT8); 1815 case VK_FORMAT_B8G8R8A8_SSCALED: return TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT8); 1816 case VK_FORMAT_B8G8R8A8_UINT: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT8); 1817 case VK_FORMAT_B8G8R8A8_SINT: return TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT8); 1818 case VK_FORMAT_B8G8R8A8_SRGB: return TextureFormat(TextureFormat::sBGRA, TextureFormat::UNORM_INT8); 1819 1820 case VK_FORMAT_D16_UNORM: return TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT16); 1821 case VK_FORMAT_X8_D24_UNORM_PACK32: return TextureFormat(TextureFormat::D, TextureFormat::UNSIGNED_INT_24_8_REV); 1822 case VK_FORMAT_D32_SFLOAT: return TextureFormat(TextureFormat::D, TextureFormat::FLOAT); 1823 1824 case VK_FORMAT_S8_UINT: return TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8); 1825 1826 // \note There is no standard interleaved memory layout for DS formats; buffer-image copies 1827 // will always operate on either D or S aspect only. See Khronos bug 12998 1828 case VK_FORMAT_D16_UNORM_S8_UINT: return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_16_8_8); 1829 case VK_FORMAT_D24_UNORM_S8_UINT: return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_24_8_REV); 1830 case VK_FORMAT_D32_SFLOAT_S8_UINT: return TextureFormat(TextureFormat::DS, TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV); 1831 1832 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 1833 case VK_FORMAT_A8B8G8R8_UNORM_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8); 1834 case VK_FORMAT_A8B8G8R8_SNORM_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT8); 1835 case VK_FORMAT_A8B8G8R8_USCALED_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8); 1836 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8); 1837 case VK_FORMAT_A8B8G8R8_UINT_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8); 1838 case VK_FORMAT_A8B8G8R8_SINT_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8); 1839 case VK_FORMAT_A8B8G8R8_SRGB_PACK32: return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8); 1840 #else 1841 # error "Big-endian not supported" 1842 #endif 1843 1844 case VK_FORMAT_A2R10G10B10_UNORM_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_INT_1010102_REV); 1845 case VK_FORMAT_A2R10G10B10_SNORM_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::SNORM_INT_1010102_REV); 1846 case VK_FORMAT_A2R10G10B10_USCALED_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT_1010102_REV); 1847 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT_1010102_REV); 1848 case VK_FORMAT_A2R10G10B10_UINT_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT_1010102_REV); 1849 case VK_FORMAT_A2R10G10B10_SINT_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT_1010102_REV); 1850 1851 case VK_FORMAT_A2B10G10R10_UNORM_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT_1010102_REV); 1852 case VK_FORMAT_A2B10G10R10_SNORM_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT_1010102_REV); 1853 case VK_FORMAT_A2B10G10R10_USCALED_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT_1010102_REV); 1854 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT_1010102_REV); 1855 case VK_FORMAT_A2B10G10R10_UINT_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT_1010102_REV); 1856 case VK_FORMAT_A2B10G10R10_SINT_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT_1010102_REV); 1857 1858 // YCbCr formats that can be mapped 1859 case VK_FORMAT_R10X6_UNORM_PACK16_KHR: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_10); 1860 case VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_SHORT_10); 1861 case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_10); 1862 1863 case VK_FORMAT_R12X4_UNORM_PACK16_KHR: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_12); 1864 case VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_SHORT_12); 1865 case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_12); 1866 1867 default: 1868 TCU_THROW(InternalError, "Unknown image format"); 1869 } 1870 } 1871 1872 tcu::CompressedTexFormat mapVkCompressedFormat (VkFormat format) 1873 { 1874 // update this mapping if VkFormat changes 1875 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185); 1876 1877 switch (format) 1878 { 1879 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8; 1880 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8; 1881 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1; 1882 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1; 1883 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8; 1884 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8; 1885 1886 case VK_FORMAT_EAC_R11_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_EAC_R11; 1887 case VK_FORMAT_EAC_R11_SNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_R11; 1888 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_EAC_RG11; 1889 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11; 1890 1891 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_RGBA; 1892 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_SRGB8_ALPHA8; 1893 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_RGBA; 1894 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_SRGB8_ALPHA8; 1895 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_RGBA; 1896 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8; 1897 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_RGBA; 1898 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_SRGB8_ALPHA8; 1899 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_RGBA; 1900 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_SRGB8_ALPHA8; 1901 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_RGBA; 1902 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_SRGB8_ALPHA8; 1903 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_RGBA; 1904 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8; 1905 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_RGBA; 1906 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_SRGB8_ALPHA8; 1907 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_RGBA; 1908 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_SRGB8_ALPHA8; 1909 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_RGBA; 1910 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_SRGB8_ALPHA8; 1911 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_RGBA; 1912 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_SRGB8_ALPHA8; 1913 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_RGBA; 1914 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_SRGB8_ALPHA8; 1915 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_RGBA; 1916 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_SRGB8_ALPHA8; 1917 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_RGBA; 1918 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_SRGB8_ALPHA8; 1919 1920 default: 1921 TCU_THROW(InternalError, "Unknown image format"); 1922 return tcu::COMPRESSEDTEXFORMAT_LAST; 1923 } 1924 } 1925 1926 static bool isScaledFormat (VkFormat format) 1927 { 1928 // update this mapping if VkFormat changes 1929 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185); 1930 1931 switch (format) 1932 { 1933 case VK_FORMAT_R8_USCALED: 1934 case VK_FORMAT_R8_SSCALED: 1935 case VK_FORMAT_R8G8_USCALED: 1936 case VK_FORMAT_R8G8_SSCALED: 1937 case VK_FORMAT_R8G8B8_USCALED: 1938 case VK_FORMAT_R8G8B8_SSCALED: 1939 case VK_FORMAT_R8G8B8A8_USCALED: 1940 case VK_FORMAT_R8G8B8A8_SSCALED: 1941 case VK_FORMAT_A2B10G10R10_USCALED_PACK32: 1942 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: 1943 case VK_FORMAT_R16_USCALED: 1944 case VK_FORMAT_R16_SSCALED: 1945 case VK_FORMAT_R16G16_USCALED: 1946 case VK_FORMAT_R16G16_SSCALED: 1947 case VK_FORMAT_R16G16B16_USCALED: 1948 case VK_FORMAT_R16G16B16_SSCALED: 1949 case VK_FORMAT_R16G16B16A16_USCALED: 1950 case VK_FORMAT_R16G16B16A16_SSCALED: 1951 case VK_FORMAT_B8G8R8_USCALED: 1952 case VK_FORMAT_B8G8R8_SSCALED: 1953 case VK_FORMAT_B8G8R8A8_USCALED: 1954 case VK_FORMAT_B8G8R8A8_SSCALED: 1955 case VK_FORMAT_A2R10G10B10_USCALED_PACK32: 1956 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: 1957 return true; 1958 1959 default: 1960 return false; 1961 } 1962 } 1963 1964 static bool fullTextureFormatRoundTripSupported (VkFormat format) 1965 { 1966 if (isScaledFormat(format)) 1967 { 1968 // *SCALED formats get mapped to correspoding (u)int formats since 1969 // accessing them through (float) getPixel/setPixel has same behavior 1970 // as in shader access in Vulkan. 1971 // Unfortunately full round-trip between tcu::TextureFormat and VkFormat 1972 // for most SCALED formats is not supported though. 1973 1974 const tcu::TextureFormat tcuFormat = mapVkFormat(format); 1975 1976 switch (tcuFormat.type) 1977 { 1978 case tcu::TextureFormat::UNSIGNED_INT8: 1979 case tcu::TextureFormat::UNSIGNED_INT16: 1980 case tcu::TextureFormat::UNSIGNED_INT32: 1981 case tcu::TextureFormat::SIGNED_INT8: 1982 case tcu::TextureFormat::SIGNED_INT16: 1983 case tcu::TextureFormat::SIGNED_INT32: 1984 case tcu::TextureFormat::UNSIGNED_INT_1010102_REV: 1985 case tcu::TextureFormat::SIGNED_INT_1010102_REV: 1986 return false; 1987 1988 default: 1989 return true; 1990 } 1991 } 1992 else 1993 { 1994 switch (format) 1995 { 1996 case VK_FORMAT_A8B8G8R8_UNORM_PACK32: 1997 case VK_FORMAT_A8B8G8R8_SNORM_PACK32: 1998 case VK_FORMAT_A8B8G8R8_USCALED_PACK32: 1999 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: 2000 case VK_FORMAT_A8B8G8R8_UINT_PACK32: 2001 case VK_FORMAT_A8B8G8R8_SINT_PACK32: 2002 case VK_FORMAT_A8B8G8R8_SRGB_PACK32: 2003 return false; // These map to regular byte array formats 2004 2005 default: 2006 break; 2007 } 2008 2009 return (format != VK_FORMAT_UNDEFINED); 2010 } 2011 } 2012 2013 tcu::TextureFormat getChannelAccessFormat (tcu::TextureChannelClass type, 2014 deUint32 offsetBits, 2015 deUint32 sizeBits) 2016 { 2017 using tcu::TextureFormat; 2018 2019 if (offsetBits == 0) 2020 { 2021 static const TextureFormat::ChannelType s_size8[tcu::TEXTURECHANNELCLASS_LAST] = 2022 { 2023 TextureFormat::SNORM_INT8, // snorm 2024 TextureFormat::UNORM_INT8, // unorm 2025 TextureFormat::SIGNED_INT8, // sint 2026 TextureFormat::UNSIGNED_INT8, // uint 2027 TextureFormat::CHANNELTYPE_LAST, // float 2028 }; 2029 static const TextureFormat::ChannelType s_size16[tcu::TEXTURECHANNELCLASS_LAST] = 2030 { 2031 TextureFormat::SNORM_INT16, // snorm 2032 TextureFormat::UNORM_INT16, // unorm 2033 TextureFormat::SIGNED_INT16, // sint 2034 TextureFormat::UNSIGNED_INT16, // uint 2035 TextureFormat::HALF_FLOAT, // float 2036 }; 2037 static const TextureFormat::ChannelType s_size32[tcu::TEXTURECHANNELCLASS_LAST] = 2038 { 2039 TextureFormat::SNORM_INT32, // snorm 2040 TextureFormat::UNORM_INT32, // unorm 2041 TextureFormat::SIGNED_INT32, // sint 2042 TextureFormat::UNSIGNED_INT32, // uint 2043 TextureFormat::FLOAT, // float 2044 }; 2045 2046 TextureFormat::ChannelType chnType = TextureFormat::CHANNELTYPE_LAST; 2047 2048 if (sizeBits == 8) 2049 chnType = s_size8[type]; 2050 else if (sizeBits == 16) 2051 chnType = s_size16[type]; 2052 else if (sizeBits == 32) 2053 chnType = s_size32[type]; 2054 2055 if (chnType != TextureFormat::CHANNELTYPE_LAST) 2056 return TextureFormat(TextureFormat::R, chnType); 2057 } 2058 else 2059 { 2060 if (type == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT && 2061 offsetBits == 6 && 2062 sizeBits == 10) 2063 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_10); 2064 else if (type == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT && 2065 offsetBits == 4 && 2066 sizeBits == 12) 2067 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_12); 2068 } 2069 2070 TCU_THROW(InternalError, "Channel access format is not supported"); 2071 } 2072 2073 tcu::PixelBufferAccess getChannelAccess (const PlanarFormatDescription& formatInfo, 2074 const tcu::UVec2& size, 2075 const deUint32* planeRowPitches, 2076 void* const* planePtrs, 2077 deUint32 channelNdx) 2078 { 2079 DE_ASSERT(formatInfo.hasChannelNdx(channelNdx)); 2080 2081 const deUint32 planeNdx = formatInfo.channels[channelNdx].planeNdx; 2082 const deUint32 planeOffsetBytes = formatInfo.channels[channelNdx].offsetBits / 8; 2083 const deUint32 valueOffsetBits = formatInfo.channels[channelNdx].offsetBits % 8; 2084 const deUint32 pixelStrideBytes = formatInfo.channels[channelNdx].strideBytes; 2085 2086 DE_ASSERT(size.x() % formatInfo.planes[planeNdx].widthDivisor == 0); 2087 DE_ASSERT(size.y() % formatInfo.planes[planeNdx].heightDivisor == 0); 2088 2089 deUint32 accessWidth = size.x() / formatInfo.planes[planeNdx].widthDivisor; 2090 const deUint32 accessHeight = size.y() / formatInfo.planes[planeNdx].heightDivisor; 2091 const deUint32 elementSizeBytes = formatInfo.planes[planeNdx].elementSizeBytes; 2092 2093 const deUint32 rowPitch = planeRowPitches[planeNdx]; 2094 2095 if (pixelStrideBytes != elementSizeBytes) 2096 { 2097 DE_ASSERT(elementSizeBytes % pixelStrideBytes == 0); 2098 accessWidth *= elementSizeBytes/pixelStrideBytes; 2099 } 2100 2101 return tcu::PixelBufferAccess(getChannelAccessFormat((tcu::TextureChannelClass)formatInfo.channels[channelNdx].type, 2102 valueOffsetBits, 2103 formatInfo.channels[channelNdx].sizeBits), 2104 tcu::IVec3((int)accessWidth, (int)accessHeight, 1), 2105 tcu::IVec3((int)pixelStrideBytes, (int)rowPitch, 0), 2106 (deUint8*)planePtrs[planeNdx] + planeOffsetBytes); 2107 } 2108 2109 2110 tcu::ConstPixelBufferAccess getChannelAccess (const PlanarFormatDescription& formatInfo, 2111 const tcu::UVec2& size, 2112 const deUint32* planeRowPitches, 2113 const void* const* planePtrs, 2114 deUint32 channelNdx) 2115 { 2116 return getChannelAccess(formatInfo, size, planeRowPitches, const_cast<void* const*>(planePtrs), channelNdx); 2117 } 2118 2119 void imageUtilSelfTest (void) 2120 { 2121 for (int formatNdx = 0; formatNdx < VK_CORE_FORMAT_LAST; formatNdx++) 2122 { 2123 const VkFormat format = (VkFormat)formatNdx; 2124 2125 if (format == VK_FORMAT_R64_UINT || 2126 format == VK_FORMAT_R64_SINT || 2127 format == VK_FORMAT_R64G64_UINT || 2128 format == VK_FORMAT_R64G64_SINT || 2129 format == VK_FORMAT_R64G64B64_UINT || 2130 format == VK_FORMAT_R64G64B64_SINT || 2131 format == VK_FORMAT_R64G64B64A64_UINT || 2132 format == VK_FORMAT_R64G64B64A64_SINT) 2133 continue; // \todo [2015-12-05 pyry] Add framework support for (u)int64 channel type 2134 2135 if (format != VK_FORMAT_UNDEFINED && !isCompressedFormat(format)) 2136 { 2137 const tcu::TextureFormat tcuFormat = mapVkFormat(format); 2138 const VkFormat remappedFormat = mapTextureFormat(tcuFormat); 2139 2140 DE_TEST_ASSERT(isValid(tcuFormat)); 2141 2142 if (fullTextureFormatRoundTripSupported(format)) 2143 DE_TEST_ASSERT(format == remappedFormat); 2144 } 2145 } 2146 2147 for (int formatNdx = VK_FORMAT_G8B8G8R8_422_UNORM_KHR; formatNdx <= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR; formatNdx++) 2148 { 2149 const VkFormat format = (VkFormat)formatNdx; 2150 const PlanarFormatDescription& info = getPlanarFormatDescription(format); 2151 2152 DE_TEST_ASSERT(isYCbCrFormat(format)); 2153 DE_TEST_ASSERT(de::inRange<deUint8>(info.numPlanes, 1u, 3u)); 2154 DE_TEST_ASSERT(info.numPlanes == getPlaneCount(format)); 2155 } 2156 } 2157 2158 VkFilter mapFilterMode (tcu::Sampler::FilterMode filterMode) 2159 { 2160 DE_STATIC_ASSERT(tcu::Sampler::FILTERMODE_LAST == 6); 2161 2162 switch (filterMode) 2163 { 2164 case tcu::Sampler::NEAREST: return VK_FILTER_NEAREST; 2165 case tcu::Sampler::LINEAR: return VK_FILTER_LINEAR; 2166 case tcu::Sampler::NEAREST_MIPMAP_NEAREST: return VK_FILTER_NEAREST; 2167 case tcu::Sampler::NEAREST_MIPMAP_LINEAR: return VK_FILTER_NEAREST; 2168 case tcu::Sampler::LINEAR_MIPMAP_NEAREST: return VK_FILTER_LINEAR; 2169 case tcu::Sampler::LINEAR_MIPMAP_LINEAR: return VK_FILTER_LINEAR; 2170 default: 2171 DE_FATAL("Illegal filter mode"); 2172 return (VkFilter)0; 2173 } 2174 } 2175 2176 VkSamplerMipmapMode mapMipmapMode (tcu::Sampler::FilterMode filterMode) 2177 { 2178 DE_STATIC_ASSERT(tcu::Sampler::FILTERMODE_LAST == 6); 2179 2180 // \note VkSamplerCreateInfo doesn't have a flag for disabling mipmapping. Instead 2181 // minLod = 0 and maxLod = 0.25 should be used to match OpenGL NEAREST and LINEAR 2182 // filtering mode behavior. 2183 2184 switch (filterMode) 2185 { 2186 case tcu::Sampler::NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST; 2187 case tcu::Sampler::LINEAR: return VK_SAMPLER_MIPMAP_MODE_NEAREST; 2188 case tcu::Sampler::NEAREST_MIPMAP_NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST; 2189 case tcu::Sampler::NEAREST_MIPMAP_LINEAR: return VK_SAMPLER_MIPMAP_MODE_LINEAR; 2190 case tcu::Sampler::LINEAR_MIPMAP_NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST; 2191 case tcu::Sampler::LINEAR_MIPMAP_LINEAR: return VK_SAMPLER_MIPMAP_MODE_LINEAR; 2192 default: 2193 DE_FATAL("Illegal filter mode"); 2194 return (VkSamplerMipmapMode)0; 2195 } 2196 } 2197 2198 VkSamplerAddressMode mapWrapMode (tcu::Sampler::WrapMode wrapMode) 2199 { 2200 switch (wrapMode) 2201 { 2202 case tcu::Sampler::CLAMP_TO_EDGE: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; 2203 case tcu::Sampler::CLAMP_TO_BORDER: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER; 2204 case tcu::Sampler::REPEAT_GL: return VK_SAMPLER_ADDRESS_MODE_REPEAT; 2205 case tcu::Sampler::MIRRORED_REPEAT_GL: return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT; 2206 case tcu::Sampler::MIRRORED_ONCE: return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; 2207 default: 2208 DE_FATAL("Wrap mode can't be mapped to Vulkan"); 2209 return (vk::VkSamplerAddressMode)0; 2210 } 2211 } 2212 2213 vk::VkCompareOp mapCompareMode (tcu::Sampler::CompareMode mode) 2214 { 2215 switch (mode) 2216 { 2217 case tcu::Sampler::COMPAREMODE_NONE: return vk::VK_COMPARE_OP_NEVER; 2218 case tcu::Sampler::COMPAREMODE_LESS: return vk::VK_COMPARE_OP_LESS; 2219 case tcu::Sampler::COMPAREMODE_LESS_OR_EQUAL: return vk::VK_COMPARE_OP_LESS_OR_EQUAL; 2220 case tcu::Sampler::COMPAREMODE_GREATER: return vk::VK_COMPARE_OP_GREATER; 2221 case tcu::Sampler::COMPAREMODE_GREATER_OR_EQUAL: return vk::VK_COMPARE_OP_GREATER_OR_EQUAL; 2222 case tcu::Sampler::COMPAREMODE_EQUAL: return vk::VK_COMPARE_OP_EQUAL; 2223 case tcu::Sampler::COMPAREMODE_NOT_EQUAL: return vk::VK_COMPARE_OP_NOT_EQUAL; 2224 case tcu::Sampler::COMPAREMODE_ALWAYS: return vk::VK_COMPARE_OP_ALWAYS; 2225 case tcu::Sampler::COMPAREMODE_NEVER: return vk::VK_COMPARE_OP_NEVER; 2226 default: 2227 DE_FATAL("Illegal compare mode"); 2228 return (vk::VkCompareOp)0; 2229 } 2230 } 2231 2232 static VkBorderColor mapBorderColor (tcu::TextureChannelClass channelClass, const rr::GenericVec4& color) 2233 { 2234 if (channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER) 2235 { 2236 const tcu::UVec4 uColor = color.get<deUint32>(); 2237 2238 if (uColor == tcu::UVec4(0, 0, 0, 0)) return VK_BORDER_COLOR_INT_TRANSPARENT_BLACK; 2239 else if (uColor == tcu::UVec4(0, 0, 0, 1)) return VK_BORDER_COLOR_INT_OPAQUE_BLACK; 2240 else if (uColor == tcu::UVec4(1, 1, 1, 1)) return VK_BORDER_COLOR_INT_OPAQUE_WHITE; 2241 } 2242 else if (channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER) 2243 { 2244 const tcu::IVec4 sColor = color.get<deInt32>(); 2245 2246 if (sColor == tcu::IVec4(0, 0, 0, 0)) return VK_BORDER_COLOR_INT_TRANSPARENT_BLACK; 2247 else if (sColor == tcu::IVec4(0, 0, 0, 1)) return VK_BORDER_COLOR_INT_OPAQUE_BLACK; 2248 else if (sColor == tcu::IVec4(1, 1, 1, 1)) return VK_BORDER_COLOR_INT_OPAQUE_WHITE; 2249 } 2250 else 2251 { 2252 const tcu::Vec4 fColor = color.get<float>(); 2253 2254 if (fColor == tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f)) return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK; 2255 else if (fColor == tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)) return VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK; 2256 else if (fColor == tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f)) return VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE; 2257 } 2258 2259 DE_FATAL("Unsupported border color"); 2260 return VK_BORDER_COLOR_LAST; 2261 } 2262 2263 VkSamplerCreateInfo mapSampler (const tcu::Sampler& sampler, const tcu::TextureFormat& format, float minLod, float maxLod) 2264 { 2265 const bool compareEnabled = (sampler.compare != tcu::Sampler::COMPAREMODE_NONE); 2266 const VkCompareOp compareOp = (compareEnabled) ? (mapCompareMode(sampler.compare)) : (VK_COMPARE_OP_ALWAYS); 2267 const VkBorderColor borderColor = mapBorderColor(getTextureChannelClass(format.type), sampler.borderColor); 2268 const bool isMipmapEnabled = (sampler.minFilter != tcu::Sampler::NEAREST && sampler.minFilter != tcu::Sampler::LINEAR); 2269 2270 const VkSamplerCreateInfo createInfo = 2271 { 2272 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, 2273 DE_NULL, 2274 (VkSamplerCreateFlags)0, 2275 mapFilterMode(sampler.magFilter), // magFilter 2276 mapFilterMode(sampler.minFilter), // minFilter 2277 mapMipmapMode(sampler.minFilter), // mipMode 2278 mapWrapMode(sampler.wrapS), // addressU 2279 mapWrapMode(sampler.wrapT), // addressV 2280 mapWrapMode(sampler.wrapR), // addressW 2281 0.0f, // mipLodBias 2282 VK_FALSE, // anisotropyEnable 2283 1.0f, // maxAnisotropy 2284 (VkBool32)(compareEnabled ? VK_TRUE : VK_FALSE), // compareEnable 2285 compareOp, // compareOp 2286 (isMipmapEnabled ? minLod : 0.0f), // minLod 2287 (isMipmapEnabled ? maxLod : 0.25f), // maxLod 2288 borderColor, // borderColor 2289 (VkBool32)(sampler.normalizedCoords ? VK_FALSE : VK_TRUE), // unnormalizedCoords 2290 }; 2291 2292 return createInfo; 2293 } 2294 2295 tcu::Sampler mapVkSampler (const VkSamplerCreateInfo& samplerCreateInfo) 2296 { 2297 // \note minLod & maxLod are not supported by tcu::Sampler. LOD must be clamped 2298 // before passing it to tcu::Texture*::sample*() 2299 2300 tcu::Sampler sampler(mapVkSamplerAddressMode(samplerCreateInfo.addressModeU), 2301 mapVkSamplerAddressMode(samplerCreateInfo.addressModeV), 2302 mapVkSamplerAddressMode(samplerCreateInfo.addressModeW), 2303 mapVkMinTexFilter(samplerCreateInfo.minFilter, samplerCreateInfo.mipmapMode), 2304 mapVkMagTexFilter(samplerCreateInfo.magFilter), 2305 0.0f, 2306 !samplerCreateInfo.unnormalizedCoordinates, 2307 samplerCreateInfo.compareEnable ? mapVkSamplerCompareOp(samplerCreateInfo.compareOp) 2308 : tcu::Sampler::COMPAREMODE_NONE, 2309 0, 2310 tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), 2311 true); 2312 2313 if (samplerCreateInfo.anisotropyEnable) 2314 TCU_THROW(InternalError, "Anisotropic filtering is not supported by tcu::Sampler"); 2315 2316 switch (samplerCreateInfo.borderColor) 2317 { 2318 case VK_BORDER_COLOR_INT_OPAQUE_BLACK: 2319 sampler.borderColor = tcu::UVec4(0,0,0,1); 2320 break; 2321 case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK: 2322 sampler.borderColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f); 2323 break; 2324 case VK_BORDER_COLOR_INT_OPAQUE_WHITE: 2325 sampler.borderColor = tcu::UVec4(1, 1, 1, 1); 2326 break; 2327 case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE: 2328 sampler.borderColor = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f); 2329 break; 2330 case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK: 2331 sampler.borderColor = tcu::UVec4(0,0,0,0); 2332 break; 2333 case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK: 2334 sampler.borderColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f); 2335 break; 2336 2337 default: 2338 DE_ASSERT(false); 2339 break; 2340 } 2341 2342 return sampler; 2343 } 2344 2345 tcu::Sampler::CompareMode mapVkSamplerCompareOp (VkCompareOp compareOp) 2346 { 2347 switch (compareOp) 2348 { 2349 case VK_COMPARE_OP_NEVER: return tcu::Sampler::COMPAREMODE_NEVER; 2350 case VK_COMPARE_OP_LESS: return tcu::Sampler::COMPAREMODE_LESS; 2351 case VK_COMPARE_OP_EQUAL: return tcu::Sampler::COMPAREMODE_EQUAL; 2352 case VK_COMPARE_OP_LESS_OR_EQUAL: return tcu::Sampler::COMPAREMODE_LESS_OR_EQUAL; 2353 case VK_COMPARE_OP_GREATER: return tcu::Sampler::COMPAREMODE_GREATER; 2354 case VK_COMPARE_OP_NOT_EQUAL: return tcu::Sampler::COMPAREMODE_NOT_EQUAL; 2355 case VK_COMPARE_OP_GREATER_OR_EQUAL: return tcu::Sampler::COMPAREMODE_GREATER_OR_EQUAL; 2356 case VK_COMPARE_OP_ALWAYS: return tcu::Sampler::COMPAREMODE_ALWAYS; 2357 default: 2358 break; 2359 } 2360 2361 DE_ASSERT(false); 2362 return tcu::Sampler::COMPAREMODE_LAST; 2363 } 2364 2365 tcu::Sampler::WrapMode mapVkSamplerAddressMode (VkSamplerAddressMode addressMode) 2366 { 2367 switch (addressMode) 2368 { 2369 case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE: return tcu::Sampler::CLAMP_TO_EDGE; 2370 case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER: return tcu::Sampler::CLAMP_TO_BORDER; 2371 case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT: return tcu::Sampler::MIRRORED_REPEAT_GL; 2372 case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE: return tcu::Sampler::MIRRORED_ONCE; 2373 case VK_SAMPLER_ADDRESS_MODE_REPEAT: return tcu::Sampler::REPEAT_GL; 2374 default: 2375 break; 2376 } 2377 2378 DE_ASSERT(false); 2379 return tcu::Sampler::WRAPMODE_LAST; 2380 } 2381 2382 tcu::Sampler::FilterMode mapVkMinTexFilter (VkFilter filter, VkSamplerMipmapMode mipMode) 2383 { 2384 switch (filter) 2385 { 2386 case VK_FILTER_LINEAR: 2387 switch (mipMode) 2388 { 2389 case VK_SAMPLER_MIPMAP_MODE_LINEAR: return tcu::Sampler::LINEAR_MIPMAP_LINEAR; 2390 case VK_SAMPLER_MIPMAP_MODE_NEAREST: return tcu::Sampler::LINEAR_MIPMAP_NEAREST; 2391 default: 2392 break; 2393 } 2394 break; 2395 2396 case VK_FILTER_NEAREST: 2397 switch (mipMode) 2398 { 2399 case VK_SAMPLER_MIPMAP_MODE_LINEAR: return tcu::Sampler::NEAREST_MIPMAP_LINEAR; 2400 case VK_SAMPLER_MIPMAP_MODE_NEAREST: return tcu::Sampler::NEAREST_MIPMAP_NEAREST; 2401 default: 2402 break; 2403 } 2404 break; 2405 2406 default: 2407 break; 2408 } 2409 2410 DE_ASSERT(false); 2411 return tcu::Sampler::FILTERMODE_LAST; 2412 } 2413 2414 tcu::Sampler::FilterMode mapVkMagTexFilter (VkFilter filter) 2415 { 2416 switch (filter) 2417 { 2418 case VK_FILTER_LINEAR: return tcu::Sampler::LINEAR; 2419 case VK_FILTER_NEAREST: return tcu::Sampler::NEAREST; 2420 default: 2421 break; 2422 } 2423 2424 DE_ASSERT(false); 2425 return tcu::Sampler::FILTERMODE_LAST; 2426 } 2427 2428 //! Get a format the matches the layout in buffer memory used for a 2429 //! buffer<->image copy on a depth/stencil format. 2430 tcu::TextureFormat getDepthCopyFormat (VkFormat combinedFormat) 2431 { 2432 switch (combinedFormat) 2433 { 2434 case VK_FORMAT_D16_UNORM: 2435 case VK_FORMAT_X8_D24_UNORM_PACK32: 2436 case VK_FORMAT_D32_SFLOAT: 2437 return mapVkFormat(combinedFormat); 2438 2439 case VK_FORMAT_D16_UNORM_S8_UINT: 2440 return mapVkFormat(VK_FORMAT_D16_UNORM); 2441 case VK_FORMAT_D24_UNORM_S8_UINT: 2442 return mapVkFormat(VK_FORMAT_X8_D24_UNORM_PACK32); 2443 case VK_FORMAT_D32_SFLOAT_S8_UINT: 2444 return mapVkFormat(VK_FORMAT_D32_SFLOAT); 2445 2446 case VK_FORMAT_S8_UINT: 2447 default: 2448 DE_FATAL("Unexpected depth/stencil format"); 2449 return tcu::TextureFormat(); 2450 } 2451 } 2452 2453 //! Get a format the matches the layout in buffer memory used for a 2454 //! buffer<->image copy on a depth/stencil format. 2455 tcu::TextureFormat getStencilCopyFormat (VkFormat combinedFormat) 2456 { 2457 switch (combinedFormat) 2458 { 2459 case VK_FORMAT_D16_UNORM_S8_UINT: 2460 case VK_FORMAT_D24_UNORM_S8_UINT: 2461 case VK_FORMAT_D32_SFLOAT_S8_UINT: 2462 case VK_FORMAT_S8_UINT: 2463 return mapVkFormat(VK_FORMAT_S8_UINT); 2464 2465 case VK_FORMAT_D16_UNORM: 2466 case VK_FORMAT_X8_D24_UNORM_PACK32: 2467 case VK_FORMAT_D32_SFLOAT: 2468 default: 2469 DE_FATAL("Unexpected depth/stencil format"); 2470 return tcu::TextureFormat(); 2471 } 2472 } 2473 2474 } // vk 2475
