external/vulkancts/framework/vulkan/vkImageUtil.cpp

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