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 tcu::TextureFormat mapVkFormat (VkFormat format) 1643 { 1644 using tcu::TextureFormat; 1645 1646 // update this mapping if VkFormat changes 1647 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185); 1648 1649 switch (format) 1650 { 1651 case VK_FORMAT_R4G4_UNORM_PACK8: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_BYTE_44); 1652 case VK_FORMAT_R5G6B5_UNORM_PACK16: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_SHORT_565); 1653 case VK_FORMAT_R4G4B4A4_UNORM_PACK16: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_4444); 1654 case VK_FORMAT_R5G5B5A1_UNORM_PACK16: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_5551); 1655 1656 case VK_FORMAT_B5G6R5_UNORM_PACK16: return TextureFormat(TextureFormat::BGR, TextureFormat::UNORM_SHORT_565); 1657 case VK_FORMAT_B4G4R4A4_UNORM_PACK16: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_SHORT_4444); 1658 case VK_FORMAT_B5G5R5A1_UNORM_PACK16: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_SHORT_5551); 1659 1660 case VK_FORMAT_A1R5G5B5_UNORM_PACK16: return TextureFormat(TextureFormat::ARGB, TextureFormat::UNORM_SHORT_1555); 1661 1662 case VK_FORMAT_R8_UNORM: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT8); 1663 case VK_FORMAT_R8_SNORM: return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT8); 1664 case VK_FORMAT_R8_USCALED: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT8); 1665 case VK_FORMAT_R8_SSCALED: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT8); 1666 case VK_FORMAT_R8_UINT: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT8); 1667 case VK_FORMAT_R8_SINT: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT8); 1668 case VK_FORMAT_R8_SRGB: return TextureFormat(TextureFormat::sR, TextureFormat::UNORM_INT8); 1669 1670 case VK_FORMAT_R8G8_UNORM: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT8); 1671 case VK_FORMAT_R8G8_SNORM: return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT8); 1672 case VK_FORMAT_R8G8_USCALED: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT8); 1673 case VK_FORMAT_R8G8_SSCALED: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT8); 1674 case VK_FORMAT_R8G8_UINT: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT8); 1675 case VK_FORMAT_R8G8_SINT: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT8); 1676 case VK_FORMAT_R8G8_SRGB: return TextureFormat(TextureFormat::sRG, TextureFormat::UNORM_INT8); 1677 1678 case VK_FORMAT_R8G8B8_UNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8); 1679 case VK_FORMAT_R8G8B8_SNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::SNORM_INT8); 1680 case VK_FORMAT_R8G8B8_USCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT8); 1681 case VK_FORMAT_R8G8B8_SSCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT8); 1682 case VK_FORMAT_R8G8B8_UINT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT8); 1683 case VK_FORMAT_R8G8B8_SINT: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT8); 1684 case VK_FORMAT_R8G8B8_SRGB: return TextureFormat(TextureFormat::sRGB, TextureFormat::UNORM_INT8); 1685 1686 case VK_FORMAT_R8G8B8A8_UNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8); 1687 case VK_FORMAT_R8G8B8A8_SNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT8); 1688 case VK_FORMAT_R8G8B8A8_USCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8); 1689 case VK_FORMAT_R8G8B8A8_SSCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8); 1690 case VK_FORMAT_R8G8B8A8_UINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8); 1691 case VK_FORMAT_R8G8B8A8_SINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8); 1692 case VK_FORMAT_R8G8B8A8_SRGB: return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8); 1693 1694 case VK_FORMAT_R16_UNORM: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT16); 1695 case VK_FORMAT_R16_SNORM: return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT16); 1696 case VK_FORMAT_R16_USCALED: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT16); 1697 case VK_FORMAT_R16_SSCALED: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT16); 1698 case VK_FORMAT_R16_UINT: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT16); 1699 case VK_FORMAT_R16_SINT: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT16); 1700 case VK_FORMAT_R16_SFLOAT: return TextureFormat(TextureFormat::R, TextureFormat::HALF_FLOAT); 1701 1702 case VK_FORMAT_R16G16_UNORM: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT16); 1703 case VK_FORMAT_R16G16_SNORM: return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT16); 1704 case VK_FORMAT_R16G16_USCALED: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT16); 1705 case VK_FORMAT_R16G16_SSCALED: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT16); 1706 case VK_FORMAT_R16G16_UINT: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT16); 1707 case VK_FORMAT_R16G16_SINT: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT16); 1708 case VK_FORMAT_R16G16_SFLOAT: return TextureFormat(TextureFormat::RG, TextureFormat::HALF_FLOAT); 1709 1710 case VK_FORMAT_R16G16B16_UNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT16); 1711 case VK_FORMAT_R16G16B16_SNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::SNORM_INT16); 1712 case VK_FORMAT_R16G16B16_USCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT16); 1713 case VK_FORMAT_R16G16B16_SSCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT16); 1714 case VK_FORMAT_R16G16B16_UINT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT16); 1715 case VK_FORMAT_R16G16B16_SINT: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT16); 1716 case VK_FORMAT_R16G16B16_SFLOAT: return TextureFormat(TextureFormat::RGB, TextureFormat::HALF_FLOAT); 1717 1718 case VK_FORMAT_R16G16B16A16_UNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT16); 1719 case VK_FORMAT_R16G16B16A16_SNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT16); 1720 case VK_FORMAT_R16G16B16A16_USCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT16); 1721 case VK_FORMAT_R16G16B16A16_SSCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT16); 1722 case VK_FORMAT_R16G16B16A16_UINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT16); 1723 case VK_FORMAT_R16G16B16A16_SINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT16); 1724 case VK_FORMAT_R16G16B16A16_SFLOAT: return TextureFormat(TextureFormat::RGBA, TextureFormat::HALF_FLOAT); 1725 1726 case VK_FORMAT_R32_UINT: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT32); 1727 case VK_FORMAT_R32_SINT: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT32); 1728 case VK_FORMAT_R32_SFLOAT: return TextureFormat(TextureFormat::R, TextureFormat::FLOAT); 1729 1730 case VK_FORMAT_R32G32_UINT: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT32); 1731 case VK_FORMAT_R32G32_SINT: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT32); 1732 case VK_FORMAT_R32G32_SFLOAT: return TextureFormat(TextureFormat::RG, TextureFormat::FLOAT); 1733 1734 case VK_FORMAT_R32G32B32_UINT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT32); 1735 case VK_FORMAT_R32G32B32_SINT: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT32); 1736 case VK_FORMAT_R32G32B32_SFLOAT: return TextureFormat(TextureFormat::RGB, TextureFormat::FLOAT); 1737 1738 case VK_FORMAT_R32G32B32A32_UINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32); 1739 case VK_FORMAT_R32G32B32A32_SINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT32); 1740 case VK_FORMAT_R32G32B32A32_SFLOAT: return TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT); 1741 1742 case VK_FORMAT_R64_SFLOAT: return TextureFormat(TextureFormat::R, TextureFormat::FLOAT64); 1743 case VK_FORMAT_R64G64_SFLOAT: return TextureFormat(TextureFormat::RG, TextureFormat::FLOAT64); 1744 case VK_FORMAT_R64G64B64_SFLOAT: return TextureFormat(TextureFormat::RGB, TextureFormat::FLOAT64); 1745 case VK_FORMAT_R64G64B64A64_SFLOAT: return TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT64); 1746 1747 case VK_FORMAT_B10G11R11_UFLOAT_PACK32: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT_11F_11F_10F_REV); 1748 case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT_999_E5_REV); 1749 1750 case VK_FORMAT_B8G8R8_UNORM: return TextureFormat(TextureFormat::BGR, TextureFormat::UNORM_INT8); 1751 case VK_FORMAT_B8G8R8_SNORM: return TextureFormat(TextureFormat::BGR, TextureFormat::SNORM_INT8); 1752 case VK_FORMAT_B8G8R8_USCALED: return TextureFormat(TextureFormat::BGR, TextureFormat::UNSIGNED_INT8); 1753 case VK_FORMAT_B8G8R8_SSCALED: return TextureFormat(TextureFormat::BGR, TextureFormat::SIGNED_INT8); 1754 case VK_FORMAT_B8G8R8_UINT: return TextureFormat(TextureFormat::BGR, TextureFormat::UNSIGNED_INT8); 1755 case VK_FORMAT_B8G8R8_SINT: return TextureFormat(TextureFormat::BGR, TextureFormat::SIGNED_INT8); 1756 case VK_FORMAT_B8G8R8_SRGB: return TextureFormat(TextureFormat::sBGR, TextureFormat::UNORM_INT8); 1757 1758 case VK_FORMAT_B8G8R8A8_UNORM: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_INT8); 1759 case VK_FORMAT_B8G8R8A8_SNORM: return TextureFormat(TextureFormat::BGRA, TextureFormat::SNORM_INT8); 1760 case VK_FORMAT_B8G8R8A8_USCALED: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT8); 1761 case VK_FORMAT_B8G8R8A8_SSCALED: return TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT8); 1762 case VK_FORMAT_B8G8R8A8_UINT: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT8); 1763 case VK_FORMAT_B8G8R8A8_SINT: return TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT8); 1764 case VK_FORMAT_B8G8R8A8_SRGB: return TextureFormat(TextureFormat::sBGRA, TextureFormat::UNORM_INT8); 1765 1766 case VK_FORMAT_D16_UNORM: return TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT16); 1767 case VK_FORMAT_X8_D24_UNORM_PACK32: return TextureFormat(TextureFormat::D, TextureFormat::UNSIGNED_INT_24_8_REV); 1768 case VK_FORMAT_D32_SFLOAT: return TextureFormat(TextureFormat::D, TextureFormat::FLOAT); 1769 1770 case VK_FORMAT_S8_UINT: return TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8); 1771 1772 // \note There is no standard interleaved memory layout for DS formats; buffer-image copies 1773 // will always operate on either D or S aspect only. See Khronos bug 12998 1774 case VK_FORMAT_D16_UNORM_S8_UINT: return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_16_8_8); 1775 case VK_FORMAT_D24_UNORM_S8_UINT: return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_24_8_REV); 1776 case VK_FORMAT_D32_SFLOAT_S8_UINT: return TextureFormat(TextureFormat::DS, TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV); 1777 1778 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 1779 case VK_FORMAT_A8B8G8R8_UNORM_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8); 1780 case VK_FORMAT_A8B8G8R8_SNORM_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT8); 1781 case VK_FORMAT_A8B8G8R8_USCALED_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8); 1782 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8); 1783 case VK_FORMAT_A8B8G8R8_UINT_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8); 1784 case VK_FORMAT_A8B8G8R8_SINT_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8); 1785 case VK_FORMAT_A8B8G8R8_SRGB_PACK32: return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8); 1786 #else 1787 # error "Big-endian not supported" 1788 #endif 1789 1790 case VK_FORMAT_A2R10G10B10_UNORM_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_INT_1010102_REV); 1791 case VK_FORMAT_A2R10G10B10_SNORM_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::SNORM_INT_1010102_REV); 1792 case VK_FORMAT_A2R10G10B10_USCALED_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT_1010102_REV); 1793 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT_1010102_REV); 1794 case VK_FORMAT_A2R10G10B10_UINT_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT_1010102_REV); 1795 case VK_FORMAT_A2R10G10B10_SINT_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT_1010102_REV); 1796 1797 case VK_FORMAT_A2B10G10R10_UNORM_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT_1010102_REV); 1798 case VK_FORMAT_A2B10G10R10_SNORM_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT_1010102_REV); 1799 case VK_FORMAT_A2B10G10R10_USCALED_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT_1010102_REV); 1800 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT_1010102_REV); 1801 case VK_FORMAT_A2B10G10R10_UINT_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT_1010102_REV); 1802 case VK_FORMAT_A2B10G10R10_SINT_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT_1010102_REV); 1803 1804 // YCbCr formats that can be mapped 1805 case VK_FORMAT_R10X6_UNORM_PACK16_KHR: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_10); 1806 case VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_SHORT_10); 1807 case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_10); 1808 1809 case VK_FORMAT_R12X4_UNORM_PACK16_KHR: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_12); 1810 case VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_SHORT_12); 1811 case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_12); 1812 1813 default: 1814 TCU_THROW(InternalError, "Unknown image format"); 1815 } 1816 } 1817 1818 tcu::CompressedTexFormat mapVkCompressedFormat (VkFormat format) 1819 { 1820 // update this mapping if VkFormat changes 1821 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185); 1822 1823 switch (format) 1824 { 1825 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8; 1826 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8; 1827 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1; 1828 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1; 1829 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8; 1830 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8; 1831 case VK_FORMAT_EAC_R11_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_EAC_R11; 1832 case VK_FORMAT_EAC_R11_SNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_R11; 1833 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_EAC_RG11; 1834 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11; 1835 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_RGBA; 1836 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_SRGB8_ALPHA8; 1837 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_RGBA; 1838 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_SRGB8_ALPHA8; 1839 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_RGBA; 1840 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8; 1841 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_RGBA; 1842 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_SRGB8_ALPHA8; 1843 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_RGBA; 1844 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_SRGB8_ALPHA8; 1845 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_RGBA; 1846 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_SRGB8_ALPHA8; 1847 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_RGBA; 1848 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8; 1849 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_RGBA; 1850 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_SRGB8_ALPHA8; 1851 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_RGBA; 1852 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_SRGB8_ALPHA8; 1853 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_RGBA; 1854 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_SRGB8_ALPHA8; 1855 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_RGBA; 1856 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_SRGB8_ALPHA8; 1857 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_RGBA; 1858 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_SRGB8_ALPHA8; 1859 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_RGBA; 1860 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_SRGB8_ALPHA8; 1861 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_RGBA; 1862 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_SRGB8_ALPHA8; 1863 default: 1864 break; 1865 } 1866 1867 return tcu::COMPRESSEDTEXFORMAT_LAST; 1868 } 1869 1870 static bool isScaledFormat (VkFormat format) 1871 { 1872 // update this mapping if VkFormat changes 1873 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185); 1874 1875 switch (format) 1876 { 1877 case VK_FORMAT_R8_USCALED: 1878 case VK_FORMAT_R8_SSCALED: 1879 case VK_FORMAT_R8G8_USCALED: 1880 case VK_FORMAT_R8G8_SSCALED: 1881 case VK_FORMAT_R8G8B8_USCALED: 1882 case VK_FORMAT_R8G8B8_SSCALED: 1883 case VK_FORMAT_R8G8B8A8_USCALED: 1884 case VK_FORMAT_R8G8B8A8_SSCALED: 1885 case VK_FORMAT_A2B10G10R10_USCALED_PACK32: 1886 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: 1887 case VK_FORMAT_R16_USCALED: 1888 case VK_FORMAT_R16_SSCALED: 1889 case VK_FORMAT_R16G16_USCALED: 1890 case VK_FORMAT_R16G16_SSCALED: 1891 case VK_FORMAT_R16G16B16_USCALED: 1892 case VK_FORMAT_R16G16B16_SSCALED: 1893 case VK_FORMAT_R16G16B16A16_USCALED: 1894 case VK_FORMAT_R16G16B16A16_SSCALED: 1895 case VK_FORMAT_B8G8R8_USCALED: 1896 case VK_FORMAT_B8G8R8_SSCALED: 1897 case VK_FORMAT_B8G8R8A8_USCALED: 1898 case VK_FORMAT_B8G8R8A8_SSCALED: 1899 case VK_FORMAT_A2R10G10B10_USCALED_PACK32: 1900 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: 1901 return true; 1902 1903 default: 1904 return false; 1905 } 1906 } 1907 1908 static bool fullTextureFormatRoundTripSupported (VkFormat format) 1909 { 1910 if (isScaledFormat(format)) 1911 { 1912 // *SCALED formats get mapped to correspoding (u)int formats since 1913 // accessing them through (float) getPixel/setPixel has same behavior 1914 // as in shader access in Vulkan. 1915 // Unfortunately full round-trip between tcu::TextureFormat and VkFormat 1916 // for most SCALED formats is not supported though. 1917 1918 const tcu::TextureFormat tcuFormat = mapVkFormat(format); 1919 1920 switch (tcuFormat.type) 1921 { 1922 case tcu::TextureFormat::UNSIGNED_INT8: 1923 case tcu::TextureFormat::UNSIGNED_INT16: 1924 case tcu::TextureFormat::UNSIGNED_INT32: 1925 case tcu::TextureFormat::SIGNED_INT8: 1926 case tcu::TextureFormat::SIGNED_INT16: 1927 case tcu::TextureFormat::SIGNED_INT32: 1928 case tcu::TextureFormat::UNSIGNED_INT_1010102_REV: 1929 case tcu::TextureFormat::SIGNED_INT_1010102_REV: 1930 return false; 1931 1932 default: 1933 return true; 1934 } 1935 } 1936 else 1937 { 1938 switch (format) 1939 { 1940 case VK_FORMAT_A8B8G8R8_UNORM_PACK32: 1941 case VK_FORMAT_A8B8G8R8_SNORM_PACK32: 1942 case VK_FORMAT_A8B8G8R8_USCALED_PACK32: 1943 case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: 1944 case VK_FORMAT_A8B8G8R8_UINT_PACK32: 1945 case VK_FORMAT_A8B8G8R8_SINT_PACK32: 1946 case VK_FORMAT_A8B8G8R8_SRGB_PACK32: 1947 return false; // These map to regular byte array formats 1948 1949 default: 1950 break; 1951 } 1952 1953 return (format != VK_FORMAT_UNDEFINED); 1954 } 1955 } 1956 1957 tcu::TextureFormat getChannelAccessFormat (tcu::TextureChannelClass type, 1958 deUint32 offsetBits, 1959 deUint32 sizeBits) 1960 { 1961 using tcu::TextureFormat; 1962 1963 if (offsetBits == 0) 1964 { 1965 static const TextureFormat::ChannelType s_size8[tcu::TEXTURECHANNELCLASS_LAST] = 1966 { 1967 TextureFormat::SNORM_INT8, // snorm 1968 TextureFormat::UNORM_INT8, // unorm 1969 TextureFormat::SIGNED_INT8, // sint 1970 TextureFormat::UNSIGNED_INT8, // uint 1971 TextureFormat::CHANNELTYPE_LAST, // float 1972 }; 1973 static const TextureFormat::ChannelType s_size16[tcu::TEXTURECHANNELCLASS_LAST] = 1974 { 1975 TextureFormat::SNORM_INT16, // snorm 1976 TextureFormat::UNORM_INT16, // unorm 1977 TextureFormat::SIGNED_INT16, // sint 1978 TextureFormat::UNSIGNED_INT16, // uint 1979 TextureFormat::HALF_FLOAT, // float 1980 }; 1981 static const TextureFormat::ChannelType s_size32[tcu::TEXTURECHANNELCLASS_LAST] = 1982 { 1983 TextureFormat::SNORM_INT32, // snorm 1984 TextureFormat::UNORM_INT32, // unorm 1985 TextureFormat::SIGNED_INT32, // sint 1986 TextureFormat::UNSIGNED_INT32, // uint 1987 TextureFormat::FLOAT, // float 1988 }; 1989 1990 TextureFormat::ChannelType chnType = TextureFormat::CHANNELTYPE_LAST; 1991 1992 if (sizeBits == 8) 1993 chnType = s_size8[type]; 1994 else if (sizeBits == 16) 1995 chnType = s_size16[type]; 1996 else if (sizeBits == 32) 1997 chnType = s_size32[type]; 1998 1999 if (chnType != TextureFormat::CHANNELTYPE_LAST) 2000 return TextureFormat(TextureFormat::R, chnType); 2001 } 2002 else 2003 { 2004 if (type == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT && 2005 offsetBits == 6 && 2006 sizeBits == 10) 2007 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_10); 2008 else if (type == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT && 2009 offsetBits == 4 && 2010 sizeBits == 12) 2011 return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_12); 2012 } 2013 2014 TCU_THROW(InternalError, "Channel access format is not supported"); 2015 } 2016 2017 tcu::PixelBufferAccess getChannelAccess (const PlanarFormatDescription& formatInfo, 2018 const tcu::UVec2& size, 2019 const deUint32* planeRowPitches, 2020 void* const* planePtrs, 2021 deUint32 channelNdx) 2022 { 2023 DE_ASSERT(formatInfo.hasChannelNdx(channelNdx)); 2024 2025 const deUint32 planeNdx = formatInfo.channels[channelNdx].planeNdx; 2026 const deUint32 planeOffsetBytes = formatInfo.channels[channelNdx].offsetBits / 8; 2027 const deUint32 valueOffsetBits = formatInfo.channels[channelNdx].offsetBits % 8; 2028 const deUint32 pixelStrideBytes = formatInfo.channels[channelNdx].strideBytes; 2029 2030 DE_ASSERT(size.x() % formatInfo.planes[planeNdx].widthDivisor == 0); 2031 DE_ASSERT(size.y() % formatInfo.planes[planeNdx].heightDivisor == 0); 2032 2033 deUint32 accessWidth = size.x() / formatInfo.planes[planeNdx].widthDivisor; 2034 const deUint32 accessHeight = size.y() / formatInfo.planes[planeNdx].heightDivisor; 2035 const deUint32 elementSizeBytes = formatInfo.planes[planeNdx].elementSizeBytes; 2036 2037 const deUint32 rowPitch = planeRowPitches[planeNdx]; 2038 2039 if (pixelStrideBytes != elementSizeBytes) 2040 { 2041 DE_ASSERT(elementSizeBytes % pixelStrideBytes == 0); 2042 accessWidth *= elementSizeBytes/pixelStrideBytes; 2043 } 2044 2045 return tcu::PixelBufferAccess(getChannelAccessFormat((tcu::TextureChannelClass)formatInfo.channels[channelNdx].type, 2046 valueOffsetBits, 2047 formatInfo.channels[channelNdx].sizeBits), 2048 tcu::IVec3((int)accessWidth, (int)accessHeight, 1), 2049 tcu::IVec3((int)pixelStrideBytes, (int)rowPitch, 0), 2050 (deUint8*)planePtrs[planeNdx] + planeOffsetBytes); 2051 } 2052 2053 2054 tcu::ConstPixelBufferAccess getChannelAccess (const PlanarFormatDescription& formatInfo, 2055 const tcu::UVec2& size, 2056 const deUint32* planeRowPitches, 2057 const void* const* planePtrs, 2058 deUint32 channelNdx) 2059 { 2060 return getChannelAccess(formatInfo, size, planeRowPitches, const_cast<void* const*>(planePtrs), channelNdx); 2061 } 2062 2063 void imageUtilSelfTest (void) 2064 { 2065 for (int formatNdx = 0; formatNdx < VK_CORE_FORMAT_LAST; formatNdx++) 2066 { 2067 const VkFormat format = (VkFormat)formatNdx; 2068 2069 if (format == VK_FORMAT_R64_UINT || 2070 format == VK_FORMAT_R64_SINT || 2071 format == VK_FORMAT_R64G64_UINT || 2072 format == VK_FORMAT_R64G64_SINT || 2073 format == VK_FORMAT_R64G64B64_UINT || 2074 format == VK_FORMAT_R64G64B64_SINT || 2075 format == VK_FORMAT_R64G64B64A64_UINT || 2076 format == VK_FORMAT_R64G64B64A64_SINT) 2077 continue; // \todo [2015-12-05 pyry] Add framework support for (u)int64 channel type 2078 2079 if (format != VK_FORMAT_UNDEFINED && !isCompressedFormat(format)) 2080 { 2081 const tcu::TextureFormat tcuFormat = mapVkFormat(format); 2082 const VkFormat remappedFormat = mapTextureFormat(tcuFormat); 2083 2084 DE_TEST_ASSERT(isValid(tcuFormat)); 2085 2086 if (fullTextureFormatRoundTripSupported(format)) 2087 DE_TEST_ASSERT(format == remappedFormat); 2088 } 2089 } 2090 2091 for (int formatNdx = VK_FORMAT_G8B8G8R8_422_UNORM_KHR; formatNdx <= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR; formatNdx++) 2092 { 2093 const VkFormat format = (VkFormat)formatNdx; 2094 const PlanarFormatDescription& info = getPlanarFormatDescription(format); 2095 2096 DE_TEST_ASSERT(isYCbCrFormat(format)); 2097 DE_TEST_ASSERT(de::inRange<deUint8>(info.numPlanes, 1u, 3u)); 2098 DE_TEST_ASSERT(info.numPlanes == getPlaneCount(format)); 2099 } 2100 } 2101 2102 VkFilter mapFilterMode (tcu::Sampler::FilterMode filterMode) 2103 { 2104 DE_STATIC_ASSERT(tcu::Sampler::FILTERMODE_LAST == 6); 2105 2106 switch (filterMode) 2107 { 2108 case tcu::Sampler::NEAREST: return VK_FILTER_NEAREST; 2109 case tcu::Sampler::LINEAR: return VK_FILTER_LINEAR; 2110 case tcu::Sampler::NEAREST_MIPMAP_NEAREST: return VK_FILTER_NEAREST; 2111 case tcu::Sampler::NEAREST_MIPMAP_LINEAR: return VK_FILTER_NEAREST; 2112 case tcu::Sampler::LINEAR_MIPMAP_NEAREST: return VK_FILTER_LINEAR; 2113 case tcu::Sampler::LINEAR_MIPMAP_LINEAR: return VK_FILTER_LINEAR; 2114 default: 2115 DE_FATAL("Illegal filter mode"); 2116 return (VkFilter)0; 2117 2118 } 2119 } 2120 2121 VkSamplerMipmapMode mapMipmapMode (tcu::Sampler::FilterMode filterMode) 2122 { 2123 DE_STATIC_ASSERT(tcu::Sampler::FILTERMODE_LAST == 6); 2124 2125 // \note VkSamplerCreateInfo doesn't have a flag for disabling mipmapping. Instead 2126 // minLod = 0 and maxLod = 0.25 should be used to match OpenGL NEAREST and LINEAR 2127 // filtering mode behavior. 2128 2129 switch (filterMode) 2130 { 2131 case tcu::Sampler::NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST; 2132 case tcu::Sampler::LINEAR: return VK_SAMPLER_MIPMAP_MODE_NEAREST; 2133 case tcu::Sampler::NEAREST_MIPMAP_NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST; 2134 case tcu::Sampler::NEAREST_MIPMAP_LINEAR: return VK_SAMPLER_MIPMAP_MODE_LINEAR; 2135 case tcu::Sampler::LINEAR_MIPMAP_NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST; 2136 case tcu::Sampler::LINEAR_MIPMAP_LINEAR: return VK_SAMPLER_MIPMAP_MODE_LINEAR; 2137 default: 2138 DE_FATAL("Illegal filter mode"); 2139 return (VkSamplerMipmapMode)0; 2140 } 2141 } 2142 2143 VkSamplerAddressMode mapWrapMode (tcu::Sampler::WrapMode wrapMode) 2144 { 2145 switch (wrapMode) 2146 { 2147 case tcu::Sampler::CLAMP_TO_EDGE: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; 2148 case tcu::Sampler::CLAMP_TO_BORDER: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER; 2149 case tcu::Sampler::REPEAT_GL: return VK_SAMPLER_ADDRESS_MODE_REPEAT; 2150 case tcu::Sampler::MIRRORED_REPEAT_GL: return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT; 2151 case tcu::Sampler::MIRRORED_ONCE: return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; 2152 default: 2153 DE_FATAL("Wrap mode can't be mapped to Vulkan"); 2154 return (vk::VkSamplerAddressMode)0; 2155 } 2156 } 2157 2158 vk::VkCompareOp mapCompareMode (tcu::Sampler::CompareMode mode) 2159 { 2160 switch (mode) 2161 { 2162 case tcu::Sampler::COMPAREMODE_NONE: return vk::VK_COMPARE_OP_NEVER; 2163 case tcu::Sampler::COMPAREMODE_LESS: return vk::VK_COMPARE_OP_LESS; 2164 case tcu::Sampler::COMPAREMODE_LESS_OR_EQUAL: return vk::VK_COMPARE_OP_LESS_OR_EQUAL; 2165 case tcu::Sampler::COMPAREMODE_GREATER: return vk::VK_COMPARE_OP_GREATER; 2166 case tcu::Sampler::COMPAREMODE_GREATER_OR_EQUAL: return vk::VK_COMPARE_OP_GREATER_OR_EQUAL; 2167 case tcu::Sampler::COMPAREMODE_EQUAL: return vk::VK_COMPARE_OP_EQUAL; 2168 case tcu::Sampler::COMPAREMODE_NOT_EQUAL: return vk::VK_COMPARE_OP_NOT_EQUAL; 2169 case tcu::Sampler::COMPAREMODE_ALWAYS: return vk::VK_COMPARE_OP_ALWAYS; 2170 case tcu::Sampler::COMPAREMODE_NEVER: return vk::VK_COMPARE_OP_NEVER; 2171 default: 2172 DE_FATAL("Illegal compare mode"); 2173 return (vk::VkCompareOp)0; 2174 } 2175 } 2176 2177 static VkBorderColor mapBorderColor (tcu::TextureChannelClass channelClass, const rr::GenericVec4& color) 2178 { 2179 if (channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER) 2180 { 2181 const tcu::UVec4 uColor = color.get<deUint32>(); 2182 2183 if (uColor == tcu::UVec4(0, 0, 0, 0)) return VK_BORDER_COLOR_INT_TRANSPARENT_BLACK; 2184 else if (uColor == tcu::UVec4(0, 0, 0, 1)) return VK_BORDER_COLOR_INT_OPAQUE_BLACK; 2185 else if (uColor == tcu::UVec4(1, 1, 1, 1)) return VK_BORDER_COLOR_INT_OPAQUE_WHITE; 2186 } 2187 else if (channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER) 2188 { 2189 const tcu::IVec4 sColor = color.get<deInt32>(); 2190 2191 if (sColor == tcu::IVec4(0, 0, 0, 0)) return VK_BORDER_COLOR_INT_TRANSPARENT_BLACK; 2192 else if (sColor == tcu::IVec4(0, 0, 0, 1)) return VK_BORDER_COLOR_INT_OPAQUE_BLACK; 2193 else if (sColor == tcu::IVec4(1, 1, 1, 1)) return VK_BORDER_COLOR_INT_OPAQUE_WHITE; 2194 } 2195 else 2196 { 2197 const tcu::Vec4 fColor = color.get<float>(); 2198 2199 if (fColor == tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f)) return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK; 2200 else if (fColor == tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)) return VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK; 2201 else if (fColor == tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f)) return VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE; 2202 } 2203 2204 DE_FATAL("Unsupported border color"); 2205 return VK_BORDER_COLOR_LAST; 2206 } 2207 2208 VkSamplerCreateInfo mapSampler (const tcu::Sampler& sampler, const tcu::TextureFormat& format, float minLod, float maxLod) 2209 { 2210 const bool compareEnabled = (sampler.compare != tcu::Sampler::COMPAREMODE_NONE); 2211 const VkCompareOp compareOp = (compareEnabled) ? (mapCompareMode(sampler.compare)) : (VK_COMPARE_OP_ALWAYS); 2212 const VkBorderColor borderColor = mapBorderColor(getTextureChannelClass(format.type), sampler.borderColor); 2213 const bool isMipmapEnabled = (sampler.minFilter != tcu::Sampler::NEAREST && sampler.minFilter != tcu::Sampler::LINEAR); 2214 2215 const VkSamplerCreateInfo createInfo = 2216 { 2217 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, 2218 DE_NULL, 2219 (VkSamplerCreateFlags)0, 2220 mapFilterMode(sampler.magFilter), // magFilter 2221 mapFilterMode(sampler.minFilter), // minFilter 2222 mapMipmapMode(sampler.minFilter), // mipMode 2223 mapWrapMode(sampler.wrapS), // addressU 2224 mapWrapMode(sampler.wrapT), // addressV 2225 mapWrapMode(sampler.wrapR), // addressW 2226 0.0f, // mipLodBias 2227 VK_FALSE, // anisotropyEnable 2228 1.0f, // maxAnisotropy 2229 (VkBool32)(compareEnabled ? VK_TRUE : VK_FALSE), // compareEnable 2230 compareOp, // compareOp 2231 (isMipmapEnabled ? minLod : 0.0f), // minLod 2232 (isMipmapEnabled ? maxLod : 0.25f), // maxLod 2233 borderColor, // borderColor 2234 (VkBool32)(sampler.normalizedCoords ? VK_FALSE : VK_TRUE), // unnormalizedCoords 2235 }; 2236 2237 return createInfo; 2238 } 2239 2240 tcu::Sampler mapVkSampler (const VkSamplerCreateInfo& samplerCreateInfo) 2241 { 2242 // \note minLod & maxLod are not supported by tcu::Sampler. LOD must be clamped 2243 // before passing it to tcu::Texture*::sample*() 2244 2245 tcu::Sampler sampler(mapVkSamplerAddressMode(samplerCreateInfo.addressModeU), 2246 mapVkSamplerAddressMode(samplerCreateInfo.addressModeV), 2247 mapVkSamplerAddressMode(samplerCreateInfo.addressModeW), 2248 mapVkMinTexFilter(samplerCreateInfo.minFilter, samplerCreateInfo.mipmapMode), 2249 mapVkMagTexFilter(samplerCreateInfo.magFilter), 2250 0.0f, 2251 !samplerCreateInfo.unnormalizedCoordinates, 2252 samplerCreateInfo.compareEnable ? mapVkSamplerCompareOp(samplerCreateInfo.compareOp) 2253 : tcu::Sampler::COMPAREMODE_NONE, 2254 0, 2255 tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), 2256 true); 2257 2258 if (samplerCreateInfo.anisotropyEnable) 2259 TCU_THROW(InternalError, "Anisotropic filtering is not supported by tcu::Sampler"); 2260 2261 switch (samplerCreateInfo.borderColor) 2262 { 2263 case VK_BORDER_COLOR_INT_OPAQUE_BLACK: 2264 sampler.borderColor = tcu::UVec4(0,0,0,1); 2265 break; 2266 case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK: 2267 sampler.borderColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f); 2268 break; 2269 case VK_BORDER_COLOR_INT_OPAQUE_WHITE: 2270 sampler.borderColor = tcu::UVec4(1, 1, 1, 1); 2271 break; 2272 case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE: 2273 sampler.borderColor = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f); 2274 break; 2275 case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK: 2276 sampler.borderColor = tcu::UVec4(0,0,0,0); 2277 break; 2278 case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK: 2279 sampler.borderColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f); 2280 break; 2281 2282 default: 2283 DE_ASSERT(false); 2284 break; 2285 } 2286 2287 return sampler; 2288 } 2289 2290 tcu::Sampler::CompareMode mapVkSamplerCompareOp (VkCompareOp compareOp) 2291 { 2292 switch (compareOp) 2293 { 2294 case VK_COMPARE_OP_NEVER: return tcu::Sampler::COMPAREMODE_NEVER; 2295 case VK_COMPARE_OP_LESS: return tcu::Sampler::COMPAREMODE_LESS; 2296 case VK_COMPARE_OP_EQUAL: return tcu::Sampler::COMPAREMODE_EQUAL; 2297 case VK_COMPARE_OP_LESS_OR_EQUAL: return tcu::Sampler::COMPAREMODE_LESS_OR_EQUAL; 2298 case VK_COMPARE_OP_GREATER: return tcu::Sampler::COMPAREMODE_GREATER; 2299 case VK_COMPARE_OP_NOT_EQUAL: return tcu::Sampler::COMPAREMODE_NOT_EQUAL; 2300 case VK_COMPARE_OP_GREATER_OR_EQUAL: return tcu::Sampler::COMPAREMODE_GREATER_OR_EQUAL; 2301 case VK_COMPARE_OP_ALWAYS: return tcu::Sampler::COMPAREMODE_ALWAYS; 2302 default: 2303 break; 2304 } 2305 2306 DE_ASSERT(false); 2307 return tcu::Sampler::COMPAREMODE_LAST; 2308 } 2309 2310 tcu::Sampler::WrapMode mapVkSamplerAddressMode (VkSamplerAddressMode addressMode) 2311 { 2312 switch (addressMode) 2313 { 2314 case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE: return tcu::Sampler::CLAMP_TO_EDGE; 2315 case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER: return tcu::Sampler::CLAMP_TO_BORDER; 2316 case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT: return tcu::Sampler::MIRRORED_REPEAT_GL; 2317 case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE: return tcu::Sampler::MIRRORED_ONCE; 2318 case VK_SAMPLER_ADDRESS_MODE_REPEAT: return tcu::Sampler::REPEAT_GL; 2319 default: 2320 break; 2321 } 2322 2323 DE_ASSERT(false); 2324 return tcu::Sampler::WRAPMODE_LAST; 2325 } 2326 2327 tcu::Sampler::FilterMode mapVkMinTexFilter (VkFilter filter, VkSamplerMipmapMode mipMode) 2328 { 2329 switch (filter) 2330 { 2331 case VK_FILTER_LINEAR: 2332 switch (mipMode) 2333 { 2334 case VK_SAMPLER_MIPMAP_MODE_LINEAR: return tcu::Sampler::LINEAR_MIPMAP_LINEAR; 2335 case VK_SAMPLER_MIPMAP_MODE_NEAREST: return tcu::Sampler::LINEAR_MIPMAP_NEAREST; 2336 default: 2337 break; 2338 } 2339 break; 2340 2341 case VK_FILTER_NEAREST: 2342 switch (mipMode) 2343 { 2344 case VK_SAMPLER_MIPMAP_MODE_LINEAR: return tcu::Sampler::NEAREST_MIPMAP_LINEAR; 2345 case VK_SAMPLER_MIPMAP_MODE_NEAREST: return tcu::Sampler::NEAREST_MIPMAP_NEAREST; 2346 default: 2347 break; 2348 } 2349 break; 2350 2351 default: 2352 break; 2353 } 2354 2355 DE_ASSERT(false); 2356 return tcu::Sampler::FILTERMODE_LAST; 2357 } 2358 2359 tcu::Sampler::FilterMode mapVkMagTexFilter (VkFilter filter) 2360 { 2361 switch (filter) 2362 { 2363 case VK_FILTER_LINEAR: return tcu::Sampler::LINEAR; 2364 case VK_FILTER_NEAREST: return tcu::Sampler::NEAREST; 2365 default: 2366 break; 2367 } 2368 2369 DE_ASSERT(false); 2370 return tcu::Sampler::FILTERMODE_LAST; 2371 } 2372 2373 //! Get a format the matches the layout in buffer memory used for a 2374 //! buffer<->image copy on a depth/stencil format. 2375 tcu::TextureFormat getDepthCopyFormat (VkFormat combinedFormat) 2376 { 2377 switch (combinedFormat) 2378 { 2379 case VK_FORMAT_D16_UNORM: 2380 case VK_FORMAT_X8_D24_UNORM_PACK32: 2381 case VK_FORMAT_D32_SFLOAT: 2382 return mapVkFormat(combinedFormat); 2383 2384 case VK_FORMAT_D16_UNORM_S8_UINT: 2385 return mapVkFormat(VK_FORMAT_D16_UNORM); 2386 case VK_FORMAT_D24_UNORM_S8_UINT: 2387 return mapVkFormat(VK_FORMAT_X8_D24_UNORM_PACK32); 2388 case VK_FORMAT_D32_SFLOAT_S8_UINT: 2389 return mapVkFormat(VK_FORMAT_D32_SFLOAT); 2390 2391 case VK_FORMAT_S8_UINT: 2392 default: 2393 DE_FATAL("Unexpected depth/stencil format"); 2394 return tcu::TextureFormat(); 2395 } 2396 } 2397 2398 //! Get a format the matches the layout in buffer memory used for a 2399 //! buffer<->image copy on a depth/stencil format. 2400 tcu::TextureFormat getStencilCopyFormat (VkFormat combinedFormat) 2401 { 2402 switch (combinedFormat) 2403 { 2404 case VK_FORMAT_D16_UNORM_S8_UINT: 2405 case VK_FORMAT_D24_UNORM_S8_UINT: 2406 case VK_FORMAT_D32_SFLOAT_S8_UINT: 2407 case VK_FORMAT_S8_UINT: 2408 return mapVkFormat(VK_FORMAT_S8_UINT); 2409 2410 case VK_FORMAT_D16_UNORM: 2411 case VK_FORMAT_X8_D24_UNORM_PACK32: 2412 case VK_FORMAT_D32_SFLOAT: 2413 default: 2414 DE_FATAL("Unexpected depth/stencil format"); 2415 return tcu::TextureFormat(); 2416 } 2417 } 2418 2419 } // vk 2420
