external/vulkancts/framework/vulkan/vkImageUtil.cpp

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