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