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