external/vulkancts/modules/vulkan/image/vktImageCompressionTranscodingSupport.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2017 The Khronos Group Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file  vktImageCompressionTranscodingSupport.cpp
  21  * \brief Compression transcoding support
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktImageCompressionTranscodingSupport.hpp"
  25
  26 #include "deUniquePtr.hpp"
  27 #include "deStringUtil.hpp"
  28 #include "deSharedPtr.hpp"
  29 #include "deRandom.hpp"
  30
  31 #include "vktTestCaseUtil.hpp"
  32 #include "vkPrograms.hpp"
  33 #include "vkImageUtil.hpp"
  34 #include "vktImageTestsUtil.hpp"
  35 #include "vkBuilderUtil.hpp"
  36 #include "vkRef.hpp"
  37 #include "vkRefUtil.hpp"
  38 #include "vkTypeUtil.hpp"
  39 #include "vkQueryUtil.hpp"
  40
  41 #include "tcuTextureUtil.hpp"
  42 #include "tcuTexture.hpp"
  43 #include "tcuCompressedTexture.hpp"
  44 #include "tcuVectorType.hpp"
  45 #include "tcuResource.hpp"
  46 #include "tcuImageIO.hpp"
  47 #include "tcuImageCompare.hpp"
  48 #include "tcuTestLog.hpp"
  49 #include "tcuRGBA.hpp"
  50 #include "tcuSurface.hpp"
  51
  52 #include <vector>
  53 using namespace vk;
  54 namespace vkt
  55 {
  56 namespace image
  57 {
  58 namespace
  59 {
  60 using std::string;
  61 using std::vector;
  62 using tcu::TestContext;
  63 using tcu::TestStatus;
  64 using tcu::UVec3;
  65 using tcu::IVec3;
  66 using tcu::CompressedTexFormat;
  67 using tcu::CompressedTexture;
  68 using tcu::Resource;
  69 using tcu::Archive;
  70 using tcu::ConstPixelBufferAccess;
  71 using de::MovePtr;
  72 using de::SharedPtr;
  73 using de::Random;
  74
  75 typedef SharedPtr<MovePtr<Image> >                      ImageSp;
  76 typedef SharedPtr<Move<VkImageView> >           ImageViewSp;
  77 typedef SharedPtr<Move<VkDescriptorSet> >       SharedVkDescriptorSet;
  78
  79 enum ShaderType
  80 {
  81         SHADER_TYPE_COMPUTE,
  82         SHADER_TYPE_FRAGMENT,
  83         SHADER_TYPE_LAST
  84 };
  85
  86 enum Operation
  87 {
  88         OPERATION_IMAGE_LOAD,
  89         OPERATION_TEXEL_FETCH,
  90         OPERATION_TEXTURE,
  91         OPERATION_IMAGE_STORE,
  92         OPERATION_ATTACHMENT_READ,
  93         OPERATION_ATTACHMENT_WRITE,
  94         OPERATION_TEXTURE_READ,
  95         OPERATION_TEXTURE_WRITE,
  96         OPERATION_LAST
  97 };
  98
  99 struct TestParameters
 100 {
 101         Operation                       operation;
 102         ShaderType                      shader;
 103         UVec3                           size;
 104         ImageType                       imageType;
 105         VkFormat                        formatCompressed;
 106         VkFormat                        formatUncompressed;
 107         deUint32                        imagesCount;
 108         VkImageUsageFlags       compressedImageUsage;
 109         VkImageUsageFlags       compressedImageViewUsage;
 110         VkImageUsageFlags       uncompressedImageUsage;
 111         bool                            useMipmaps;
 112         VkFormat                        formatForVerify;
 113 };
 114
 115 template<typename T>
 116 inline SharedPtr<Move<T> > makeVkSharedPtr (Move<T> move)
 117 {
 118         return SharedPtr<Move<T> >(new Move<T>(move));
 119 }
 120
 121 template<typename T>
 122 inline SharedPtr<MovePtr<T> > makeVkSharedPtr (MovePtr<T> movePtr)
 123 {
 124         return SharedPtr<MovePtr<T> >(new MovePtr<T>(movePtr));
 125 }
 126
 127 const deUint32 SINGLE_LEVEL = 1u;
 128 const deUint32 SINGLE_LAYER = 1u;
 129
 130 class BasicTranscodingTestInstance : public TestInstance
 131 {
 132 public:
 133                                                         BasicTranscodingTestInstance    (Context&                                               context,
 134                                                                                                                          const TestParameters&                  parameters);
 135         virtual TestStatus              iterate                                                 (void) = 0;
 136 protected:
 137         void                                    generateData                                    (deUint8*                                               toFill,
 138                                                                                                                          const size_t                                   size,
 139                                                                                                                          const VkFormat                                 format,
 140                                                                                                                          const deUint32                                 layer = 0u,
 141                                                                                                                          const deUint32                                 level = 0u);
 142         deUint32                                getLevelCount                                   ();
 143         deUint32                                getLayerCount                                   ();
 144         UVec3                                   getLayerDims                                    ();
 145         vector<UVec3>                   getMipLevelSizes                                (UVec3                                                  baseSize);
 146         vector<UVec3>                   getCompressedMipLevelSizes              (const VkFormat                                 compressedFormat,
 147                                                                                                                          const vector<UVec3>&                   uncompressedSizes);
 148
 149         const TestParameters    m_parameters;
 150         const deUint32                  m_blockWidth;
 151         const deUint32                  m_blockHeight;
 152         const deUint32                  m_levelCount;
 153         const UVec3                             m_layerSize;
 154
 155 private:
 156         deUint32                                findMipMapLevelCount                    ();
 157 };
 158
 159 deUint32 BasicTranscodingTestInstance::findMipMapLevelCount ()
 160 {
 161         deUint32 levelCount = 1;
 162
 163         // We cannot use mipmap levels which have resolution below block size.
 164         // Reduce number of mipmap levels
 165         if (m_parameters.useMipmaps)
 166         {
 167                 deUint32 w = m_parameters.size.x();
 168                 deUint32 h = m_parameters.size.y();
 169
 170                 DE_ASSERT(m_blockWidth > 0u && m_blockHeight > 0u);
 171
 172                 while (w > m_blockWidth && h > m_blockHeight)
 173                 {
 174                         w >>= 1;
 175                         h >>= 1;
 176
 177                         if (w > m_blockWidth && h > m_blockHeight)
 178                                 levelCount++;
 179                 }
 180
 181                 DE_ASSERT((m_parameters.size.x() >> (levelCount - 1u)) >= m_blockWidth);
 182                 DE_ASSERT((m_parameters.size.y() >> (levelCount - 1u)) >= m_blockHeight);
 183         }
 184
 185         return levelCount;
 186 }
 187
 188 BasicTranscodingTestInstance::BasicTranscodingTestInstance (Context& context, const TestParameters& parameters)
 189         : TestInstance  (context)
 190         , m_parameters  (parameters)
 191         , m_blockWidth  (getBlockWidth(m_parameters.formatCompressed))
 192         , m_blockHeight (getBlockHeight(m_parameters.formatCompressed))
 193         , m_levelCount  (findMipMapLevelCount())
 194         , m_layerSize   (getLayerSize(m_parameters.imageType, m_parameters.size))
 195 {
 196         DE_ASSERT(deLog2Floor32(m_parameters.size.x()) == deLog2Floor32(m_parameters.size.y()));
 197 }
 198
 199 deUint32 BasicTranscodingTestInstance::getLevelCount()
 200 {
 201         return m_levelCount;
 202 }
 203
 204 deUint32 BasicTranscodingTestInstance::getLayerCount()
 205 {
 206         return m_parameters.size.z();
 207 }
 208
 209 UVec3 BasicTranscodingTestInstance::getLayerDims()
 210 {
 211         return m_layerSize;
 212 }
 213
 214 vector<UVec3> BasicTranscodingTestInstance::getMipLevelSizes (UVec3 baseSize)
 215 {
 216         vector<UVec3>   levelSizes;
 217         const deUint32  levelCount = getLevelCount();
 218
 219         DE_ASSERT(m_parameters.imageType == IMAGE_TYPE_2D || m_parameters.imageType == IMAGE_TYPE_2D_ARRAY);
 220
 221         baseSize.z() = 1u;
 222
 223         levelSizes.push_back(baseSize);
 224
 225         while (levelSizes.size() < levelCount && (baseSize.x() != 1 || baseSize.y() != 1))
 226         {
 227                 baseSize.x() = deMax32(baseSize.x() >> 1, 1);
 228                 baseSize.y() = deMax32(baseSize.y() >> 1, 1);
 229                 levelSizes.push_back(baseSize);
 230         }
 231
 232         DE_ASSERT(levelSizes.size() == getLevelCount());
 233
 234         return levelSizes;
 235 }
 236
 237 vector<UVec3> BasicTranscodingTestInstance::getCompressedMipLevelSizes (const VkFormat compressedFormat, const vector<UVec3>& uncompressedSizes)
 238 {
 239         vector<UVec3> levelSizes;
 240         vector<UVec3>::const_iterator it;
 241
 242         for (it = uncompressedSizes.begin(); it != uncompressedSizes.end(); it++)
 243                 levelSizes.push_back(getCompressedImageResolutionInBlocks(compressedFormat, *it));
 244
 245         return levelSizes;
 246 }
 247
 248 void BasicTranscodingTestInstance::generateData (deUint8*               toFill,
 249                                                                                                  const size_t   size,
 250                                                                                                  const VkFormat format,
 251                                                                                                  const deUint32 layer,
 252                                                                                                  const deUint32 level)
 253 {
 254         const deUint8 pattern[] =
 255         {
 256                 // 64-bit values
 257                 0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22,
 258                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 259                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
 260                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
 261                 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
 262                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
 263                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
 264                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00,
 265                 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00,
 266                 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
 267                 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,         // Positive infinity
 268                 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,         // Negative infinity
 269                 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,         // Start of a signalling NaN (NANS)
 270                 0x7F, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,         // End of a signalling NaN (NANS)
 271                 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,         // Start of a signalling NaN (NANS)
 272                 0xFF, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,         // End of a signalling NaN (NANS)
 273                 0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,         // Start of a quiet NaN (NANQ)
 274                 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,         // End of of a quiet NaN (NANQ)
 275                 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,         // Start of a quiet NaN (NANQ)
 276                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,         // End of a quiet NaN (NANQ)
 277                 // 32-bit values
 278                 0x7F, 0x80, 0x00, 0x00,                                                         // Positive infinity
 279                 0xFF, 0x80, 0x00, 0x00,                                                         // Negative infinity
 280                 0x7F, 0x80, 0x00, 0x01,                                                         // Start of a signalling NaN (NANS)
 281                 0x7F, 0xBF, 0xFF, 0xFF,                                                         // End of a signalling NaN (NANS)
 282                 0xFF, 0x80, 0x00, 0x01,                                                         // Start of a signalling NaN (NANS)
 283                 0xFF, 0xBF, 0xFF, 0xFF,                                                         // End of a signalling NaN (NANS)
 284                 0x7F, 0xC0, 0x00, 0x00,                                                         // Start of a quiet NaN (NANQ)
 285                 0x7F, 0xFF, 0xFF, 0xFF,                                                         // End of of a quiet NaN (NANQ)
 286                 0xFF, 0xC0, 0x00, 0x00,                                                         // Start of a quiet NaN (NANQ)
 287                 0xFF, 0xFF, 0xFF, 0xFF,                                                         // End of a quiet NaN (NANQ)
 288                 0xAA, 0xAA, 0xAA, 0xAA,
 289                 0x55, 0x55, 0x55, 0x55,
 290         };
 291
 292         deUint8*        start           = toFill;
 293         size_t          sizeToRnd       = size;
 294
 295         // Pattern part
 296         if (layer == 0 && level == 0 && size >= 2 * sizeof(pattern))
 297         {
 298                 // Rotated pattern
 299                 for (size_t i = 0; i < sizeof(pattern); i++)
 300                         start[sizeof(pattern) - i - 1] = pattern[i];
 301
 302                 start           += sizeof(pattern);
 303                 sizeToRnd       -= sizeof(pattern);
 304
 305                 // Direct pattern
 306                 deMemcpy(start, pattern, sizeof(pattern));
 307
 308                 start           += sizeof(pattern);
 309                 sizeToRnd       -= sizeof(pattern);
 310         }
 311
 312         // Random part
 313         {
 314                 DE_ASSERT(sizeToRnd % sizeof(deUint32) == 0);
 315
 316                 deUint32*       start32         = reinterpret_cast<deUint32*>(start);
 317                 size_t          sizeToRnd32     = sizeToRnd / sizeof(deUint32);
 318                 deUint32        seed            = (layer << 24) ^ (level << 16) ^ static_cast<deUint32>(format);
 319                 Random          rnd                     (seed);
 320
 321                 for (size_t i = 0; i < sizeToRnd32; i++)
 322                         start32[i] = rnd.getUint32();
 323         }
 324
 325         {
 326                 // Remove certain values that may not be preserved based on the uncompressed view format
 327                 if (isSnormFormat(m_parameters.formatUncompressed))
 328                 {
 329                         for (size_t i = 0; i < size; i += 2)
 330                         {
 331                                 // SNORM fix: due to write operation in SNORM format
 332                                 // replaces 0x00 0x80 to 0x01 0x80
 333                                 if (toFill[i] == 0x00 && toFill[i+1] == 0x80)
 334                                         toFill[i+1] = 0x81;
 335                         }
 336                 }
 337                 else if (isFloatFormat(m_parameters.formatUncompressed))
 338                 {
 339                         tcu::TextureFormat textureFormat = mapVkFormat(m_parameters.formatUncompressed);
 340
 341                         if (textureFormat.type == tcu::TextureFormat::HALF_FLOAT)
 342                         {
 343                                 for (size_t i = 0; i < size; i += 2)
 344                                 {
 345                                         // HALF_FLOAT fix: remove INF and NaN
 346                                         if ((toFill[i+1] & 0x7C) == 0x7C)
 347                                                 toFill[i+1] = 0x00;
 348                                 }
 349                         }
 350                         else if (textureFormat.type == tcu::TextureFormat::FLOAT)
 351                         {
 352                                 for (size_t i = 0; i < size; i += 4)
 353                                 {
 354                                         // HALF_FLOAT fix: remove INF and NaN
 355                                         if ((toFill[i+1] & 0x7C) == 0x7C)
 356                                                 toFill[i+1] = 0x00;
 357                                 }
 358
 359                                 for (size_t i = 0; i < size; i += 4)
 360                                 {
 361                                         // FLOAT fix: remove INF, NaN, and denorm
 362                                         // Little endian fix
 363                                         if (((toFill[i+3] & 0x7F) == 0x7F && (toFill[i+2] & 0x80) == 0x80) || ((toFill[i+3] & 0x7F) == 0x00 && (toFill[i+2] & 0x80) == 0x00))
 364                                                 toFill[i+3] = 0x01;
 365                                         // Big endian fix
 366                                         if (((toFill[i+0] & 0x7F) == 0x7F && (toFill[i+1] & 0x80) == 0x80) || ((toFill[i+0] & 0x7F) == 0x00 && (toFill[i+1] & 0x80) == 0x00))
 367                                                 toFill[i+0] = 0x01;
 368                                 }
 369                         }
 370                 }
 371         }
 372 }
 373
 374 class BasicComputeTestInstance : public BasicTranscodingTestInstance
 375 {
 376 public:
 377                                         BasicComputeTestInstance        (Context&                                                       context,
 378                                                                                                 const TestParameters&                           parameters);
 379         TestStatus              iterate                                         (void);
 380 protected:
 381         struct ImageData
 382         {
 383                 deUint32                        getImagesCount          (void)                                                                  { return static_cast<deUint32>(images.size());          }
 384                 deUint32                        getImageViewCount       (void)                                                                  { return static_cast<deUint32>(imagesViews.size());     }
 385                 deUint32                        getImageInfoCount       (void)                                                                  { return static_cast<deUint32>(imagesInfos.size());     }
 386                 VkImage                         getImage                        (const deUint32                         ndx)            { return **images[ndx]->get();                                          }
 387                 VkImageView                     getImageView            (const deUint32                         ndx)            { return **imagesViews[ndx];                                            }
 388                 VkImageCreateInfo       getImageInfo            (const deUint32                         ndx)            { return imagesInfos[ndx];                                                      }
 389                 void                            addImage                        (MovePtr<Image>                         image)          { images.push_back(makeVkSharedPtr(image));                     }
 390                 void                            addImageView            (Move<VkImageView>                      imageView)      { imagesViews.push_back(makeVkSharedPtr(imageView));}
 391                 void                            addImageInfo            (const VkImageCreateInfo        imageInfo)      { imagesInfos.push_back(imageInfo);                                     }
 392                 void                            resetViews                      ()                                                                              { imagesViews.clear();                                                          }
 393         private:
 394                 vector<ImageSp>                         images;
 395                 vector<ImageViewSp>                     imagesViews;
 396                 vector<VkImageCreateInfo>       imagesInfos;
 397         };
 398         void                    copyDataToImage                         (const VkCommandBuffer&                         cmdBuffer,
 399                                                                                                  ImageData&                                                     imageData,
 400                                                                                                  const vector<UVec3>&                           mipMapSizes,
 401                                                                                                  const bool                                                     isCompressed);
 402         virtual void    executeShader                           (const VkCommandBuffer&                         cmdBuffer,
 403                                                                                                  const VkDescriptorSetLayout&           descriptorSetLayout,
 404                                                                                                  const VkDescriptorPool&                        descriptorPool,
 405                                                                                                 vector<ImageData>&                                      imageData);
 406         bool                    copyResultAndCompare            (const VkCommandBuffer&                         cmdBuffer,
 407                                                                                                  const VkImage&                                         uncompressed,
 408                                                                                                  const VkDeviceSize                                     offset,
 409                                                                                                  const UVec3&                                           size);
 410         void                    descriptorSetUpdate                     (VkDescriptorSet                                        descriptorSet,
 411                                                                                                  const VkDescriptorImageInfo*           descriptorImageInfos);
 412         void                    createImageInfos                        (ImageData&                                                     imageData,
 413                                                                                                  const vector<UVec3>&                           mipMapSizes,
 414                                                                                                  const bool                                                     isCompressed);
 415         bool                    decompressImage                         (const VkCommandBuffer&                         cmdBuffer,
 416                                                                                                  vector<ImageData>&                                     imageData,
 417                                                                                                  const vector<UVec3>&                           mipMapSizes);
 418         vector<deUint8> m_data;
 419 };
 420
 421
 422 BasicComputeTestInstance::BasicComputeTestInstance (Context& context, const TestParameters& parameters)
 423         :BasicTranscodingTestInstance   (context, parameters)
 424 {
 425 }
 426
 427 TestStatus BasicComputeTestInstance::iterate (void)
 428 {
 429         const DeviceInterface&                                  vk                                      = m_context.getDeviceInterface();
 430         const VkDevice                                                  device                          = m_context.getDevice();
 431         const deUint32                                                  queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 432         Allocator&                                                              allocator                       = m_context.getDefaultAllocator();
 433         const Unique<VkCommandPool>                             cmdPool                         (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
 434         const Unique<VkCommandBuffer>                   cmdBuffer                       (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
 435         const vector<UVec3>                                             mipMapSizes                     = m_parameters.useMipmaps ? getMipLevelSizes (getLayerDims()) : vector<UVec3>(1, m_parameters.size);
 436         vector<ImageData>                                               imageData                       (m_parameters.imagesCount);
 437         const deUint32                                                  compressedNdx           = 0u;
 438         const deUint32                                                  resultImageNdx          = m_parameters.imagesCount -1u;
 439
 440         for (deUint32 imageNdx = 0u; imageNdx < m_parameters.imagesCount; ++imageNdx)
 441         {
 442                 const bool isCompressed = compressedNdx == imageNdx ? true : false;
 443                 createImageInfos(imageData[imageNdx], mipMapSizes, isCompressed);
 444                 for (deUint32 infoNdx = 0u; infoNdx < imageData[imageNdx].getImageInfoCount(); ++infoNdx)
 445                 {
 446                         imageData[imageNdx].addImage(MovePtr<Image>(new Image(vk, device, allocator, imageData[imageNdx].getImageInfo(infoNdx), MemoryRequirement::Any)));
 447                         if (isCompressed)
 448                         {
 449                                 const VkImageViewUsageCreateInfoKHR     imageViewUsageKHR       =
 450                                 {
 451                                         VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR,                             //VkStructureType               sType;
 452                                         DE_NULL,                                                                                                                //const void*                   pNext;
 453                                         m_parameters.compressedImageUsage,                                                              //VkImageUsageFlags             usage;
 454                                 };
 455                                 for (deUint32 mipNdx = 0u; mipNdx < mipMapSizes.size(); ++mipNdx)
 456                                 for (deUint32 layerNdx = 0u; layerNdx < getLayerCount(); ++layerNdx)
 457                                 {
 458                                         imageData[imageNdx].addImageView(makeImageView(vk, device, imageData[imageNdx].getImage(infoNdx),
 459                                                                                                                 mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed,
 460                                                                                                                 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, mipNdx, 1u, layerNdx, 1u),
 461                                                                                                                 &imageViewUsageKHR));
 462                                 }
 463                         }
 464                         else
 465                         {
 466                                 imageData[imageNdx].addImageView(makeImageView(vk, device, imageData[imageNdx].getImage(infoNdx),
 467                                                                                                         mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed,
 468                                                                                                         makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u)));
 469                         }
 470                 }
 471         }
 472
 473         {
 474                 size_t size = 0ull;
 475                 for(deUint32 mipNdx = 0u; mipNdx < mipMapSizes.size(); ++mipNdx)
 476                 {
 477                         size += static_cast<size_t>(getCompressedImageSizeInBytes(m_parameters.formatCompressed, mipMapSizes[mipNdx]) * getLayerCount());
 478                 }
 479                 m_data.resize(size);
 480                 generateData (&m_data[0], m_data.size(), m_parameters.formatCompressed);
 481         }
 482
 483         switch(m_parameters.operation)
 484         {
 485                 case OPERATION_IMAGE_LOAD:
 486                 case OPERATION_TEXEL_FETCH:
 487                 case OPERATION_TEXTURE:
 488                         copyDataToImage(*cmdBuffer, imageData[compressedNdx], mipMapSizes, true);
 489                         break;
 490                 case OPERATION_IMAGE_STORE:
 491                         copyDataToImage(*cmdBuffer, imageData[1], mipMapSizes, false);
 492                         break;
 493                 default:
 494                         DE_ASSERT(false);
 495                         break;
 496         }
 497
 498         {
 499                 Move<VkDescriptorSetLayout>     descriptorSetLayout;
 500                 Move<VkDescriptorPool>          descriptorPool;
 501
 502                 DescriptorSetLayoutBuilder      descriptorSetLayoutBuilder;
 503                 DescriptorPoolBuilder           descriptorPoolBuilder;
 504                 for (deUint32 imageNdx = 0u; imageNdx < m_parameters.imagesCount; ++imageNdx)
 505                 {
 506                         switch(m_parameters.operation)
 507                         {
 508                                 case OPERATION_IMAGE_LOAD:
 509                                 case OPERATION_IMAGE_STORE:
 510                                         descriptorSetLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT);
 511                                         descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, imageData[0].getImageViewCount());
 512                                         break;
 513                                 case OPERATION_TEXEL_FETCH:
 514                                 case OPERATION_TEXTURE:
 515                                         descriptorSetLayoutBuilder.addSingleBinding((compressedNdx == imageNdx) ? VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER : VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT);
 516                                         descriptorPoolBuilder.addType((compressedNdx == imageNdx) ? VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER : VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, imageData[0].getImageViewCount());
 517                                         break;
 518                                 default:
 519                                         DE_ASSERT(false);
 520                                         break;
 521                         }
 522                 }
 523                 descriptorSetLayout     = descriptorSetLayoutBuilder.build(vk, device);
 524                 descriptorPool          = descriptorPoolBuilder.build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, imageData[0].getImageViewCount());
 525                 executeShader(*cmdBuffer, *descriptorSetLayout, *descriptorPool, imageData);
 526
 527                 {
 528                         VkDeviceSize offset = 0ull;
 529                         for (deUint32 mipNdx = 0u; mipNdx < mipMapSizes.size(); ++mipNdx)
 530                         for (deUint32 layerNdx = 0u; layerNdx < getLayerCount(); ++layerNdx)
 531                         {
 532                                 const deUint32  imageNdx        = layerNdx + mipNdx * getLayerCount();
 533                                 const UVec3             size            = UVec3(imageData[resultImageNdx].getImageInfo(imageNdx).extent.width,
 534                                                                                                         imageData[resultImageNdx].getImageInfo(imageNdx).extent.height,
 535                                                                                                         imageData[resultImageNdx].getImageInfo(imageNdx).extent.depth);
 536                                 if (!copyResultAndCompare(*cmdBuffer, imageData[resultImageNdx].getImage(imageNdx), offset, size))
 537                                         return TestStatus::fail("Fail");
 538                                 offset += getCompressedImageSizeInBytes(m_parameters.formatCompressed, mipMapSizes[mipNdx]);
 539                         }
 540                 }
 541         };
 542         if (!decompressImage(*cmdBuffer, imageData, mipMapSizes))
 543                         return TestStatus::fail("Fail");
 544         return TestStatus::pass("Pass");
 545 }
 546
 547 void BasicComputeTestInstance::copyDataToImage (const VkCommandBuffer&  cmdBuffer,
 548                                                                                                 ImageData&                              imageData,
 549                                                                                                 const vector<UVec3>&    mipMapSizes,
 550                                                                                                 const bool                              isCompressed)
 551 {
 552         const DeviceInterface&          vk                      = m_context.getDeviceInterface();
 553         const VkDevice                          device          = m_context.getDevice();
 554         const VkQueue                           queue           = m_context.getUniversalQueue();
 555         Allocator&                                      allocator       = m_context.getDefaultAllocator();
 556
 557         Buffer                                          imageBuffer     (vk, device, allocator,
 558                                                                                                 makeBufferCreateInfo(m_data.size(), VK_BUFFER_USAGE_TRANSFER_SRC_BIT),
 559                                                                                                 MemoryRequirement::HostVisible);
 560         VkDeviceSize                            offset          = 0ull;
 561         {
 562                 const Allocation& alloc = imageBuffer.getAllocation();
 563                 deMemcpy(alloc.getHostPtr(), &m_data[0], m_data.size());
 564                 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), m_data.size());
 565         }
 566
 567         beginCommandBuffer(vk, cmdBuffer);
 568         const VkImageSubresourceRange   subresourceRange                =
 569         {
 570                 VK_IMAGE_ASPECT_COLOR_BIT,                                      //VkImageAspectFlags    aspectMask
 571                 0u,                                                                                     //deUint32                              baseMipLevel
 572                 imageData.getImageInfo(0u).mipLevels,           //deUint32                              levelCount
 573                 0u,                                                                                     //deUint32                              baseArrayLayer
 574                 imageData.getImageInfo(0u).arrayLayers          //deUint32                              layerCount
 575         };
 576
 577         for (deUint32 imageNdx = 0u; imageNdx < imageData.getImagesCount(); ++imageNdx)
 578         {
 579                 const VkImageMemoryBarrier              preCopyImageBarrier             = makeImageMemoryBarrier(
 580                                                                                                                                         0u, VK_ACCESS_TRANSFER_WRITE_BIT,
 581                                                                                                                                         VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
 582                                                                                                                                         imageData.getImage(imageNdx), subresourceRange);
 583
 584                 const VkBufferMemoryBarrier             FlushHostCopyBarrier    = makeBufferMemoryBarrier(
 585                                                                                                                                         VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
 586                                                                                                                                         imageBuffer.get(), 0ull, m_data.size());
 587
 588                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
 589                                 (VkDependencyFlags)0, 0u, (const VkMemoryBarrier*)DE_NULL, 1u, &FlushHostCopyBarrier, 1u, &preCopyImageBarrier);
 590
 591                 for (deUint32 mipNdx = 0u; mipNdx < imageData.getImageInfo(imageNdx).mipLevels; ++mipNdx)
 592                 {
 593                         const VkExtent3D                                imageExtent                             = isCompressed ?
 594                                                                                                                                                 makeExtent3D(mipMapSizes[mipNdx]) :
 595                                                                                                                                                 imageData.getImageInfo(imageNdx).extent;
 596                         const VkBufferImageCopy                 copyRegion                              =
 597                         {
 598                                 offset,                                                                                                                                                                                                                         //VkDeviceSize                          bufferOffset;
 599                                 0u,                                                                                                                                                                                                                                     //deUint32                                      bufferRowLength;
 600                                 0u,                                                                                                                                                                                                                                     //deUint32                                      bufferImageHeight;
 601                                 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, mipNdx, 0u, imageData.getImageInfo(imageNdx).arrayLayers),        //VkImageSubresourceLayers      imageSubresource;
 602                                 makeOffset3D(0, 0, 0),                                                                                                                                                                                          //VkOffset3D                            imageOffset;
 603                                 imageExtent,                                                                                                                                                                                                            //VkExtent3D                            imageExtent;
 604                         };
 605
 606                         vk.cmdCopyBufferToImage(cmdBuffer, imageBuffer.get(), imageData.getImage(imageNdx), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &copyRegion);
 607                         offset += getCompressedImageSizeInBytes(m_parameters.formatCompressed,
 608                                                 UVec3(isCompressed ? imageExtent.width : imageExtent.width * m_blockWidth, isCompressed? imageExtent.height :imageExtent.height * m_blockHeight,imageExtent.depth)) *
 609                                                 imageData.getImageInfo(imageNdx).arrayLayers;
 610                 }
 611         }
 612         endCommandBuffer(vk, cmdBuffer);
 613         submitCommandsAndWait(vk, device, queue, cmdBuffer);
 614 }
 615
 616 void BasicComputeTestInstance::executeShader (const VkCommandBuffer&            cmdBuffer,
 617                                                                                           const VkDescriptorSetLayout&  descriptorSetLayout,
 618                                                                                           const VkDescriptorPool&               descriptorPool,
 619                                                                                           vector<ImageData>&                    imageData)
 620 {
 621         const DeviceInterface&                  vk                                              = m_context.getDeviceInterface();
 622         const VkDevice                                  device                                  = m_context.getDevice();
 623         const VkQueue                                   queue                                   = m_context.getUniversalQueue();
 624         const Unique<VkShaderModule>    shaderModule                    (createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0));
 625         vector<SharedVkDescriptorSet>   descriptorSets                  (imageData[0].getImageViewCount());
 626         const Unique<VkPipelineLayout>  pipelineLayout                  (makePipelineLayout(vk, device, descriptorSetLayout));
 627         const Unique<VkPipeline>                pipeline                                (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
 628         Move<VkSampler>                                 sampler;
 629         {
 630                 const VkSamplerCreateInfo createInfo =
 631                 {
 632                         VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,          //VkStructureType               sType;
 633                         DE_NULL,                                                                        //const void*                   pNext;
 634                         0u,                                                                                     //VkSamplerCreateFlags  flags;
 635                         VK_FILTER_NEAREST,                                                      //VkFilter                              magFilter;
 636                         VK_FILTER_NEAREST,                                                      //VkFilter                              minFilter;
 637                         VK_SAMPLER_MIPMAP_MODE_NEAREST,                         //VkSamplerMipmapMode   mipmapMode;
 638                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          //VkSamplerAddressMode  addressModeU;
 639                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          //VkSamplerAddressMode  addressModeV;
 640                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          //VkSamplerAddressMode  addressModeW;
 641                         0.0f,                                                                           //float                                 mipLodBias;
 642                         VK_FALSE,                                                                       //VkBool32                              anisotropyEnable;
 643                         1.0f,                                                                           //float                                 maxAnisotropy;
 644                         VK_FALSE,                                                                       //VkBool32                              compareEnable;
 645                         VK_COMPARE_OP_EQUAL,                                            //VkCompareOp                   compareOp;
 646                         0.0f,                                                                           //float                                 minLod;
 647                         0.0f,                                                                           //float                                 maxLod;
 648                         VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,        //VkBorderColor                 borderColor;
 649                         VK_FALSE,                                                                       //VkBool32                              unnormalizedCoordinates;
 650                 };
 651                 sampler = createSampler(vk, device, &createInfo);
 652         }
 653
 654         vector<VkDescriptorImageInfo>   descriptorImageInfos    (descriptorSets.size() * m_parameters.imagesCount);
 655         for (deUint32 viewNdx = 0u; viewNdx < descriptorSets.size(); ++viewNdx)
 656         {
 657                 const deUint32 descriptorNdx = viewNdx * m_parameters.imagesCount;
 658                 for (deUint32 imageNdx = 0; imageNdx < m_parameters.imagesCount; ++imageNdx)
 659                 {
 660                         descriptorImageInfos[descriptorNdx+imageNdx] = makeDescriptorImageInfo(*sampler,
 661                                                                                                                         imageData[imageNdx].getImageView(viewNdx), VK_IMAGE_LAYOUT_GENERAL);
 662                 }
 663         }
 664
 665         for (deUint32 ndx = 0u; ndx < descriptorSets.size(); ++ndx)
 666                 descriptorSets[ndx] = makeVkSharedPtr(makeDescriptorSet(vk, device, descriptorPool, descriptorSetLayout));
 667
 668         beginCommandBuffer(vk, cmdBuffer);
 669         {
 670                 const VkImageSubresourceRange   compressedRange                         =
 671                 {
 672                         VK_IMAGE_ASPECT_COLOR_BIT,                                      //VkImageAspectFlags    aspectMask
 673                         0u,                                                                                     //deUint32                              baseMipLevel
 674                         imageData[0].getImageInfo(0u).mipLevels,        //deUint32                              levelCount
 675                         0u,                                                                                     //deUint32                              baseArrayLayer
 676                         imageData[0].getImageInfo(0u).arrayLayers       //deUint32                              layerCount
 677                 };
 678                 const VkImageSubresourceRange   uncompressedRange                       =
 679                 {
 680                         VK_IMAGE_ASPECT_COLOR_BIT,                                      //VkImageAspectFlags    aspectMask
 681                         0u,                                                                                     //deUint32                              baseMipLevel
 682                         1u,                                                                                     //deUint32                              levelCount
 683                         0u,                                                                                     //deUint32                              baseArrayLayer
 684                         1u                                                                                      //deUint32                              layerCount
 685                 };
 686
 687                 vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
 688
 689                 vector<VkImageMemoryBarrier>            preShaderImageBarriers;
 690                 preShaderImageBarriers.resize(descriptorSets.size() + 1u);
 691                 for (deUint32 imageNdx = 0u; imageNdx < imageData[1].getImagesCount(); ++imageNdx)
 692                 {
 693                         preShaderImageBarriers[imageNdx]= makeImageMemoryBarrier(
 694                                                                                                 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_WRITE_BIT,
 695                                                                                                 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
 696                                                                                                 imageData[1].getImage(imageNdx), uncompressedRange);
 697                 }
 698
 699                 preShaderImageBarriers[descriptorSets.size()] = makeImageMemoryBarrier(
 700                                                                                                                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
 701                                                                                                                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
 702                                                                                                                         imageData[0].getImage(0), compressedRange);
 703
 704                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
 705                         (VkDependencyFlags)0, 0u, (const VkMemoryBarrier*)DE_NULL, 0u, (const VkBufferMemoryBarrier*)DE_NULL,
 706                         static_cast<deUint32>(preShaderImageBarriers.size()), &preShaderImageBarriers[0]);
 707
 708                 for (deUint32 ndx = 0u; ndx <descriptorSets.size(); ++ndx)
 709                 {
 710                         descriptorSetUpdate (**descriptorSets[ndx], &descriptorImageInfos[ndx* m_parameters.imagesCount]);
 711                         vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &(**descriptorSets[ndx]), 0u, DE_NULL);
 712                         vk.cmdDispatch(cmdBuffer,       imageData[1].getImageInfo(ndx).extent.width,
 713                                                                                 imageData[1].getImageInfo(ndx).extent.height,
 714                                                                                 imageData[1].getImageInfo(ndx).extent.depth);
 715                 }
 716         }
 717         endCommandBuffer(vk, cmdBuffer);
 718         submitCommandsAndWait(vk, device, queue, cmdBuffer);
 719 }
 720
 721 bool BasicComputeTestInstance::copyResultAndCompare (const VkCommandBuffer&     cmdBuffer,
 722                                                                                                          const VkImage&                 uncompressed,
 723                                                                                                          const VkDeviceSize             offset,
 724                                                                                                          const UVec3&                   size)
 725 {
 726         const DeviceInterface&  vk                                      = m_context.getDeviceInterface();
 727         const VkQueue                   queue                           = m_context.getUniversalQueue();
 728         const VkDevice                  device                          = m_context.getDevice();
 729         Allocator&                              allocator                       = m_context.getDefaultAllocator();
 730
 731         VkDeviceSize                    imageResultSize         = getImageSizeBytes (tcu::IVec3(size.x(), size.y(), size.z()), m_parameters.formatUncompressed);
 732         Buffer                                  imageBufferResult       (vk, device, allocator,
 733                                                                                                         makeBufferCreateInfo(imageResultSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT),
 734                                                                                                         MemoryRequirement::HostVisible);
 735
 736         beginCommandBuffer(vk, cmdBuffer);
 737         {
 738                 const VkImageSubresourceRange   subresourceRange        =
 739                 {
 740                         VK_IMAGE_ASPECT_COLOR_BIT,                                                                                      //VkImageAspectFlags    aspectMask
 741                         0u,                                                                                                                                     //deUint32                              baseMipLevel
 742                         1u,                                                                                                                                     //deUint32                              levelCount
 743                         0u,                                                                                                                                     //deUint32                              baseArrayLayer
 744                         1u                                                                                                                                      //deUint32                              layerCount
 745                 };
 746
 747                 const VkBufferImageCopy                 copyRegion                      =
 748                 {
 749                         0ull,                                                                                                                           //      VkDeviceSize                            bufferOffset;
 750                         0u,                                                                                                                                     //      deUint32                                        bufferRowLength;
 751                         0u,                                                                                                                                     //      deUint32                                        bufferImageHeight;
 752                         makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u),      //      VkImageSubresourceLayers        imageSubresource;
 753                         makeOffset3D(0, 0, 0),                                                                                          //      VkOffset3D                                      imageOffset;
 754                         makeExtent3D(size),                                                                                                     //      VkExtent3D                                      imageExtent;
 755                 };
 756
 757                 const VkImageMemoryBarrier prepareForTransferBarrier = makeImageMemoryBarrier(
 758                                                                                                                                 VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
 759                                                                                                                                 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
 760                                                                                                                                 uncompressed, subresourceRange);
 761
 762                 const VkBufferMemoryBarrier copyBarrier = makeBufferMemoryBarrier(
 763                                                                                                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
 764                                                                                                         imageBufferResult.get(), 0ull, imageResultSize);
 765
 766                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1u, &prepareForTransferBarrier);
 767                 vk.cmdCopyImageToBuffer(cmdBuffer, uncompressed, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, imageBufferResult.get(), 1u, &copyRegion);
 768                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0u, (const VkMemoryBarrier*)DE_NULL, 1, &copyBarrier, 0u, (const VkImageMemoryBarrier*)DE_NULL);
 769         }
 770         endCommandBuffer(vk, cmdBuffer);
 771         submitCommandsAndWait(vk, device, queue, cmdBuffer);
 772
 773         const Allocation& allocResult = imageBufferResult.getAllocation();
 774         invalidateMappedMemoryRange(vk, device, allocResult.getMemory(), allocResult.getOffset(), imageResultSize);
 775         if (deMemCmp((const void *)allocResult.getHostPtr(), (const void *)&m_data[static_cast<size_t>(offset)], static_cast<size_t>(imageResultSize)) == 0ull)
 776                 return true;
 777         return false;
 778 }
 779
 780 void BasicComputeTestInstance::descriptorSetUpdate (VkDescriptorSet descriptorSet, const VkDescriptorImageInfo* descriptorImageInfos)
 781 {
 782         const DeviceInterface&          vk              = m_context.getDeviceInterface();
 783         const VkDevice                          device  = m_context.getDevice();
 784         DescriptorSetUpdateBuilder      descriptorSetUpdateBuilder;
 785
 786         switch(m_parameters.operation)
 787         {
 788                 case OPERATION_IMAGE_LOAD:
 789                 case OPERATION_IMAGE_STORE:
 790                 {
 791                         for (deUint32 bindingNdx = 0u; bindingNdx < m_parameters.imagesCount; ++bindingNdx)
 792                                 descriptorSetUpdateBuilder.writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(bindingNdx), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfos[bindingNdx]);
 793
 794                         break;
 795                 }
 796
 797                 case OPERATION_TEXEL_FETCH:
 798                 case OPERATION_TEXTURE:
 799                 {
 800                         for (deUint32 bindingNdx = 0u; bindingNdx < m_parameters.imagesCount; ++bindingNdx)
 801                         {
 802                                 descriptorSetUpdateBuilder.writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(bindingNdx),
 803                                         bindingNdx == 0u ? VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER : VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfos[bindingNdx]);
 804                         }
 805
 806                         break;
 807                 }
 808
 809                 default:
 810                         DE_ASSERT(false);
 811         }
 812         descriptorSetUpdateBuilder.update(vk, device);
 813 }
 814
 815 void BasicComputeTestInstance::createImageInfos (ImageData& imageData, const vector<UVec3>& mipMapSizes, const bool isCompressed)
 816 {
 817         const VkImageType                       imageType                       = mapImageType(m_parameters.imageType);
 818
 819         if (isCompressed)
 820         {
 821                 const VkExtent3D                        extentCompressed        = makeExtent3D(getLayerSize(m_parameters.imageType, m_parameters.size));
 822                 const VkImageCreateInfo compressedInfo =
 823                 {
 824                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                    // VkStructureType                      sType;
 825                         DE_NULL,                                                                                                // const void*                          pNext;
 826                         VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT |
 827                         VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR |
 828                         VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR,                                 // VkImageCreateFlags           flags;
 829                         imageType,                                                                                              // VkImageType                          imageType;
 830                         m_parameters.formatCompressed,                                                  // VkFormat                                     format;
 831                         extentCompressed,                                                                               // VkExtent3D                           extent;
 832                         static_cast<deUint32>(mipMapSizes.size()),                              // deUint32                                     mipLevels;
 833                         getLayerCount(),                                                                                // deUint32                                     arrayLayers;
 834                         VK_SAMPLE_COUNT_1_BIT,                                                                  // VkSampleCountFlagBits        samples;
 835                         VK_IMAGE_TILING_OPTIMAL,                                                                // VkImageTiling                        tiling;
 836                         VK_IMAGE_USAGE_SAMPLED_BIT |
 837                         VK_IMAGE_USAGE_STORAGE_BIT |
 838                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
 839                         VK_IMAGE_USAGE_TRANSFER_DST_BIT,                                                // VkImageUsageFlags            usage;
 840                         VK_SHARING_MODE_EXCLUSIVE,                                                              // VkSharingMode                        sharingMode;
 841                         0u,                                                                                                             // deUint32                                     queueFamilyIndexCount;
 842                         DE_NULL,                                                                                                // const deUint32*                      pQueueFamilyIndices;
 843                         VK_IMAGE_LAYOUT_UNDEFINED,                                                              // VkImageLayout                        initialLayout;
 844                 };
 845                 imageData.addImageInfo(compressedInfo);
 846         }
 847         else
 848         {
 849                 for (size_t mipNdx = 0ull; mipNdx < mipMapSizes.size(); ++mipNdx)
 850                 for (size_t layerNdx = 0ull; layerNdx < getLayerCount(); ++layerNdx)
 851                 {
 852                         const VkExtent3D                extentUncompressed      = m_parameters.useMipmaps ?
 853                                                                                                                         makeExtent3D(getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, mipMapSizes[mipNdx])) :
 854                                                                                                                         makeExtent3D(getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size));
 855                         const VkImageCreateInfo uncompressedInfo        =
 856                         {
 857                                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                            // VkStructureType                      sType;
 858                                 DE_NULL,                                                                                        // const void*                          pNext;
 859                                 0u,                                                                                                     // VkImageCreateFlags           flags;
 860                                 imageType,                                                                                      // VkImageType                          imageType;
 861                                 m_parameters.formatUncompressed,                                        // VkFormat                                     format;
 862                                 extentUncompressed,                                                                     // VkExtent3D                           extent;
 863                                 1u,                                                                                                     // deUint32                                     mipLevels;
 864                                 1u,                                                                                                     // deUint32                                     arrayLayers;
 865                                 VK_SAMPLE_COUNT_1_BIT,                                                          // VkSampleCountFlagBits        samples;
 866                                 VK_IMAGE_TILING_OPTIMAL,                                                        // VkImageTiling                        tiling;
 867                                 m_parameters.uncompressedImageUsage |
 868                                 VK_IMAGE_USAGE_SAMPLED_BIT,                                                     // VkImageUsageFlags            usage;
 869                                 VK_SHARING_MODE_EXCLUSIVE,                                                      // VkSharingMode                        sharingMode;
 870                                 0u,                                                                                                     // deUint32                                     queueFamilyIndexCount;
 871                                 DE_NULL,                                                                                        // const deUint32*                      pQueueFamilyIndices;
 872                                 VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                        initialLayout;
 873                         };
 874                         imageData.addImageInfo(uncompressedInfo);
 875                 }
 876         }
 877 }
 878
 879 bool BasicComputeTestInstance::decompressImage (const VkCommandBuffer&  cmdBuffer,
 880                                                                                                  vector<ImageData>&             imageData,
 881                                                                                                  const vector<UVec3>&   mipMapSizes)
 882 {
 883         const DeviceInterface&                  vk                                              = m_context.getDeviceInterface();
 884         const VkDevice                                  device                                  = m_context.getDevice();
 885         const VkQueue                                   queue                                   = m_context.getUniversalQueue();
 886         Allocator&                                              allocator                               = m_context.getDefaultAllocator();
 887         const Unique<VkShaderModule>    shaderModule                    (createShaderModule(vk, device, m_context.getBinaryCollection().get("decompress"), 0));
 888         const VkImage&                                  compressed                              = imageData[0].getImage(0);
 889
 890         for (deUint32 ndx = 0u; ndx < imageData.size(); ndx++)
 891                 imageData[ndx].resetViews();
 892
 893         for (deUint32 mipNdx = 0u; mipNdx < mipMapSizes.size(); ++mipNdx)
 894         for (deUint32 layerNdx = 0u; layerNdx < getLayerCount(); ++layerNdx)
 895         {
 896                 const bool                                              layoutShaderReadOnly    = (layerNdx % 2u) == 1;
 897                 const deUint32                                  imageNdx                                = layerNdx + mipNdx * getLayerCount();
 898                 const VkExtent3D                                extentCompressed                = makeExtent3D(mipMapSizes[mipNdx]);
 899                 const VkImage&                                  uncompressed                    = imageData[m_parameters.imagesCount -1].getImage(imageNdx);
 900                 const VkExtent3D                                extentUncompressed              = imageData[m_parameters.imagesCount -1].getImageInfo(imageNdx).extent;
 901                 const VkDeviceSize                              bufferSizeComp                  = getCompressedImageSizeInBytes(m_parameters.formatCompressed, mipMapSizes[mipNdx]);
 902
 903                 const VkImageCreateInfo                 decompressedImageInfo   =
 904                 {
 905                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                                            // VkStructureType                      sType;
 906                         DE_NULL,                                                                                                                        // const void*                          pNext;
 907                         0u,                                                                                                                                     // VkImageCreateFlags           flags;
 908                         VK_IMAGE_TYPE_2D,                                                                                                       // VkImageType                          imageType;
 909                         VK_FORMAT_R8G8B8A8_UNORM,                                                                                       // VkFormat                                     format;
 910                         extentCompressed,                                                                                                       // VkExtent3D                           extent;
 911                         1u,                                                                                                                                     // deUint32                                     mipLevels;
 912                         1u,                                                                                                                                     // deUint32                                     arrayLayers;
 913                         VK_SAMPLE_COUNT_1_BIT,                                                                                          // VkSampleCountFlagBits        samples;
 914                         VK_IMAGE_TILING_OPTIMAL,                                                                                        // VkImageTiling                        tiling;
 915                         VK_IMAGE_USAGE_SAMPLED_BIT |
 916                         VK_IMAGE_USAGE_STORAGE_BIT |
 917                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
 918                         VK_IMAGE_USAGE_TRANSFER_DST_BIT,                                                                        // VkImageUsageFlags            usage;
 919                         VK_SHARING_MODE_EXCLUSIVE,                                                                                      // VkSharingMode                        sharingMode;
 920                         0u,                                                                                                                                     // deUint32                                     queueFamilyIndexCount;
 921                         DE_NULL,                                                                                                                        // const deUint32*                      pQueueFamilyIndices;
 922                         VK_IMAGE_LAYOUT_UNDEFINED,                                                                                      // VkImageLayout                        initialLayout;
 923                 };
 924
 925                 const VkImageCreateInfo                 compressedImageInfo             =
 926                 {
 927                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                                            // VkStructureType                      sType;
 928                         DE_NULL,                                                                                                                        // const void*                          pNext;
 929                         0u,                                                                                                                                     // VkImageCreateFlags           flags;
 930                         VK_IMAGE_TYPE_2D,                                                                                                       // VkImageType                          imageType;
 931                         m_parameters.formatCompressed,                                                                          // VkFormat                                     format;
 932                         extentCompressed,                                                                                                       // VkExtent3D                           extent;
 933                         1u,                                                                                                                                     // deUint32                                     mipLevels;
 934                         1u,                                                                                                                                     // deUint32                                     arrayLayers;
 935                         VK_SAMPLE_COUNT_1_BIT,                                                                                          // VkSampleCountFlagBits        samples;
 936                         VK_IMAGE_TILING_OPTIMAL,                                                                                        // VkImageTiling                        tiling;
 937                         VK_IMAGE_USAGE_SAMPLED_BIT |
 938                         VK_IMAGE_USAGE_TRANSFER_DST_BIT,                                                                        // VkImageUsageFlags            usage;
 939                         VK_SHARING_MODE_EXCLUSIVE,                                                                                      // VkSharingMode                        sharingMode;
 940                         0u,                                                                                                                                     // deUint32                                     queueFamilyIndexCount;
 941                         DE_NULL,                                                                                                                        // const deUint32*                      pQueueFamilyIndices;
 942                         VK_IMAGE_LAYOUT_UNDEFINED,                                                                                      // VkImageLayout                        initialLayout;
 943                 };
 944                 const VkImageUsageFlags                         compressedViewUsageFlags        = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 945                 const VkImageViewUsageCreateInfoKHR     compressedViewUsageCI           =
 946                 {
 947                         VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR,                                     //VkStructureType               sType;
 948                         DE_NULL,                                                                                                                        //const void*                   pNext;
 949                         compressedViewUsageFlags,                                                                                       //VkImageUsageFlags             usage;
 950                 };
 951                 Image                                                   resultImage                             (vk, device, allocator, decompressedImageInfo, MemoryRequirement::Any);
 952                 Image                                                   referenceImage                  (vk, device, allocator, decompressedImageInfo, MemoryRequirement::Any);
 953                 Image                                                   uncompressedImage               (vk, device, allocator, compressedImageInfo, MemoryRequirement::Any);
 954                 Move<VkImageView>                               resultView                              = makeImageView(vk, device, resultImage.get(), mapImageViewType(m_parameters.imageType), decompressedImageInfo.format,
 955                                                                                                                                         makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, decompressedImageInfo.extent.depth, 0u, decompressedImageInfo.arrayLayers));
 956                 Move<VkImageView>                               referenceView                   = makeImageView(vk, device, referenceImage.get(), mapImageViewType(m_parameters.imageType), decompressedImageInfo.format,
 957                                                                                                                                         makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, decompressedImageInfo.extent.depth, 0u, decompressedImageInfo.arrayLayers));
 958                 Move<VkImageView>                               uncompressedView                = makeImageView(vk, device, uncompressedImage.get(), mapImageViewType(m_parameters.imageType), m_parameters.formatCompressed,
 959                                                                                                                                         makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, compressedImageInfo.extent.depth, 0u, compressedImageInfo.arrayLayers));
 960                 Move<VkImageView>                               compressedView                  = makeImageView(vk, device, compressed, mapImageViewType(m_parameters.imageType), m_parameters.formatCompressed,
 961                                                                                                                                         makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, mipNdx, 1u, layerNdx, 1u), &compressedViewUsageCI);
 962                 Move<VkDescriptorSetLayout>             descriptorSetLayout             = DescriptorSetLayoutBuilder()
 963                                                                                                                                         .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_COMPUTE_BIT)
 964                                                                                                                                         .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_COMPUTE_BIT)
 965                                                                                                                                         .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
 966                                                                                                                                         .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
 967                                                                                                                                         .build(vk, device);
 968                 Move<VkDescriptorPool>                  descriptorPool                  = DescriptorPoolBuilder()
 969                                                                                                                                         .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, decompressedImageInfo.arrayLayers)
 970                                                                                                                                         .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, decompressedImageInfo.arrayLayers)
 971                                                                                                                                         .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, decompressedImageInfo.arrayLayers)
 972                                                                                                                                         .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, decompressedImageInfo.arrayLayers)
 973                                                                                                                                         .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, decompressedImageInfo.arrayLayers);
 974
 975                 Move<VkDescriptorSet>                   descriptorSet                   = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);
 976                 const Unique<VkPipelineLayout>  pipelineLayout                  (makePipelineLayout(vk, device, *descriptorSetLayout));
 977                 const Unique<VkPipeline>                pipeline                                (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
 978                 const VkDeviceSize                              bufferSize                              = getImageSizeBytes(IVec3((int)extentCompressed.width, (int)extentCompressed.height, (int)extentCompressed.depth), VK_FORMAT_R8G8B8A8_UNORM);
 979                 Buffer                                                  resultBuffer                    (vk, device, allocator,
 980                                                                                                                                         makeBufferCreateInfo(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible);
 981                 Buffer                                                  referenceBuffer                 (vk, device, allocator,
 982                                                                                                                                         makeBufferCreateInfo(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible);
 983                 Buffer                                                  transferBuffer                  (vk, device, allocator,
 984                                                                                                                                         makeBufferCreateInfo(bufferSizeComp, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible);
 985                 Move<VkSampler>                                 sampler;
 986                 {
 987                         const VkSamplerCreateInfo createInfo    =
 988                         {
 989                                 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,                                                  //VkStructureType               sType;
 990                                 DE_NULL,                                                                                                                //const void*                   pNext;
 991                                 0u,                                                                                                                             //VkSamplerCreateFlags  flags;
 992                                 VK_FILTER_NEAREST,                                                                                              //VkFilter                              magFilter;
 993                                 VK_FILTER_NEAREST,                                                                                              //VkFilter                              minFilter;
 994                                 VK_SAMPLER_MIPMAP_MODE_NEAREST,                                                                 //VkSamplerMipmapMode   mipmapMode;
 995                                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                                  //VkSamplerAddressMode  addressModeU;
 996                                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                                  //VkSamplerAddressMode  addressModeV;
 997                                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                                  //VkSamplerAddressMode  addressModeW;
 998                                 0.0f,                                                                                                                   //float                                 mipLodBias;
 999                                 VK_FALSE,                                                                                                               //VkBool32                              anisotropyEnable;
1000                                 1.0f,                                                                                                                   //float                                 maxAnisotropy;
1001                                 VK_FALSE,                                                                                                               //VkBool32                              compareEnable;
1002                                 VK_COMPARE_OP_EQUAL,                                                                                    //VkCompareOp                   compareOp;
1003                                 0.0f,                                                                                                                   //float                                 minLod;
1004                                 1.0f,                                                                                                                   //float                                 maxLod;
1005                                 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,                                                //VkBorderColor                 borderColor;
1006                                 VK_FALSE,                                                                                                               //VkBool32                              unnormalizedCoordinates;
1007                         };
1008                         sampler = createSampler(vk, device, &createInfo);
1009                 }
1010
1011                 VkDescriptorImageInfo                   descriptorImageInfos[]  =
1012                 {
1013                         makeDescriptorImageInfo(*sampler,       *uncompressedView,      layoutShaderReadOnly ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL),
1014                         makeDescriptorImageInfo(*sampler,       *compressedView,        layoutShaderReadOnly ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL),
1015                         makeDescriptorImageInfo(DE_NULL,        *resultView,            VK_IMAGE_LAYOUT_GENERAL),
1016                         makeDescriptorImageInfo(DE_NULL,        *referenceView,         VK_IMAGE_LAYOUT_GENERAL)
1017                 };
1018                 DescriptorSetUpdateBuilder()
1019                         .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorImageInfos[0])
1020                         .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorImageInfos[1])
1021                         .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(2u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfos[2])
1022                         .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(3u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfos[3])
1023                         .update(vk, device);
1024
1025
1026                 beginCommandBuffer(vk, cmdBuffer);
1027                 {
1028                         const VkImageSubresourceRange   subresourceRange                =
1029                         {
1030                                 VK_IMAGE_ASPECT_COLOR_BIT,                                                                                      //VkImageAspectFlags                    aspectMask
1031                                 0u,                                                                                                                                     //deUint32                                              baseMipLevel
1032                                 1u,                                                                                                                                     //deUint32                                              levelCount
1033                                 0u,                                                                                                                                     //deUint32                                              baseArrayLayer
1034                                 1u                                                                                                                                      //deUint32                                              layerCount
1035                         };
1036
1037                         const VkImageSubresourceRange   subresourceRangeComp    =
1038                         {
1039                                 VK_IMAGE_ASPECT_COLOR_BIT,                                                                                      //VkImageAspectFlags                    aspectMask
1040                                 mipNdx,                                                                                                                         //deUint32                                              baseMipLevel
1041                                 1u,                                                                                                                                     //deUint32                                              levelCount
1042                                 layerNdx,                                                                                                                       //deUint32                                              baseArrayLayer
1043                                 1u                                                                                                                                      //deUint32                                              layerCount
1044                         };
1045
1046                         const VkBufferImageCopy                 copyRegion                              =
1047                         {
1048                                 0ull,                                                                                                                           //      VkDeviceSize                            bufferOffset;
1049                                 0u,                                                                                                                                     //      deUint32                                        bufferRowLength;
1050                                 0u,                                                                                                                                     //      deUint32                                        bufferImageHeight;
1051                                 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u),      //      VkImageSubresourceLayers        imageSubresource;
1052                                 makeOffset3D(0, 0, 0),                                                                                          //      VkOffset3D                                      imageOffset;
1053                                 decompressedImageInfo.extent,                                                                           //      VkExtent3D                                      imageExtent;
1054                         };
1055
1056                         const VkBufferImageCopy                 compressedCopyRegion    =
1057                         {
1058                                 0ull,                                                                                                                           //      VkDeviceSize                            bufferOffset;
1059                                 0u,                                                                                                                                     //      deUint32                                        bufferRowLength;
1060                                 0u,                                                                                                                                     //      deUint32                                        bufferImageHeight;
1061                                 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u),      //      VkImageSubresourceLayers        imageSubresource;
1062                                 makeOffset3D(0, 0, 0),                                                                                          //      VkOffset3D                                      imageOffset;
1063                                 extentUncompressed,                                                                                                     //      VkExtent3D                                      imageExtent;
1064                         };
1065
1066                         {
1067
1068                                 const VkBufferMemoryBarrier             preCopyBufferBarriers   = makeBufferMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT,
1069                                                                                                                                                         transferBuffer.get(), 0ull, bufferSizeComp);
1070
1071                                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1072                                         (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &preCopyBufferBarriers, 0u, (const VkImageMemoryBarrier*)DE_NULL);
1073                         }
1074
1075                         vk.cmdCopyImageToBuffer(cmdBuffer, uncompressed, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, transferBuffer.get(), 1u, &compressedCopyRegion);
1076
1077                         {
1078                                 const VkBufferMemoryBarrier             postCopyBufferBarriers  = makeBufferMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1079                                                                                                                                                         transferBuffer.get(), 0ull, bufferSizeComp);
1080
1081                                 const VkImageMemoryBarrier              preCopyImageBarriers    = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT,
1082                                                                                                                                                         VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, uncompressedImage.get(), subresourceRange);
1083
1084                                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1085                                         (VkDependencyFlags)0, 0u, (const VkMemoryBarrier*)DE_NULL, 1u, &postCopyBufferBarriers, 1u, &preCopyImageBarriers);
1086                         }
1087
1088                         vk.cmdCopyBufferToImage(cmdBuffer, transferBuffer.get(), uncompressedImage.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &copyRegion);
1089
1090                         vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
1091                         vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
1092
1093                         {
1094                                 const VkImageMemoryBarrier              preShaderImageBarriers[]        =
1095                                 {
1096
1097                                         makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
1098                                                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, layoutShaderReadOnly ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL,
1099                                                 uncompressedImage.get(), subresourceRange),
1100
1101                                         makeImageMemoryBarrier(0, VK_ACCESS_SHADER_READ_BIT,
1102                                                 VK_IMAGE_LAYOUT_GENERAL, layoutShaderReadOnly ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL,
1103                                                 compressed, subresourceRangeComp),
1104
1105                                         makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_WRITE_BIT,
1106                                                 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
1107                                                 resultImage.get(), subresourceRange),
1108
1109                                         makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_WRITE_BIT,
1110                                                 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
1111                                                 referenceImage.get(), subresourceRange)
1112                                 };
1113
1114                                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
1115                                         (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, (const VkBufferMemoryBarrier*)DE_NULL,
1116                                         DE_LENGTH_OF_ARRAY(preShaderImageBarriers), preShaderImageBarriers);
1117                         }
1118
1119                         vk.cmdDispatch(cmdBuffer, extentCompressed.width, extentCompressed.height, extentCompressed.depth);
1120
1121                         {
1122                                 const VkImageMemoryBarrier              postShaderImageBarriers[]       =
1123                                 {
1124                                         makeImageMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1125                                         VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1126                                         resultImage.get(), subresourceRange),
1127
1128                                         makeImageMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1129                                                 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1130                                                 referenceImage.get(), subresourceRange)
1131                                 };
1132
1133                                  const VkBufferMemoryBarrier            preCopyBufferBarrier[]          =
1134                                 {
1135                                         makeBufferMemoryBarrier( 0, VK_BUFFER_USAGE_TRANSFER_DST_BIT,
1136                                                 resultBuffer.get(), 0ull, bufferSize),
1137
1138                                         makeBufferMemoryBarrier( 0, VK_BUFFER_USAGE_TRANSFER_DST_BIT,
1139                                                 referenceBuffer.get(), 0ull, bufferSize),
1140                                 };
1141
1142                                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1143                                         (VkDependencyFlags)0, 0u, (const VkMemoryBarrier*)DE_NULL, DE_LENGTH_OF_ARRAY(preCopyBufferBarrier), preCopyBufferBarrier,
1144                                         DE_LENGTH_OF_ARRAY(postShaderImageBarriers), postShaderImageBarriers);
1145                         }
1146                         vk.cmdCopyImageToBuffer(cmdBuffer, resultImage.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, resultBuffer.get(), 1u, &copyRegion);
1147                         vk.cmdCopyImageToBuffer(cmdBuffer, referenceImage.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, referenceBuffer.get(), 1u, &copyRegion);
1148                 }
1149                 endCommandBuffer(vk, cmdBuffer);
1150                 submitCommandsAndWait(vk, device, queue, cmdBuffer);
1151
1152                 const Allocation&               resultAlloc             = resultBuffer.getAllocation();
1153                 const Allocation&               referenceAlloc  = referenceBuffer.getAllocation();
1154                 invalidateMappedMemoryRange(vk, device, resultAlloc.getMemory(), resultAlloc.getOffset(), bufferSize);
1155                 invalidateMappedMemoryRange(vk, device, referenceAlloc.getMemory(), referenceAlloc.getOffset(), bufferSize);
1156
1157                 if (deMemCmp(resultAlloc.getHostPtr(), referenceAlloc.getHostPtr(), (size_t)bufferSize) != 0)
1158                 {
1159                         ConstPixelBufferAccess  resultPixels            (mapVkFormat(decompressedImageInfo.format), decompressedImageInfo.extent.width, decompressedImageInfo.extent.height, decompressedImageInfo.extent.depth, resultAlloc.getHostPtr());
1160                         ConstPixelBufferAccess  referencePixels         (mapVkFormat(decompressedImageInfo.format), decompressedImageInfo.extent.width, decompressedImageInfo.extent.height, decompressedImageInfo.extent.depth, referenceAlloc.getHostPtr());
1161
1162                         if(!fuzzyCompare(m_context.getTestContext().getLog(), "Image Comparison", "Image Comparison", resultPixels, referencePixels, 0.001f, tcu::COMPARE_LOG_EVERYTHING))
1163                                 return false;
1164                 }
1165         }
1166
1167         return true;
1168 }
1169
1170 class ImageStoreComputeTestInstance : public BasicComputeTestInstance
1171 {
1172 public:
1173                                         ImageStoreComputeTestInstance   (Context&                                                       context,
1174                                                                                                          const TestParameters&                          parameters);
1175 protected:
1176         virtual void    executeShader                                   (const VkCommandBuffer&                         cmdBuffer,
1177                                                                                                          const VkDescriptorSetLayout&           descriptorSetLayout,
1178                                                                                                          const VkDescriptorPool&                        descriptorPool,
1179                                                                                                          vector<ImageData>&                                     imageData);
1180 private:
1181 };
1182
1183 ImageStoreComputeTestInstance::ImageStoreComputeTestInstance (Context& context, const TestParameters& parameters)
1184         :BasicComputeTestInstance       (context, parameters)
1185 {
1186 }
1187
1188 void ImageStoreComputeTestInstance::executeShader (const VkCommandBuffer&               cmdBuffer,
1189                                                                                                    const VkDescriptorSetLayout& descriptorSetLayout,
1190                                                                                                    const VkDescriptorPool&              descriptorPool,
1191                                                                                                    vector<ImageData>&                   imageData)
1192 {
1193         const DeviceInterface&                  vk                                              = m_context.getDeviceInterface();
1194         const VkDevice                                  device                                  = m_context.getDevice();
1195         const VkQueue                                   queue                                   = m_context.getUniversalQueue();
1196         const Unique<VkShaderModule>    shaderModule                    (createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0));
1197         vector<SharedVkDescriptorSet>   descriptorSets                  (imageData[0].getImageViewCount());
1198         const Unique<VkPipelineLayout>  pipelineLayout                  (makePipelineLayout(vk, device, descriptorSetLayout));
1199         const Unique<VkPipeline>                pipeline                                (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
1200         Move<VkSampler>                                 sampler;
1201         {
1202                 const VkSamplerCreateInfo createInfo =
1203                 {
1204                         VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,          //VkStructureType               sType;
1205                         DE_NULL,                                                                        //const void*                   pNext;
1206                         0u,                                                                                     //VkSamplerCreateFlags  flags;
1207                         VK_FILTER_NEAREST,                                                      //VkFilter                              magFilter;
1208                         VK_FILTER_NEAREST,                                                      //VkFilter                              minFilter;
1209                         VK_SAMPLER_MIPMAP_MODE_NEAREST,                         //VkSamplerMipmapMode   mipmapMode;
1210                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          //VkSamplerAddressMode  addressModeU;
1211                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          //VkSamplerAddressMode  addressModeV;
1212                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          //VkSamplerAddressMode  addressModeW;
1213                         0.0f,                                                                           //float                                 mipLodBias;
1214                         VK_FALSE,                                                                       //VkBool32                              anisotropyEnable;
1215                         1.0f,                                                                           //float                                 maxAnisotropy;
1216                         VK_FALSE,                                                                       //VkBool32                              compareEnable;
1217                         VK_COMPARE_OP_EQUAL,                                            //VkCompareOp                   compareOp;
1218                         0.0f,                                                                           //float                                 minLod;
1219                         0.0f,                                                                           //float                                 maxLod;
1220                         VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,        //VkBorderColor                 borderColor;
1221                         VK_TRUE,                                                                        //VkBool32                              unnormalizedCoordinates;
1222                 };
1223                 sampler = createSampler(vk, device, &createInfo);
1224         }
1225
1226         vector<VkDescriptorImageInfo>   descriptorImageInfos    (descriptorSets.size() * m_parameters.imagesCount);
1227         for (deUint32 viewNdx = 0u; viewNdx < descriptorSets.size(); ++viewNdx)
1228         {
1229                 const deUint32 descriptorNdx = viewNdx * m_parameters.imagesCount;
1230                 for (deUint32 imageNdx = 0u; imageNdx < m_parameters.imagesCount; ++imageNdx)
1231                 {
1232                         descriptorImageInfos[descriptorNdx+imageNdx] = makeDescriptorImageInfo(*sampler,
1233                                                                                                                         imageData[imageNdx].getImageView(viewNdx), VK_IMAGE_LAYOUT_GENERAL);
1234                 }
1235         }
1236
1237         for (deUint32 ndx = 0u; ndx < descriptorSets.size(); ++ndx)
1238                 descriptorSets[ndx] = makeVkSharedPtr(makeDescriptorSet(vk, device, descriptorPool, descriptorSetLayout));
1239
1240         beginCommandBuffer(vk, cmdBuffer);
1241         {
1242                 const VkImageSubresourceRange   compressedRange                         =
1243                 {
1244                         VK_IMAGE_ASPECT_COLOR_BIT,                                      //VkImageAspectFlags    aspectMask
1245                         0u,                                                                                     //deUint32                              baseMipLevel
1246                         imageData[0].getImageInfo(0).mipLevels,         //deUint32                              levelCount
1247                         0u,                                                                                     //deUint32                              baseArrayLayer
1248                         imageData[0].getImageInfo(0).arrayLayers        //deUint32                              layerCount
1249                 };
1250
1251                 const VkImageSubresourceRange   uncompressedRange                       =
1252                 {
1253                         VK_IMAGE_ASPECT_COLOR_BIT,                                      //VkImageAspectFlags    aspectMask
1254                         0u,                                                                                     //deUint32                              baseMipLevel
1255                         1u,                                                                                     //deUint32                              levelCount
1256                         0u,                                                                                     //deUint32                              baseArrayLayer
1257                         1u                                                                                      //deUint32                              layerCount
1258                 };
1259
1260                 vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
1261
1262                 vector<VkImageMemoryBarrier>            preShaderImageBarriers  (descriptorSets.size() * 2u + 1u);
1263                 for (deUint32 imageNdx = 0u; imageNdx < imageData[1].getImagesCount(); ++imageNdx)
1264                 {
1265                         preShaderImageBarriers[imageNdx]                                                                        = makeImageMemoryBarrier(
1266                                                                                                                                                                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_WRITE_BIT,
1267                                                                                                                                                                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
1268                                                                                                                                                                         imageData[1].getImage(imageNdx), uncompressedRange);
1269
1270                         preShaderImageBarriers[imageNdx + imageData[1].getImagesCount()]        = makeImageMemoryBarrier(
1271                                                                                                                                                                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_WRITE_BIT,
1272                                                                                                                                                                         VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
1273                                                                                                                                                                         imageData[2].getImage(imageNdx), uncompressedRange);
1274                 }
1275
1276                 preShaderImageBarriers[preShaderImageBarriers.size()-1] = makeImageMemoryBarrier(
1277                                                                                                                                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
1278                                                                                                                                         VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
1279                                                                                                                                         imageData[0].getImage(0u), compressedRange);
1280
1281                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
1282                         (VkDependencyFlags)0, 0u, (const VkMemoryBarrier*)DE_NULL, 0u, (const VkBufferMemoryBarrier*)DE_NULL,
1283                         static_cast<deUint32>(preShaderImageBarriers.size()), &preShaderImageBarriers[0]);
1284
1285                 for (deUint32 ndx = 0u; ndx <descriptorSets.size(); ++ndx)
1286                 {
1287                         descriptorSetUpdate (**descriptorSets[ndx], &descriptorImageInfos[ndx* m_parameters.imagesCount]);
1288                         vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &(**descriptorSets[ndx]), 0u, DE_NULL);
1289                         vk.cmdDispatch(cmdBuffer,       imageData[1].getImageInfo(ndx).extent.width,
1290                                                                                 imageData[1].getImageInfo(ndx).extent.height,
1291                                                                                 imageData[1].getImageInfo(ndx).extent.depth);
1292                 }
1293         }
1294         endCommandBuffer(vk, cmdBuffer);
1295         submitCommandsAndWait(vk, device, queue, cmdBuffer);
1296 }
1297
1298 class GraphicsAttachmentsTestInstance : public BasicTranscodingTestInstance
1299 {
1300 public:
1301                                                                                 GraphicsAttachmentsTestInstance (Context& context, const TestParameters& parameters);
1302         virtual TestStatus                                      iterate                                                 (void);
1303
1304 protected:
1305         virtual bool                                            isWriteToCompressedOperation    ();
1306         VkImageCreateInfo                                       makeCreateImageInfo                             (const VkFormat                                 format,
1307                                                                                                                                                  const ImageType                                type,
1308                                                                                                                                                  const UVec3&                                   size,
1309                                                                                                                                                  const VkImageUsageFlags                usageFlags,
1310                                                                                                                                                  const VkImageCreateFlags*              createFlags,
1311                                                                                                                                                  const deUint32                                 levels,
1312                                                                                                                                                  const deUint32                                 layers);
1313         VkDeviceSize                                            getCompressedImageData                  (const VkFormat                                 format,
1314                                                                                                                                                  const UVec3&                                   size,
1315                                                                                                                                                  std::vector<deUint8>&                  data,
1316                                                                                                                                                  const deUint32                                 layer,
1317                                                                                                                                                  const deUint32                                 level);
1318         VkDeviceSize                                            getUncompressedImageData                (const VkFormat                                 format,
1319                                                                                                                                                  const UVec3&                                   size,
1320                                                                                                                                                  std::vector<deUint8>&                  data,
1321                                                                                                                                                  const deUint32                                 layer,
1322                                                                                                                                                  const deUint32                                 level);
1323         virtual void                                            prepareData                                             ();
1324         virtual void                                            prepareVertexBuffer                             ();
1325         virtual void                                            transcodeRead                                   ();
1326         virtual void                                            transcodeWrite                                  ();
1327         bool                                                            verifyDecompression                             (const std::vector<deUint8>&    refCompressedData,
1328                                                                                                                                                  const de::MovePtr<Image>&              resCompressedImage,
1329                                                                                                                                                  const deUint32                                 layer,
1330                                                                                                                                                  const deUint32                                 level,
1331                                                                                                                                                  const UVec3&                                   mipmapDims);
1332
1333         typedef std::vector<deUint8>            RawDataVector;
1334         typedef SharedPtr<RawDataVector>        RawDataPtr;
1335         typedef std::vector<RawDataPtr>         LevelData;
1336         typedef std::vector<LevelData>          FullImageData;
1337
1338         FullImageData                                           m_srcData;
1339         FullImageData                                           m_dstData;
1340
1341         typedef SharedPtr<Image>                        ImagePtr;
1342         typedef std::vector<ImagePtr>           LevelImages;
1343         typedef std::vector<LevelImages>        ImagesArray;
1344
1345         ImagesArray                                                     m_uncompressedImages;
1346         MovePtr<Image>                                          m_compressedImage;
1347
1348         VkImageViewUsageCreateInfoKHR           m_imageViewUsageKHR;
1349         VkImageViewUsageCreateInfoKHR*          m_srcImageViewUsageKHR;
1350         VkImageViewUsageCreateInfoKHR*          m_dstImageViewUsageKHR;
1351         std::vector<tcu::UVec3>                         m_compressedImageResVec;
1352         std::vector<tcu::UVec3>                         m_uncompressedImageResVec;
1353         VkFormat                                                        m_srcFormat;
1354         VkFormat                                                        m_dstFormat;
1355         VkImageUsageFlags                                       m_srcImageUsageFlags;
1356         VkImageUsageFlags                                       m_dstImageUsageFlags;
1357         std::vector<tcu::UVec3>                         m_srcImageResolutions;
1358         std::vector<tcu::UVec3>                         m_dstImageResolutions;
1359
1360         MovePtr<Buffer>                                         m_vertexBuffer;
1361         deUint32                                                        m_vertexCount;
1362         VkDeviceSize                                            m_vertexBufferOffset;
1363 };
1364
1365 GraphicsAttachmentsTestInstance::GraphicsAttachmentsTestInstance (Context& context, const TestParameters& parameters)
1366         : BasicTranscodingTestInstance(context, parameters)
1367         , m_srcData()
1368         , m_dstData()
1369         , m_uncompressedImages()
1370         , m_compressedImage()
1371         , m_imageViewUsageKHR()
1372         , m_srcImageViewUsageKHR()
1373         , m_dstImageViewUsageKHR()
1374         , m_compressedImageResVec()
1375         , m_uncompressedImageResVec()
1376         , m_srcFormat()
1377         , m_dstFormat()
1378         , m_srcImageUsageFlags()
1379         , m_dstImageUsageFlags()
1380         , m_srcImageResolutions()
1381         , m_dstImageResolutions()
1382         , m_vertexBuffer()
1383         , m_vertexCount(0u)
1384         , m_vertexBufferOffset(0ull)
1385 {
1386 }
1387
1388 TestStatus GraphicsAttachmentsTestInstance::iterate (void)
1389 {
1390         prepareData();
1391         prepareVertexBuffer();
1392
1393         for (deUint32 levelNdx = 0; levelNdx < getLevelCount(); ++levelNdx)
1394                 for (deUint32 layerNdx = 0; layerNdx < getLayerCount(); ++layerNdx)
1395                         DE_ASSERT(m_srcData[levelNdx][layerNdx]->size() == m_dstData[levelNdx][layerNdx]->size());
1396
1397         if (isWriteToCompressedOperation())
1398                 transcodeWrite();
1399         else
1400                 transcodeRead();
1401
1402         for (deUint32 levelNdx = 0; levelNdx < getLevelCount(); ++levelNdx)
1403                 for (deUint32 layerNdx = 0; layerNdx < getLayerCount(); ++layerNdx)
1404                         if (isWriteToCompressedOperation())
1405                         {
1406                                 if (!verifyDecompression(*m_srcData[levelNdx][layerNdx], m_compressedImage, levelNdx, layerNdx, m_compressedImageResVec[levelNdx]))
1407                                         return TestStatus::fail("Images difference detected");
1408                         }
1409                         else
1410                         {
1411                                 if (!verifyDecompression(*m_dstData[levelNdx][layerNdx], m_compressedImage, levelNdx, layerNdx, m_compressedImageResVec[levelNdx]))
1412                                         return TestStatus::fail("Images difference detected");
1413                         }
1414
1415         return TestStatus::pass("Pass");
1416 }
1417
1418 void GraphicsAttachmentsTestInstance::prepareData ()
1419 {
1420         VkImageViewUsageCreateInfoKHR*  imageViewUsageKHRNull   = (VkImageViewUsageCreateInfoKHR*)DE_NULL;
1421
1422         m_imageViewUsageKHR                     = makeImageViewUsageCreateInfo(m_parameters.compressedImageViewUsage);
1423
1424         m_srcImageViewUsageKHR          = isWriteToCompressedOperation() ? imageViewUsageKHRNull : &m_imageViewUsageKHR;
1425         m_dstImageViewUsageKHR          = isWriteToCompressedOperation() ? &m_imageViewUsageKHR : imageViewUsageKHRNull;
1426
1427         m_srcFormat                                     = isWriteToCompressedOperation() ? m_parameters.formatUncompressed : m_parameters.formatCompressed;
1428         m_dstFormat                                     = isWriteToCompressedOperation() ? m_parameters.formatCompressed : m_parameters.formatUncompressed;
1429
1430         m_srcImageUsageFlags            = isWriteToCompressedOperation() ? m_parameters.uncompressedImageUsage : m_parameters.compressedImageUsage;
1431         m_dstImageUsageFlags            = isWriteToCompressedOperation() ? m_parameters.compressedImageUsage : m_parameters.uncompressedImageUsage;
1432
1433         m_compressedImageResVec         = getMipLevelSizes(getLayerDims());
1434         m_uncompressedImageResVec       = getCompressedMipLevelSizes(m_parameters.formatCompressed, m_compressedImageResVec);
1435
1436         m_srcImageResolutions           = isWriteToCompressedOperation() ? m_uncompressedImageResVec : m_compressedImageResVec;
1437         m_dstImageResolutions           = isWriteToCompressedOperation() ? m_compressedImageResVec : m_uncompressedImageResVec;
1438
1439         m_srcData.resize(getLevelCount());
1440         m_dstData.resize(getLevelCount());
1441         m_uncompressedImages.resize(getLevelCount());
1442
1443         for (deUint32 levelNdx = 0; levelNdx < getLevelCount(); ++levelNdx)
1444         {
1445                 m_srcData[levelNdx].resize(getLayerCount());
1446                 m_dstData[levelNdx].resize(getLayerCount());
1447                 m_uncompressedImages[levelNdx].resize(getLayerCount());
1448
1449                 for (deUint32 layerNdx = 0; layerNdx < getLayerCount(); ++layerNdx)
1450                 {
1451                         m_srcData[levelNdx][layerNdx] = SharedPtr<RawDataVector>(new RawDataVector);
1452                         m_dstData[levelNdx][layerNdx] = SharedPtr<RawDataVector>(new RawDataVector);
1453
1454                         if (isWriteToCompressedOperation())
1455                         {
1456                                 getUncompressedImageData(m_srcFormat, m_srcImageResolutions[levelNdx], *m_srcData[levelNdx][layerNdx], layerNdx, levelNdx);
1457
1458                                 m_dstData[levelNdx][layerNdx]->resize((size_t)getCompressedImageSizeInBytes(m_dstFormat, m_dstImageResolutions[levelNdx]));
1459                         }
1460                         else
1461                         {
1462                                 getCompressedImageData(m_srcFormat, m_srcImageResolutions[levelNdx], *m_srcData[levelNdx][layerNdx], layerNdx, levelNdx);
1463
1464                                 m_dstData[levelNdx][layerNdx]->resize((size_t)getUncompressedImageSizeInBytes(m_dstFormat, m_dstImageResolutions[levelNdx]));
1465                         }
1466
1467                         DE_ASSERT(m_srcData[levelNdx][layerNdx]->size() == m_dstData[levelNdx][layerNdx]->size());
1468                 }
1469         }
1470 }
1471
1472 void GraphicsAttachmentsTestInstance::prepareVertexBuffer ()
1473 {
1474         const DeviceInterface&                  vk                                              = m_context.getDeviceInterface();
1475         const VkDevice                                  device                                  = m_context.getDevice();
1476         Allocator&                                              allocator                               = m_context.getDefaultAllocator();
1477
1478         const std::vector<tcu::Vec4>    vertexArray                             = createFullscreenQuad();
1479         const size_t                                    vertexBufferSizeInBytes = vertexArray.size() * sizeof(vertexArray[0]);
1480
1481         m_vertexCount   = static_cast<deUint32>(vertexArray.size());
1482         m_vertexBuffer  = MovePtr<Buffer>(new Buffer(vk, device, allocator, makeBufferCreateInfo(vertexBufferSizeInBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible));
1483
1484         // Upload vertex data
1485         const Allocation&       vertexBufferAlloc       = m_vertexBuffer->getAllocation();
1486         deMemcpy(vertexBufferAlloc.getHostPtr(), &vertexArray[0], vertexBufferSizeInBytes);
1487         flushMappedMemoryRange(vk, device, vertexBufferAlloc.getMemory(), vertexBufferAlloc.getOffset(), vertexBufferSizeInBytes);
1488 }
1489
1490 void GraphicsAttachmentsTestInstance::transcodeRead ()
1491 {
1492         const DeviceInterface&                          vk                                              = m_context.getDeviceInterface();
1493         const VkDevice                                          device                                  = m_context.getDevice();
1494         const deUint32                                          queueFamilyIndex                = m_context.getUniversalQueueFamilyIndex();
1495         const VkQueue                                           queue                                   = m_context.getUniversalQueue();
1496         Allocator&                                                      allocator                               = m_context.getDefaultAllocator();
1497
1498         const VkImageCreateFlags*                       imgCreateFlagsOverride  = DE_NULL;
1499
1500         const VkImageCreateInfo                         srcImageCreateInfo              = makeCreateImageInfo(m_srcFormat, m_parameters.imageType, m_srcImageResolutions[0], m_srcImageUsageFlags, imgCreateFlagsOverride, getLevelCount(), getLayerCount());
1501         MovePtr<Image>                                          srcImage                                (new Image(vk, device, allocator, srcImageCreateInfo, MemoryRequirement::Any));
1502
1503         const Unique<VkShaderModule>            vertShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
1504         const Unique<VkShaderModule>            fragShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
1505
1506         const Unique<VkRenderPass>                      renderPass                              (makeRenderPass(vk, device, m_parameters.formatUncompressed, m_parameters.formatUncompressed));
1507
1508         const Move<VkDescriptorSetLayout>       descriptorSetLayout             (DescriptorSetLayoutBuilder()
1509                                                                                                                                         .addSingleBinding(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_SHADER_STAGE_FRAGMENT_BIT)
1510                                                                                                                                         .build(vk, device));
1511         const Move<VkDescriptorPool>            descriptorPool                  (DescriptorPoolBuilder()
1512                                                                                                                                         .addType(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
1513                                                                                                                                         .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
1514         const Move<VkDescriptorSet>                     descriptorSet                   (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
1515
1516         const VkExtent2D                                        renderSizeDummy                 (makeExtent2D(1u, 1u));
1517         const Unique<VkPipelineLayout>          pipelineLayout                  (makePipelineLayout(vk, device, *descriptorSetLayout));
1518         const Unique<VkPipeline>                        pipeline                                (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertShaderModule, *fragShaderModule, renderSizeDummy, 1u, true));
1519
1520         const Unique<VkCommandPool>                     cmdPool                                 (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
1521         const Unique<VkCommandBuffer>           cmdBuffer                               (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
1522
1523         for (deUint32 levelNdx = 0; levelNdx < getLevelCount(); ++levelNdx)
1524         {
1525                 const UVec3&                            uncompressedImageRes    = m_uncompressedImageResVec[levelNdx];
1526                 const UVec3&                            srcImageResolution              = m_srcImageResolutions[levelNdx];
1527                 const UVec3&                            dstImageResolution              = m_dstImageResolutions[levelNdx];
1528                 const size_t                            srcImageSizeInBytes             = m_srcData[levelNdx][0]->size();
1529                 const size_t                            dstImageSizeInBytes             = m_dstData[levelNdx][0]->size();
1530                 const UVec3                                     srcImageResBlocked              = getCompressedImageResolutionBlockCeil(m_parameters.formatCompressed, srcImageResolution);
1531
1532                 const VkImageCreateInfo         dstImageCreateInfo              = makeCreateImageInfo(m_dstFormat, m_parameters.imageType, dstImageResolution, m_dstImageUsageFlags, imgCreateFlagsOverride, SINGLE_LEVEL, SINGLE_LAYER);
1533
1534                 const VkBufferCreateInfo        srcImageBufferInfo              = makeBufferCreateInfo(srcImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
1535                 const MovePtr<Buffer>           srcImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, srcImageBufferInfo, MemoryRequirement::HostVisible));
1536
1537                 const VkBufferCreateInfo        dstImageBufferInfo              = makeBufferCreateInfo(dstImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
1538                 MovePtr<Buffer>                         dstImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, dstImageBufferInfo, MemoryRequirement::HostVisible));
1539
1540                 const VkExtent2D                        renderSize                              (makeExtent2D(uncompressedImageRes.x(), uncompressedImageRes.y()));
1541                 const VkViewport                        viewport                                = makeViewport(0.0f, 0.0f, static_cast<float>(renderSize.width), static_cast<float>(renderSize.height), 0.0f, 1.0f);
1542                 const VkRect2D                          scissor                                 = makeScissor(renderSize.width, renderSize.height);
1543
1544                 for (deUint32 layerNdx = 0; layerNdx < getLayerCount(); ++layerNdx)
1545                 {
1546                         const VkImageSubresourceRange   srcSubresourceRange             = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, levelNdx, SINGLE_LEVEL, layerNdx, SINGLE_LAYER);
1547                         const VkImageSubresourceRange   dstSubresourceRange             = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, SINGLE_LEVEL, 0u, SINGLE_LAYER);
1548
1549                         Move<VkImageView>                               srcImageView                    (makeImageView(vk, device, srcImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, srcSubresourceRange, m_srcImageViewUsageKHR));
1550
1551                         de::MovePtr<Image>                              dstImage                                (new Image(vk, device, allocator, dstImageCreateInfo, MemoryRequirement::Any));
1552                         Move<VkImageView>                               dstImageView                    (makeImageView(vk, device, dstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, dstSubresourceRange, m_dstImageViewUsageKHR));
1553
1554                         const VkBufferImageCopy                 srcCopyRegion                   = makeBufferImageCopy(srcImageResolution.x(), srcImageResolution.y(), levelNdx, layerNdx, srcImageResBlocked.x(), srcImageResBlocked.y());
1555                         const VkBufferMemoryBarrier             srcCopyBufferBarrierPre = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, srcImageBuffer->get(), 0ull, srcImageSizeInBytes);
1556                         const VkImageMemoryBarrier              srcCopyImageBarrierPre  = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, srcImage->get(), srcSubresourceRange);
1557                         const VkImageMemoryBarrier              srcCopyImageBarrierPost = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, srcImage->get(), srcSubresourceRange);
1558                         const VkBufferImageCopy                 dstCopyRegion                   = makeBufferImageCopy(dstImageResolution.x(), dstImageResolution.y());
1559                         const VkImageMemoryBarrier              dstInitImageBarrier             = makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, dstImage->get(), dstSubresourceRange);
1560
1561                         const VkImageView                               attachmentBindInfos[]   = { *srcImageView, *dstImageView };
1562                         const VkExtent2D                                framebufferSize                 (makeExtent2D(dstImageResolution[0], dstImageResolution[1]));
1563                         const Move<VkFramebuffer>               framebuffer                             (makeFramebuffer(vk, device, *renderPass, DE_LENGTH_OF_ARRAY(attachmentBindInfos), attachmentBindInfos, framebufferSize, SINGLE_LAYER));
1564
1565                         // Upload source image data
1566                         const Allocation& alloc = srcImageBuffer->getAllocation();
1567                         deMemcpy(alloc.getHostPtr(), &m_srcData[levelNdx][layerNdx]->at(0), srcImageSizeInBytes);
1568                         flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), srcImageSizeInBytes);
1569
1570                         beginCommandBuffer(vk, *cmdBuffer);
1571                         vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1572
1573                         // Copy buffer to image
1574                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);
1575                         vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);
1576                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &srcCopyImageBarrierPost);
1577
1578                         // Define destination image layout
1579                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &dstInitImageBarrier);
1580
1581                         beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
1582
1583                         const VkDescriptorImageInfo     descriptorSrcImageInfo(makeDescriptorImageInfo(DE_NULL, *srcImageView, VK_IMAGE_LAYOUT_GENERAL));
1584                         DescriptorSetUpdateBuilder()
1585                                 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, &descriptorSrcImageInfo)
1586                                 .update(vk, device);
1587
1588                         vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
1589                         vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &m_vertexBuffer->get(), &m_vertexBufferOffset);
1590
1591                         vk.cmdSetViewport(*cmdBuffer, 0u, 1u, &viewport);
1592                         vk.cmdSetScissor(*cmdBuffer, 0u, 1u, &scissor);
1593
1594                         vk.cmdDraw(*cmdBuffer, (deUint32)m_vertexCount, 1, 0, 0);
1595
1596                         vk.cmdEndRenderPass(*cmdBuffer);
1597
1598                         const VkImageMemoryBarrier prepareForTransferBarrier = makeImageMemoryBarrier(
1599                                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1600                                 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
1601                                 dstImage->get(), dstSubresourceRange);
1602
1603                         const VkBufferMemoryBarrier copyBarrier = makeBufferMemoryBarrier(
1604                                 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
1605                                 dstImageBuffer->get(), 0ull, dstImageSizeInBytes);
1606
1607                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &prepareForTransferBarrier);
1608                         vk.cmdCopyImageToBuffer(*cmdBuffer, dstImage->get(), VK_IMAGE_LAYOUT_GENERAL, dstImageBuffer->get(), 1u, &dstCopyRegion);
1609                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &copyBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1610
1611                         endCommandBuffer(vk, *cmdBuffer);
1612
1613                         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
1614
1615                         const Allocation& dstImageBufferAlloc = dstImageBuffer->getAllocation();
1616                         invalidateMappedMemoryRange(vk, device, dstImageBufferAlloc.getMemory(), dstImageBufferAlloc.getOffset(), dstImageSizeInBytes);
1617                         deMemcpy(&m_dstData[levelNdx][layerNdx]->at(0), dstImageBufferAlloc.getHostPtr(), dstImageSizeInBytes);
1618                 }
1619         }
1620
1621         m_compressedImage = srcImage;
1622 }
1623
1624 void GraphicsAttachmentsTestInstance::transcodeWrite ()
1625 {
1626         const DeviceInterface&                          vk                                              = m_context.getDeviceInterface();
1627         const VkDevice                                          device                                  = m_context.getDevice();
1628         const deUint32                                          queueFamilyIndex                = m_context.getUniversalQueueFamilyIndex();
1629         const VkQueue                                           queue                                   = m_context.getUniversalQueue();
1630         Allocator&                                                      allocator                               = m_context.getDefaultAllocator();
1631
1632         const VkImageCreateFlags*                       imgCreateFlagsOverride  = DE_NULL;
1633
1634         const VkImageCreateInfo                         dstImageCreateInfo              = makeCreateImageInfo(m_dstFormat, m_parameters.imageType, m_dstImageResolutions[0], m_dstImageUsageFlags, imgCreateFlagsOverride, getLevelCount(), getLayerCount());
1635         MovePtr<Image>                                          dstImage                                (new Image(vk, device, allocator, dstImageCreateInfo, MemoryRequirement::Any));
1636
1637         const Unique<VkShaderModule>            vertShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
1638         const Unique<VkShaderModule>            fragShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
1639
1640         const Unique<VkRenderPass>                      renderPass                              (makeRenderPass(vk, device, m_parameters.formatUncompressed, m_parameters.formatUncompressed));
1641
1642         const Move<VkDescriptorSetLayout>       descriptorSetLayout             (DescriptorSetLayoutBuilder()
1643                                                                                                                                         .addSingleBinding(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_SHADER_STAGE_FRAGMENT_BIT)
1644                                                                                                                                         .build(vk, device));
1645         const Move<VkDescriptorPool>            descriptorPool                  (DescriptorPoolBuilder()
1646                                                                                                                                         .addType(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
1647                                                                                                                                         .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
1648         const Move<VkDescriptorSet>                     descriptorSet                   (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
1649
1650         const VkExtent2D                                        renderSizeDummy                 (makeExtent2D(1u, 1u));
1651         const Unique<VkPipelineLayout>          pipelineLayout                  (makePipelineLayout(vk, device, *descriptorSetLayout));
1652         const Unique<VkPipeline>                        pipeline                                (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertShaderModule, *fragShaderModule, renderSizeDummy, 1u, true));
1653
1654         const Unique<VkCommandPool>                     cmdPool                                 (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
1655         const Unique<VkCommandBuffer>           cmdBuffer                               (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
1656
1657         for (deUint32 levelNdx = 0; levelNdx < getLevelCount(); ++levelNdx)
1658         {
1659                 const UVec3&                            uncompressedImageRes    = m_uncompressedImageResVec[levelNdx];
1660                 const UVec3&                            srcImageResolution              = m_srcImageResolutions[levelNdx];
1661                 const UVec3&                            dstImageResolution              = m_dstImageResolutions[levelNdx];
1662                 const UVec3                                     dstImageResBlocked              = getCompressedImageResolutionBlockCeil(m_parameters.formatCompressed, dstImageResolution);
1663                 const size_t                            srcImageSizeInBytes             = m_srcData[levelNdx][0]->size();
1664                 const size_t                            dstImageSizeInBytes             = m_dstData[levelNdx][0]->size();
1665
1666                 const VkImageCreateInfo         srcImageCreateInfo              = makeCreateImageInfo(m_srcFormat, m_parameters.imageType, srcImageResolution, m_srcImageUsageFlags, imgCreateFlagsOverride, SINGLE_LEVEL, SINGLE_LAYER);
1667
1668                 const VkExtent2D                        renderSize                              (makeExtent2D(uncompressedImageRes.x(), uncompressedImageRes.y()));
1669                 const VkViewport                        viewport                                = makeViewport(0.0f, 0.0f, static_cast<float>(renderSize.width), static_cast<float>(renderSize.height), 0.0f, 1.0f);
1670                 const VkRect2D                          scissor                                 = makeScissor(renderSize.width, renderSize.height);
1671
1672                 for (deUint32 layerNdx = 0; layerNdx < getLayerCount(); ++layerNdx)
1673                 {
1674                         const VkBufferCreateInfo                srcImageBufferInfo              = makeBufferCreateInfo(srcImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
1675                         const MovePtr<Buffer>                   srcImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, srcImageBufferInfo, MemoryRequirement::HostVisible));
1676
1677                         const VkBufferCreateInfo                dstImageBufferInfo              = makeBufferCreateInfo(dstImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
1678                         MovePtr<Buffer>                                 dstImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, dstImageBufferInfo, MemoryRequirement::HostVisible));
1679
1680                         const VkImageSubresourceRange   srcSubresourceRange             = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, SINGLE_LEVEL, 0u, SINGLE_LAYER);
1681                         const VkImageSubresourceRange   dstSubresourceRange             = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, levelNdx, SINGLE_LEVEL, layerNdx, SINGLE_LAYER);
1682
1683                         Move<VkImageView>                               dstImageView                    (makeImageView(vk, device, dstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, dstSubresourceRange, m_dstImageViewUsageKHR));
1684
1685                         de::MovePtr<Image>                              srcImage                                (new Image(vk, device, allocator, srcImageCreateInfo, MemoryRequirement::Any));
1686                         Move<VkImageView>                               srcImageView                    (makeImageView(vk, device, srcImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, srcSubresourceRange, m_srcImageViewUsageKHR));
1687
1688                         const VkBufferImageCopy                 srcCopyRegion                   = makeBufferImageCopy(srcImageResolution.x(), srcImageResolution.y(), 0u, 0u);
1689                         const VkBufferMemoryBarrier             srcCopyBufferBarrierPre = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, srcImageBuffer->get(), 0ull, srcImageSizeInBytes);
1690                         const VkImageMemoryBarrier              srcCopyImageBarrierPre  = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, srcImage->get(), srcSubresourceRange);
1691                         const VkImageMemoryBarrier              srcCopyImageBarrierPost = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, srcImage->get(), srcSubresourceRange);
1692                         const VkBufferImageCopy                 dstCopyRegion                   = makeBufferImageCopy(dstImageResolution.x(), dstImageResolution.y(), levelNdx, layerNdx, dstImageResBlocked.x(), dstImageResBlocked.y());
1693                         const VkImageMemoryBarrier              dstInitImageBarrier             = makeImageMemoryBarrier(0u, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, dstImage->get(), dstSubresourceRange);
1694
1695                         const VkImageView                               attachmentBindInfos[]   = { *srcImageView, *dstImageView };
1696                         const VkExtent2D                                framebufferSize                 (renderSize);
1697                         const Move<VkFramebuffer>               framebuffer                             (makeFramebuffer(vk, device, *renderPass, DE_LENGTH_OF_ARRAY(attachmentBindInfos), attachmentBindInfos, framebufferSize, SINGLE_LAYER));
1698
1699                         // Upload source image data
1700                         const Allocation& alloc = srcImageBuffer->getAllocation();
1701                         deMemcpy(alloc.getHostPtr(), &m_srcData[levelNdx][layerNdx]->at(0), srcImageSizeInBytes);
1702                         flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), srcImageSizeInBytes);
1703
1704                         beginCommandBuffer(vk, *cmdBuffer);
1705                         vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1706
1707                         // Copy buffer to image
1708                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);
1709                         vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);
1710                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &srcCopyImageBarrierPost);
1711
1712                         // Define destination image layout
1713                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &dstInitImageBarrier);
1714
1715                         beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
1716
1717                         const VkDescriptorImageInfo     descriptorSrcImageInfo(makeDescriptorImageInfo(DE_NULL, *srcImageView, VK_IMAGE_LAYOUT_GENERAL));
1718                         DescriptorSetUpdateBuilder()
1719                                 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, &descriptorSrcImageInfo)
1720                                 .update(vk, device);
1721
1722                         vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
1723                         vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &m_vertexBuffer->get(), &m_vertexBufferOffset);
1724
1725                         vk.cmdSetViewport(*cmdBuffer, 0u, 1u, &viewport);
1726                         vk.cmdSetScissor(*cmdBuffer, 0u, 1u, &scissor);
1727
1728                         vk.cmdDraw(*cmdBuffer, (deUint32)m_vertexCount, 1, 0, 0);
1729
1730                         vk.cmdEndRenderPass(*cmdBuffer);
1731
1732                         const VkImageMemoryBarrier prepareForTransferBarrier = makeImageMemoryBarrier(
1733                                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1734                                 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
1735                                 dstImage->get(), dstSubresourceRange);
1736
1737                         const VkBufferMemoryBarrier copyBarrier = makeBufferMemoryBarrier(
1738                                 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
1739                                 dstImageBuffer->get(), 0ull, dstImageSizeInBytes);
1740
1741                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &prepareForTransferBarrier);
1742                         vk.cmdCopyImageToBuffer(*cmdBuffer, dstImage->get(), VK_IMAGE_LAYOUT_GENERAL, dstImageBuffer->get(), 1u, &dstCopyRegion);
1743                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &copyBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1744
1745                         endCommandBuffer(vk, *cmdBuffer);
1746
1747                         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
1748
1749                         const Allocation& dstImageBufferAlloc = dstImageBuffer->getAllocation();
1750                         invalidateMappedMemoryRange(vk, device, dstImageBufferAlloc.getMemory(), dstImageBufferAlloc.getOffset(), dstImageSizeInBytes);
1751                         deMemcpy(&m_dstData[levelNdx][layerNdx]->at(0), dstImageBufferAlloc.getHostPtr(), dstImageSizeInBytes);
1752                 }
1753         }
1754
1755         m_compressedImage = dstImage;
1756 }
1757
1758 bool GraphicsAttachmentsTestInstance::isWriteToCompressedOperation ()
1759 {
1760         return (m_parameters.operation == OPERATION_ATTACHMENT_WRITE);
1761 }
1762
1763 VkImageCreateInfo GraphicsAttachmentsTestInstance::makeCreateImageInfo (const VkFormat                          format,
1764                                                                                                                                             const ImageType                             type,
1765                                                                                                                                             const UVec3&                                size,
1766                                                                                                                                             const VkImageUsageFlags             usageFlags,
1767                                                                                                                                             const VkImageCreateFlags*   createFlags,
1768                                                                                                                                             const deUint32                              levels,
1769                                                                                                                                             const deUint32                              layers)
1770 {
1771         const VkImageType                       imageType                               = mapImageType(type);
1772         const VkImageCreateFlags        imageCreateFlagsBase    = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
1773         const VkImageCreateFlags        imageCreateFlagsAddOn   = isCompressedFormat(format) ? VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR : 0;
1774         const VkImageCreateFlags        imageCreateFlags                = (createFlags != DE_NULL) ? *createFlags : (imageCreateFlagsBase | imageCreateFlagsAddOn);
1775
1776         const VkImageCreateInfo createImageInfo =
1777         {
1778                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                    // VkStructureType                      sType;
1779                 DE_NULL,                                                                                // const void*                          pNext;
1780                 imageCreateFlags,                                                               // VkImageCreateFlags           flags;
1781                 imageType,                                                                              // VkImageType                          imageType;
1782                 format,                                                                                 // VkFormat                                     format;
1783                 makeExtent3D(getLayerSize(type, size)),                 // VkExtent3D                           extent;
1784                 levels,                                                                                 // deUint32                                     mipLevels;
1785                 layers,                                                                                 // deUint32                                     arrayLayers;
1786                 VK_SAMPLE_COUNT_1_BIT,                                                  // VkSampleCountFlagBits        samples;
1787                 VK_IMAGE_TILING_OPTIMAL,                                                // VkImageTiling                        tiling;
1788                 usageFlags,                                                                             // VkImageUsageFlags            usage;
1789                 VK_SHARING_MODE_EXCLUSIVE,                                              // VkSharingMode                        sharingMode;
1790                 0u,                                                                                             // deUint32                                     queueFamilyIndexCount;
1791                 DE_NULL,                                                                                // const deUint32*                      pQueueFamilyIndices;
1792                 VK_IMAGE_LAYOUT_UNDEFINED,                                              // VkImageLayout                        initialLayout;
1793         };
1794
1795         return createImageInfo;
1796 }
1797
1798 VkDeviceSize GraphicsAttachmentsTestInstance::getCompressedImageData (const VkFormat                    format,
1799                                                                                                                                           const UVec3&                          size,
1800                                                                                                                                           std::vector<deUint8>&         data,
1801                                                                                                                                           const deUint32                        layer,
1802                                                                                                                                           const deUint32                        level)
1803 {
1804         VkDeviceSize    sizeBytes       = getCompressedImageSizeInBytes(format, size);
1805
1806         data.resize((size_t)sizeBytes);
1807         generateData(&data[0], data.size(), format, layer, level);
1808
1809         return sizeBytes;
1810 }
1811
1812 VkDeviceSize GraphicsAttachmentsTestInstance::getUncompressedImageData (const VkFormat                  format,
1813                                                                                                                                                 const UVec3&                    size,
1814                                                                                                                                                 std::vector<deUint8>&   data,
1815                                                                                                                                                 const deUint32                  layer,
1816                                                                                                                                                 const deUint32                  level)
1817 {
1818         tcu::IVec3                              sizeAsIVec3     = tcu::IVec3(static_cast<int>(size[0]), static_cast<int>(size[1]), static_cast<int>(size[2]));
1819         VkDeviceSize                    sizeBytes       = getImageSizeBytes(sizeAsIVec3, format);
1820
1821         data.resize((size_t)sizeBytes);
1822         generateData(&data[0], data.size(), format, layer, level);
1823
1824         return sizeBytes;
1825 }
1826
1827 bool GraphicsAttachmentsTestInstance::verifyDecompression (const std::vector<deUint8>&  refCompressedData,
1828                                                                                                                    const de::MovePtr<Image>&    resCompressedImage,
1829                                                                                                                    const deUint32                               level,
1830                                                                                                                    const deUint32                               layer,
1831                                                                                                                    const UVec3&                                 mipmapDims)
1832 {
1833         const DeviceInterface&                          vk                                                      = m_context.getDeviceInterface();
1834         const VkDevice                                          device                                          = m_context.getDevice();
1835         const deUint32                                          queueFamilyIndex                        = m_context.getUniversalQueueFamilyIndex();
1836         const VkQueue                                           queue                                           = m_context.getUniversalQueue();
1837         Allocator&                                                      allocator                                       = m_context.getDefaultAllocator();
1838
1839         const bool                                                      layoutShaderReadOnly            = (layer % 2u) == 1;
1840         const UVec3                                                     mipmapDimsBlocked                       = getCompressedImageResolutionBlockCeil(m_parameters.formatCompressed, mipmapDims);
1841
1842         const VkImageSubresourceRange           subresourceRange                        = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, SINGLE_LEVEL, 0u, SINGLE_LAYER);
1843         const VkImageSubresourceRange           resSubresourceRange                     = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, level, SINGLE_LEVEL, layer, SINGLE_LAYER);
1844
1845         const VkDeviceSize                                      dstBufferSize                           = getUncompressedImageSizeInBytes(m_parameters.formatForVerify, mipmapDims);
1846         const VkImageUsageFlags                         refSrcImageUsageFlags           = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
1847
1848         const VkBufferCreateInfo                        refSrcImageBufferInfo           (makeBufferCreateInfo(refCompressedData.size(), VK_BUFFER_USAGE_TRANSFER_SRC_BIT));
1849         const MovePtr<Buffer>                           refSrcImageBuffer                       = MovePtr<Buffer>(new Buffer(vk, device, allocator, refSrcImageBufferInfo, MemoryRequirement::HostVisible));
1850
1851         const VkImageCreateFlags                        refSrcImageCreateFlags          = 0;
1852         const VkImageCreateInfo                         refSrcImageCreateInfo           = makeCreateImageInfo(m_parameters.formatCompressed, m_parameters.imageType, mipmapDimsBlocked, refSrcImageUsageFlags, &refSrcImageCreateFlags, SINGLE_LEVEL, SINGLE_LAYER);
1853         const MovePtr<Image>                            refSrcImage                                     (new Image(vk, device, allocator, refSrcImageCreateInfo, MemoryRequirement::Any));
1854         Move<VkImageView>                                       refSrcImageView                         (makeImageView(vk, device, refSrcImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatCompressed, subresourceRange));
1855
1856         const VkImageUsageFlags                         resSrcImageUsageFlags           = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
1857         const VkImageViewUsageCreateInfoKHR     resSrcImageViewUsageKHR         = makeImageViewUsageCreateInfo(resSrcImageUsageFlags);
1858         Move<VkImageView>                                       resSrcImageView                         (makeImageView(vk, device, resCompressedImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatCompressed, resSubresourceRange, &resSrcImageViewUsageKHR));
1859
1860         const VkImageCreateFlags                        refDstImageCreateFlags          = 0;
1861         const VkImageUsageFlags                         refDstImageUsageFlags           = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
1862         const VkImageCreateInfo                         refDstImageCreateInfo           = makeCreateImageInfo(m_parameters.formatForVerify, m_parameters.imageType, mipmapDims, refDstImageUsageFlags, &refDstImageCreateFlags, SINGLE_LEVEL, SINGLE_LAYER);
1863         const MovePtr<Image>                            refDstImage                                     (new Image(vk, device, allocator, refDstImageCreateInfo, MemoryRequirement::Any));
1864         const Move<VkImageView>                         refDstImageView                         (makeImageView(vk, device, refDstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatForVerify, subresourceRange));
1865         const VkImageMemoryBarrier                      refDstInitImageBarrier          = makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, refDstImage->get(), subresourceRange);
1866         const VkBufferCreateInfo                        refDstBufferInfo                        (makeBufferCreateInfo(dstBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT));
1867         const MovePtr<Buffer>                           refDstBuffer                            = MovePtr<Buffer>(new Buffer(vk, device, allocator, refDstBufferInfo, MemoryRequirement::HostVisible));
1868
1869         const VkImageCreateFlags                        resDstImageCreateFlags          = 0;
1870         const VkImageUsageFlags                         resDstImageUsageFlags           = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
1871         const VkImageCreateInfo                         resDstImageCreateInfo           = makeCreateImageInfo(m_parameters.formatForVerify, m_parameters.imageType, mipmapDims, resDstImageUsageFlags, &resDstImageCreateFlags, SINGLE_LEVEL, SINGLE_LAYER);
1872         const MovePtr<Image>                            resDstImage                                     (new Image(vk, device, allocator, resDstImageCreateInfo, MemoryRequirement::Any));
1873         const Move<VkImageView>                         resDstImageView                         (makeImageView(vk, device, resDstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatForVerify, subresourceRange));
1874         const VkImageMemoryBarrier                      resDstInitImageBarrier          = makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, resDstImage->get(), subresourceRange);
1875         const VkBufferCreateInfo                        resDstBufferInfo                        (makeBufferCreateInfo(dstBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT));
1876         const MovePtr<Buffer>                           resDstBuffer                            = MovePtr<Buffer>(new Buffer(vk, device, allocator, resDstBufferInfo, MemoryRequirement::HostVisible));
1877
1878         const Unique<VkShaderModule>            vertShaderModule                        (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
1879         const Unique<VkShaderModule>            fragShaderModule                        (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag_verify"), 0));
1880
1881         const Unique<VkRenderPass>                      renderPass                                      (makeRenderPass(vk, device));
1882
1883         const Move<VkDescriptorSetLayout>       descriptorSetLayout                     (DescriptorSetLayoutBuilder()
1884                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT)
1885                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT)
1886                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_FRAGMENT_BIT)
1887                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_FRAGMENT_BIT)
1888                                                                                                                                                 .build(vk, device));
1889         const Move<VkDescriptorPool>            descriptorPool                          (DescriptorPoolBuilder()
1890                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
1891                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
1892                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
1893                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
1894                                                                                                                                                 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
1895         const Move<VkDescriptorSet>                     descriptorSet                           (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
1896         const VkSamplerCreateInfo                       refSrcSamplerInfo                       (makeSamplerCreateInfo());
1897         const Move<VkSampler>                           refSrcSampler                           = vk::createSampler(vk, device, &refSrcSamplerInfo);
1898         const VkSamplerCreateInfo                       resSrcSamplerInfo                       (makeSamplerCreateInfo());
1899         const Move<VkSampler>                           resSrcSampler                           = vk::createSampler(vk, device, &resSrcSamplerInfo);
1900         const VkDescriptorImageInfo                     descriptorRefSrcImage           (makeDescriptorImageInfo(*refSrcSampler, *refSrcImageView, layoutShaderReadOnly ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL));
1901         const VkDescriptorImageInfo                     descriptorResSrcImage           (makeDescriptorImageInfo(*resSrcSampler, *resSrcImageView, layoutShaderReadOnly ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL));
1902         const VkDescriptorImageInfo                     descriptorRefDstImage           (makeDescriptorImageInfo(DE_NULL, *refDstImageView, VK_IMAGE_LAYOUT_GENERAL));
1903         const VkDescriptorImageInfo                     descriptorResDstImage           (makeDescriptorImageInfo(DE_NULL, *resDstImageView, VK_IMAGE_LAYOUT_GENERAL));
1904
1905         const VkExtent2D                                        renderSize                                      (makeExtent2D(mipmapDims.x(), mipmapDims.y()));
1906         const Unique<VkPipelineLayout>          pipelineLayout                          (makePipelineLayout(vk, device, *descriptorSetLayout));
1907         const Unique<VkPipeline>                        pipeline                                        (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertShaderModule, *fragShaderModule, renderSize, 0u));
1908         const Unique<VkCommandPool>                     cmdPool                                         (createCommandPool(vk, device, VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT, queueFamilyIndex));
1909         const Unique<VkCommandBuffer>           cmdBuffer                                       (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
1910
1911         const VkBufferImageCopy                         copyBufferToImageRegion         = makeBufferImageCopy(mipmapDimsBlocked.x(), mipmapDimsBlocked.y(), 0u, 0u, mipmapDimsBlocked.x(), mipmapDimsBlocked.y());
1912         const VkBufferImageCopy                         copyRegion                                      = makeBufferImageCopy(mipmapDims.x(), mipmapDims.y(), 0u, 0u);
1913         const VkBufferMemoryBarrier                     refSrcCopyBufferBarrierPre      = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, refSrcImageBuffer->get(), 0ull, refCompressedData.size());
1914         const VkImageMemoryBarrier                      refSrcCopyImageBarrierPre       = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, refSrcImage->get(), subresourceRange);
1915         const VkImageMemoryBarrier                      refSrcCopyImageBarrierPost      = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL, layoutShaderReadOnly ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL, refSrcImage->get(), subresourceRange);
1916         const VkImageMemoryBarrier                      resCompressedImageBarrier       = makeImageMemoryBarrier(0, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL, layoutShaderReadOnly ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL, resCompressedImage->get(), resSubresourceRange);
1917
1918         const Move<VkFramebuffer>                       framebuffer                                     (makeFramebuffer(vk, device, *renderPass, 0, DE_NULL, renderSize, getLayerCount()));
1919
1920         // Upload source image data
1921         {
1922                 const Allocation& refSrcImageBufferAlloc = refSrcImageBuffer->getAllocation();
1923                 deMemcpy(refSrcImageBufferAlloc.getHostPtr(), &refCompressedData[0], refCompressedData.size());
1924                 flushMappedMemoryRange(vk, device, refSrcImageBufferAlloc.getMemory(), refSrcImageBufferAlloc.getOffset(), refCompressedData.size());
1925         }
1926
1927         beginCommandBuffer(vk, *cmdBuffer);
1928         vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1929
1930         // Copy buffer to image
1931         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &refSrcCopyBufferBarrierPre, 1u, &refSrcCopyImageBarrierPre);
1932         vk.cmdCopyBufferToImage(*cmdBuffer, refSrcImageBuffer->get(), refSrcImage->get(), VK_IMAGE_LAYOUT_GENERAL, 1u, &copyBufferToImageRegion);
1933         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, DE_NULL, 1u, &refSrcCopyImageBarrierPost);
1934
1935         // Make reference and result images readable
1936         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &refDstInitImageBarrier);
1937         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &resDstInitImageBarrier);
1938         {
1939                 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &resCompressedImageBarrier);
1940         }
1941
1942         beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
1943         {
1944                 DescriptorSetUpdateBuilder()
1945                         .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorRefSrcImage)
1946                         .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorResSrcImage)
1947                         .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(2u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorRefDstImage)
1948                         .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(3u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorResDstImage)
1949                         .update(vk, device);
1950
1951                 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
1952                 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &m_vertexBuffer->get(), &m_vertexBufferOffset);
1953                 vk.cmdDraw(*cmdBuffer, m_vertexCount, 1, 0, 0);
1954         }
1955         vk.cmdEndRenderPass(*cmdBuffer);
1956
1957         // Decompress reference image
1958         {
1959                 const VkImageMemoryBarrier refDstImageBarrier = makeImageMemoryBarrier(
1960                         VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1961                         VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
1962                         refDstImage->get(), subresourceRange);
1963
1964                 const VkBufferMemoryBarrier refDstBufferBarrier = makeBufferMemoryBarrier(
1965                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
1966                         refDstBuffer->get(), 0ull, dstBufferSize);
1967
1968                 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &refDstImageBarrier);
1969                 vk.cmdCopyImageToBuffer(*cmdBuffer, refDstImage->get(), VK_IMAGE_LAYOUT_GENERAL, refDstBuffer->get(), 1u, &copyRegion);
1970                 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &refDstBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1971         }
1972
1973         // Decompress result image
1974         {
1975                 const VkImageMemoryBarrier resDstImageBarrier = makeImageMemoryBarrier(
1976                         VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1977                         VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
1978                         resDstImage->get(), subresourceRange);
1979
1980                 const VkBufferMemoryBarrier resDstBufferBarrier = makeBufferMemoryBarrier(
1981                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
1982                         resDstBuffer->get(), 0ull, dstBufferSize);
1983
1984                 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &resDstImageBarrier);
1985                 vk.cmdCopyImageToBuffer(*cmdBuffer, resDstImage->get(), VK_IMAGE_LAYOUT_GENERAL, resDstBuffer->get(), 1u, &copyRegion);
1986                 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &resDstBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1987         }
1988
1989         endCommandBuffer(vk, *cmdBuffer);
1990
1991         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
1992
1993         // Compare decompressed pixel data in reference and result images
1994         {
1995                 const Allocation&       refDstBufferAlloc       = refDstBuffer->getAllocation();
1996                 invalidateMappedMemoryRange(vk, device, refDstBufferAlloc.getMemory(), refDstBufferAlloc.getOffset(), dstBufferSize);
1997
1998                 const Allocation&       resDstBufferAlloc       = resDstBuffer->getAllocation();
1999                 invalidateMappedMemoryRange(vk, device, resDstBufferAlloc.getMemory(), resDstBufferAlloc.getOffset(), dstBufferSize);
2000
2001                 if (deMemCmp(refDstBufferAlloc.getHostPtr(), resDstBufferAlloc.getHostPtr(), (size_t)dstBufferSize) != 0)
2002                 {
2003                         // Do fuzzy to log error mask
2004                         invalidateMappedMemoryRange(vk, device, resDstBufferAlloc.getMemory(), resDstBufferAlloc.getOffset(), dstBufferSize);
2005                         invalidateMappedMemoryRange(vk, device, refDstBufferAlloc.getMemory(), refDstBufferAlloc.getOffset(), dstBufferSize);
2006
2007                         tcu::ConstPixelBufferAccess     resPixels       (mapVkFormat(m_parameters.formatForVerify), renderSize.width, renderSize.height, 1u, resDstBufferAlloc.getHostPtr());
2008                         tcu::ConstPixelBufferAccess     refPixels       (mapVkFormat(m_parameters.formatForVerify), renderSize.width, renderSize.height, 1u, refDstBufferAlloc.getHostPtr());
2009
2010                         string  comment = string("Image Comparison (level=") + de::toString(level) + string(", layer=") + de::toString(layer) + string(")");
2011
2012                         if (isWriteToCompressedOperation())
2013                                 tcu::fuzzyCompare(m_context.getTestContext().getLog(), "ImageComparison", comment.c_str(), refPixels, resPixels, 0.001f, tcu::COMPARE_LOG_EVERYTHING);
2014                         else
2015                                 tcu::fuzzyCompare(m_context.getTestContext().getLog(), "ImageComparison", comment.c_str(), resPixels, refPixels, 0.001f, tcu::COMPARE_LOG_EVERYTHING);
2016
2017                         return false;
2018                 }
2019         }
2020
2021         return true;
2022 }
2023
2024
2025 class GraphicsTextureTestInstance : public GraphicsAttachmentsTestInstance
2026 {
2027 public:
2028                                                 GraphicsTextureTestInstance             (Context& context, const TestParameters& parameters);
2029
2030 protected:
2031         virtual bool            isWriteToCompressedOperation    ();
2032         virtual void            transcodeRead                                   ();
2033         virtual void            transcodeWrite                                  ();
2034 };
2035
2036 GraphicsTextureTestInstance::GraphicsTextureTestInstance (Context& context, const TestParameters& parameters)
2037         : GraphicsAttachmentsTestInstance(context, parameters)
2038 {
2039 }
2040
2041 bool GraphicsTextureTestInstance::isWriteToCompressedOperation ()
2042 {
2043         return (m_parameters.operation == OPERATION_TEXTURE_WRITE);
2044 }
2045
2046 void GraphicsTextureTestInstance::transcodeRead ()
2047 {
2048         const DeviceInterface&                          vk                                              = m_context.getDeviceInterface();
2049         const VkDevice                                          device                                  = m_context.getDevice();
2050         const deUint32                                          queueFamilyIndex                = m_context.getUniversalQueueFamilyIndex();
2051         const VkQueue                                           queue                                   = m_context.getUniversalQueue();
2052         Allocator&                                                      allocator                               = m_context.getDefaultAllocator();
2053
2054         const VkImageCreateFlags*                       imgCreateFlagsOverride  = DE_NULL;
2055
2056         const VkImageCreateInfo                         srcImageCreateInfo              = makeCreateImageInfo(m_srcFormat, m_parameters.imageType, m_srcImageResolutions[0], m_srcImageUsageFlags, imgCreateFlagsOverride, getLevelCount(), getLayerCount());
2057         MovePtr<Image>                                          srcImage                                (new Image(vk, device, allocator, srcImageCreateInfo, MemoryRequirement::Any));
2058
2059         const Unique<VkShaderModule>            vertShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
2060         const Unique<VkShaderModule>            fragShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
2061
2062         const Unique<VkRenderPass>                      renderPass                              (makeRenderPass(vk, device));
2063
2064         const Move<VkDescriptorSetLayout>       descriptorSetLayout             (DescriptorSetLayoutBuilder()
2065                                                                                                                                         .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT)
2066                                                                                                                                         .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_FRAGMENT_BIT)
2067                                                                                                                                         .build(vk, device));
2068         const Move<VkDescriptorPool>            descriptorPool                  (DescriptorPoolBuilder()
2069                                                                                                                                         .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
2070                                                                                                                                         .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
2071                                                                                                                                         .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
2072         const Move<VkDescriptorSet>                     descriptorSet                   (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
2073
2074         const VkExtent2D                                        renderSizeDummy                 (makeExtent2D(1u, 1u));
2075         const Unique<VkPipelineLayout>          pipelineLayout                  (makePipelineLayout(vk, device, *descriptorSetLayout));
2076         const Unique<VkPipeline>                        pipeline                                (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertShaderModule, *fragShaderModule, renderSizeDummy, 0u, true));
2077
2078         const Unique<VkCommandPool>                     cmdPool                                 (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
2079         const Unique<VkCommandBuffer>           cmdBuffer                               (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
2080
2081         for (deUint32 levelNdx = 0; levelNdx < getLevelCount(); ++levelNdx)
2082         {
2083                 const UVec3&                            uncompressedImageRes    = m_uncompressedImageResVec[levelNdx];
2084                 const UVec3&                            srcImageResolution              = m_srcImageResolutions[levelNdx];
2085                 const UVec3&                            dstImageResolution              = m_dstImageResolutions[levelNdx];
2086                 const size_t                            srcImageSizeInBytes             = m_srcData[levelNdx][0]->size();
2087                 const size_t                            dstImageSizeInBytes             = m_dstData[levelNdx][0]->size();
2088                 const UVec3                                     srcImageResBlocked              = getCompressedImageResolutionBlockCeil(m_parameters.formatCompressed, srcImageResolution);
2089
2090                 const VkImageCreateInfo         dstImageCreateInfo              = makeCreateImageInfo(m_dstFormat, m_parameters.imageType, dstImageResolution, m_dstImageUsageFlags, imgCreateFlagsOverride, SINGLE_LEVEL, SINGLE_LAYER);
2091
2092                 const VkBufferCreateInfo        srcImageBufferInfo              = makeBufferCreateInfo(srcImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
2093                 const MovePtr<Buffer>           srcImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, srcImageBufferInfo, MemoryRequirement::HostVisible));
2094
2095                 const VkBufferCreateInfo        dstImageBufferInfo              = makeBufferCreateInfo(dstImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
2096                 MovePtr<Buffer>                         dstImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, dstImageBufferInfo, MemoryRequirement::HostVisible));
2097
2098                 const VkExtent2D                        renderSize                              (makeExtent2D(uncompressedImageRes.x(), uncompressedImageRes.y()));
2099                 const VkViewport                        viewport                                = makeViewport(0.0f, 0.0f, static_cast<float>(renderSize.width), static_cast<float>(renderSize.height), 0.0f, 1.0f);
2100                 const VkRect2D                          scissor                                 = makeScissor(renderSize.width, renderSize.height);
2101
2102                 for (deUint32 layerNdx = 0; layerNdx < getLayerCount(); ++layerNdx)
2103                 {
2104                         const VkImageSubresourceRange   srcSubresourceRange             = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, levelNdx, SINGLE_LEVEL, layerNdx, SINGLE_LAYER);
2105                         const VkImageSubresourceRange   dstSubresourceRange             = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, SINGLE_LEVEL, 0u, SINGLE_LAYER);
2106
2107                         Move<VkImageView>                               srcImageView                    (makeImageView(vk, device, srcImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, srcSubresourceRange, m_srcImageViewUsageKHR));
2108
2109                         de::MovePtr<Image>                              dstImage                                (new Image(vk, device, allocator, dstImageCreateInfo, MemoryRequirement::Any));
2110                         Move<VkImageView>                               dstImageView                    (makeImageView(vk, device, dstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, dstSubresourceRange, m_dstImageViewUsageKHR));
2111
2112                         const VkSamplerCreateInfo               srcSamplerInfo                  (makeSamplerCreateInfo());
2113                         const Move<VkSampler>                   srcSampler                              = vk::createSampler(vk, device, &srcSamplerInfo);
2114                         const VkDescriptorImageInfo             descriptorSrcImage              (makeDescriptorImageInfo(*srcSampler, *srcImageView, VK_IMAGE_LAYOUT_GENERAL));
2115                         const VkDescriptorImageInfo             descriptorDstImage              (makeDescriptorImageInfo(DE_NULL, *dstImageView, VK_IMAGE_LAYOUT_GENERAL));
2116
2117                         const VkBufferImageCopy                 srcCopyRegion                   = makeBufferImageCopy(srcImageResolution.x(), srcImageResolution.y(), levelNdx, layerNdx, srcImageResBlocked.x(), srcImageResBlocked.y());
2118                         const VkBufferMemoryBarrier             srcCopyBufferBarrierPre = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, srcImageBuffer->get(), 0ull, srcImageSizeInBytes);
2119                         const VkImageMemoryBarrier              srcCopyImageBarrierPre  = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, srcImage->get(), srcSubresourceRange);
2120                         const VkImageMemoryBarrier              srcCopyImageBarrierPost = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, srcImage->get(), srcSubresourceRange);
2121                         const VkBufferImageCopy                 dstCopyRegion                   = makeBufferImageCopy(dstImageResolution.x(), dstImageResolution.y());
2122                         const VkImageMemoryBarrier              dstInitImageBarrier             = makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, dstImage->get(), dstSubresourceRange);
2123
2124                         const VkExtent2D                                framebufferSize                 (makeExtent2D(dstImageResolution[0], dstImageResolution[1]));
2125                         const Move<VkFramebuffer>               framebuffer                             (makeFramebuffer(vk, device, *renderPass, 0, DE_NULL, framebufferSize, SINGLE_LAYER));
2126
2127                         // Upload source image data
2128                         const Allocation& alloc = srcImageBuffer->getAllocation();
2129                         deMemcpy(alloc.getHostPtr(), &m_srcData[levelNdx][layerNdx]->at(0), srcImageSizeInBytes);
2130                         flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), srcImageSizeInBytes);
2131
2132                         beginCommandBuffer(vk, *cmdBuffer);
2133                         vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
2134
2135                         // Copy buffer to image
2136                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);
2137                         vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);
2138                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &srcCopyImageBarrierPost);
2139
2140                         // Define destination image layout
2141                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &dstInitImageBarrier);
2142
2143                         beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
2144
2145                         DescriptorSetUpdateBuilder()
2146                                 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorSrcImage)
2147                                 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorDstImage)
2148                                 .update(vk, device);
2149
2150                         vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
2151                         vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &m_vertexBuffer->get(), &m_vertexBufferOffset);
2152
2153                         vk.cmdSetViewport(*cmdBuffer, 0u, 1u, &viewport);
2154                         vk.cmdSetScissor(*cmdBuffer, 0u, 1u, &scissor);
2155
2156                         vk.cmdDraw(*cmdBuffer, (deUint32)m_vertexCount, 1, 0, 0);
2157
2158                         vk.cmdEndRenderPass(*cmdBuffer);
2159
2160                         const VkImageMemoryBarrier prepareForTransferBarrier = makeImageMemoryBarrier(
2161                                 VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
2162                                 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
2163                                 dstImage->get(), dstSubresourceRange);
2164
2165                         const VkBufferMemoryBarrier copyBarrier = makeBufferMemoryBarrier(
2166                                 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
2167                                 dstImageBuffer->get(), 0ull, dstImageSizeInBytes);
2168
2169                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &prepareForTransferBarrier);
2170                         vk.cmdCopyImageToBuffer(*cmdBuffer, dstImage->get(), VK_IMAGE_LAYOUT_GENERAL, dstImageBuffer->get(), 1u, &dstCopyRegion);
2171                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &copyBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
2172
2173                         endCommandBuffer(vk, *cmdBuffer);
2174
2175                         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
2176
2177                         const Allocation& dstImageBufferAlloc = dstImageBuffer->getAllocation();
2178                         invalidateMappedMemoryRange(vk, device, dstImageBufferAlloc.getMemory(), dstImageBufferAlloc.getOffset(), dstImageSizeInBytes);
2179                         deMemcpy(&m_dstData[levelNdx][layerNdx]->at(0), dstImageBufferAlloc.getHostPtr(), dstImageSizeInBytes);
2180                 }
2181         }
2182
2183         m_compressedImage = srcImage;
2184 }
2185
2186 void GraphicsTextureTestInstance::transcodeWrite ()
2187 {
2188         const DeviceInterface&                          vk                                              = m_context.getDeviceInterface();
2189         const VkDevice                                          device                                  = m_context.getDevice();
2190         const deUint32                                          queueFamilyIndex                = m_context.getUniversalQueueFamilyIndex();
2191         const VkQueue                                           queue                                   = m_context.getUniversalQueue();
2192         Allocator&                                                      allocator                               = m_context.getDefaultAllocator();
2193
2194         const VkImageCreateFlags*                       imgCreateFlagsOverride  = DE_NULL;
2195
2196         const VkImageCreateInfo                         dstImageCreateInfo              = makeCreateImageInfo(m_dstFormat, m_parameters.imageType, m_dstImageResolutions[0], m_dstImageUsageFlags, imgCreateFlagsOverride, getLevelCount(), getLayerCount());
2197         MovePtr<Image>                                          dstImage                                (new Image(vk, device, allocator, dstImageCreateInfo, MemoryRequirement::Any));
2198
2199         const Unique<VkShaderModule>            vertShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
2200         const Unique<VkShaderModule>            fragShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
2201
2202         const Unique<VkRenderPass>                      renderPass                              (makeRenderPass(vk, device));
2203
2204         const Move<VkDescriptorSetLayout>       descriptorSetLayout             (DescriptorSetLayoutBuilder()
2205                                                                                                                                         .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT)
2206                                                                                                                                         .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_FRAGMENT_BIT)
2207                                                                                                                                         .build(vk, device));
2208         const Move<VkDescriptorPool>            descriptorPool                  (DescriptorPoolBuilder()
2209                                                                                                                                         .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
2210                                                                                                                                         .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
2211                                                                                                                                         .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
2212         const Move<VkDescriptorSet>                     descriptorSet                   (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
2213
2214         const VkExtent2D                                        renderSizeDummy                 (makeExtent2D(1u, 1u));
2215         const Unique<VkPipelineLayout>          pipelineLayout                  (makePipelineLayout(vk, device, *descriptorSetLayout));
2216         const Unique<VkPipeline>                        pipeline                                (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertShaderModule, *fragShaderModule, renderSizeDummy, 0u, true));
2217
2218         const Unique<VkCommandPool>                     cmdPool                                 (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
2219         const Unique<VkCommandBuffer>           cmdBuffer                               (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
2220
2221         for (deUint32 levelNdx = 0; levelNdx < getLevelCount(); ++levelNdx)
2222         {
2223                 const UVec3&                            uncompressedImageRes    = m_uncompressedImageResVec[levelNdx];
2224                 const UVec3&                            srcImageResolution              = m_srcImageResolutions[levelNdx];
2225                 const UVec3&                            dstImageResolution              = m_dstImageResolutions[levelNdx];
2226                 const size_t                            srcImageSizeInBytes             = m_srcData[levelNdx][0]->size();
2227                 const size_t                            dstImageSizeInBytes             = m_dstData[levelNdx][0]->size();
2228                 const UVec3                                     dstImageResBlocked              = getCompressedImageResolutionBlockCeil(m_parameters.formatCompressed, dstImageResolution);
2229
2230                 const VkImageCreateInfo         srcImageCreateInfo              = makeCreateImageInfo(m_srcFormat, m_parameters.imageType, srcImageResolution, m_srcImageUsageFlags, imgCreateFlagsOverride, SINGLE_LEVEL, SINGLE_LAYER);
2231
2232                 const VkExtent2D                        renderSize                              (makeExtent2D(uncompressedImageRes.x(), uncompressedImageRes.y()));
2233                 const VkViewport                        viewport                                = makeViewport(0.0f, 0.0f, static_cast<float>(renderSize.width), static_cast<float>(renderSize.height), 0.0f, 1.0f);
2234                 const VkRect2D                          scissor                                 = makeScissor(renderSize.width, renderSize.height);
2235
2236                 for (deUint32 layerNdx = 0; layerNdx < getLayerCount(); ++layerNdx)
2237                 {
2238                         const VkBufferCreateInfo                srcImageBufferInfo              = makeBufferCreateInfo(srcImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
2239                         const MovePtr<Buffer>                   srcImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, srcImageBufferInfo, MemoryRequirement::HostVisible));
2240
2241                         const VkBufferCreateInfo                dstImageBufferInfo              = makeBufferCreateInfo(dstImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
2242                         MovePtr<Buffer>                                 dstImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, dstImageBufferInfo, MemoryRequirement::HostVisible));
2243
2244                         const VkImageSubresourceRange   srcSubresourceRange             = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, SINGLE_LEVEL, 0u, SINGLE_LAYER);
2245                         const VkImageSubresourceRange   dstSubresourceRange             = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, levelNdx, SINGLE_LEVEL, layerNdx, SINGLE_LAYER);
2246
2247                         Move<VkImageView>                               dstImageView                    (makeImageView(vk, device, dstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, dstSubresourceRange, m_dstImageViewUsageKHR));
2248
2249                         de::MovePtr<Image>                              srcImage                                (new Image(vk, device, allocator, srcImageCreateInfo, MemoryRequirement::Any));
2250                         Move<VkImageView>                               srcImageView                    (makeImageView(vk, device, srcImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, srcSubresourceRange, m_srcImageViewUsageKHR));
2251
2252                         const VkSamplerCreateInfo               srcSamplerInfo                  (makeSamplerCreateInfo());
2253                         const Move<VkSampler>                   srcSampler                              = vk::createSampler(vk, device, &srcSamplerInfo);
2254                         const VkDescriptorImageInfo             descriptorSrcImage              (makeDescriptorImageInfo(*srcSampler, *srcImageView, VK_IMAGE_LAYOUT_GENERAL));
2255                         const VkDescriptorImageInfo             descriptorDstImage              (makeDescriptorImageInfo(DE_NULL, *dstImageView, VK_IMAGE_LAYOUT_GENERAL));
2256
2257                         const VkBufferImageCopy                 srcCopyRegion                   = makeBufferImageCopy(srcImageResolution.x(), srcImageResolution.y(), 0u, 0u);
2258                         const VkBufferMemoryBarrier             srcCopyBufferBarrierPre = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, srcImageBuffer->get(), 0ull, srcImageSizeInBytes);
2259                         const VkImageMemoryBarrier              srcCopyImageBarrierPre  = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, srcImage->get(), srcSubresourceRange);
2260                         const VkImageMemoryBarrier              srcCopyImageBarrierPost = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, srcImage->get(), srcSubresourceRange);
2261                         const VkBufferImageCopy                 dstCopyRegion                   = makeBufferImageCopy(dstImageResolution.x(), dstImageResolution.y(), levelNdx, layerNdx, dstImageResBlocked.x(), dstImageResBlocked.y());
2262                         const VkImageMemoryBarrier              dstInitImageBarrier             = makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, dstImage->get(), dstSubresourceRange);
2263
2264                         const VkExtent2D                                framebufferSize                 (makeExtent2D(dstImageResolution[0], dstImageResolution[1]));
2265                         const Move<VkFramebuffer>               framebuffer                             (makeFramebuffer(vk, device, *renderPass, 0, DE_NULL, framebufferSize, SINGLE_LAYER));
2266
2267                         // Upload source image data
2268                         const Allocation& alloc = srcImageBuffer->getAllocation();
2269                         deMemcpy(alloc.getHostPtr(), &m_srcData[levelNdx][layerNdx]->at(0), srcImageSizeInBytes);
2270                         flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), srcImageSizeInBytes);
2271
2272                         beginCommandBuffer(vk, *cmdBuffer);
2273                         vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
2274
2275                         // Copy buffer to image
2276                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);
2277                         vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);
2278                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &srcCopyImageBarrierPost);
2279
2280                         // Define destination image layout
2281                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &dstInitImageBarrier);
2282
2283                         beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
2284
2285                         DescriptorSetUpdateBuilder()
2286                                 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorSrcImage)
2287                                 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorDstImage)
2288                                 .update(vk, device);
2289
2290                         vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
2291                         vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &m_vertexBuffer->get(), &m_vertexBufferOffset);
2292
2293                         vk.cmdSetViewport(*cmdBuffer, 0u, 1u, &viewport);
2294                         vk.cmdSetScissor(*cmdBuffer, 0u, 1u, &scissor);
2295
2296                         vk.cmdDraw(*cmdBuffer, (deUint32)m_vertexCount, 1, 0, 0);
2297
2298                         vk.cmdEndRenderPass(*cmdBuffer);
2299
2300                         const VkImageMemoryBarrier prepareForTransferBarrier = makeImageMemoryBarrier(
2301                                 VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
2302                                 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
2303                                 dstImage->get(), dstSubresourceRange);
2304
2305                         const VkBufferMemoryBarrier copyBarrier = makeBufferMemoryBarrier(
2306                                 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
2307                                 dstImageBuffer->get(), 0ull, dstImageSizeInBytes);
2308
2309                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &prepareForTransferBarrier);
2310                         vk.cmdCopyImageToBuffer(*cmdBuffer, dstImage->get(), VK_IMAGE_LAYOUT_GENERAL, dstImageBuffer->get(), 1u, &dstCopyRegion);
2311                         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &copyBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
2312
2313                         endCommandBuffer(vk, *cmdBuffer);
2314
2315                         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
2316
2317                         const Allocation& dstImageBufferAlloc = dstImageBuffer->getAllocation();
2318                         invalidateMappedMemoryRange(vk, device, dstImageBufferAlloc.getMemory(), dstImageBufferAlloc.getOffset(), dstImageSizeInBytes);
2319                         deMemcpy(&m_dstData[levelNdx][layerNdx]->at(0), dstImageBufferAlloc.getHostPtr(), dstImageSizeInBytes);
2320                 }
2321         }
2322
2323         m_compressedImage = dstImage;
2324 }
2325
2326 class TexelViewCompatibleCase : public TestCase
2327 {
2328 public:
2329                                                         TexelViewCompatibleCase         (TestContext&                           testCtx,
2330                                                                                                                  const std::string&                     name,
2331                                                                                                                  const std::string&                     desc,
2332                                                                                                                  const TestParameters&          parameters);
2333         void                                    initPrograms                            (SourceCollections&                     programCollection) const;
2334         TestInstance*                   createInstance                          (Context&                                       context) const;
2335 protected:
2336         const TestParameters    m_parameters;
2337 };
2338
2339 TexelViewCompatibleCase::TexelViewCompatibleCase (TestContext& testCtx, const std::string& name, const std::string& desc, const TestParameters& parameters)
2340         : TestCase                              (testCtx, name, desc)
2341         , m_parameters                  (parameters)
2342 {
2343 }
2344
2345 void TexelViewCompatibleCase::initPrograms (vk::SourceCollections&      programCollection) const
2346 {
2347         DE_ASSERT(m_parameters.size.x() > 0);
2348         DE_ASSERT(m_parameters.size.y() > 0);
2349
2350         switch (m_parameters.shader)
2351         {
2352                 case SHADER_TYPE_COMPUTE:
2353                 {
2354                         const std::string       imageTypeStr            = getShaderImageType(mapVkFormat(m_parameters.formatUncompressed), m_parameters.imageType);
2355                         const std::string       formatQualifierStr      = getShaderImageFormatQualifier(mapVkFormat(m_parameters.formatUncompressed));
2356                         std::ostringstream      src;
2357                         std::ostringstream      src_decompress;
2358
2359                         src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
2360                                 << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n\n";
2361                         src_decompress << src.str();
2362
2363                         switch(m_parameters.operation)
2364                         {
2365                                 case OPERATION_IMAGE_LOAD:
2366                                 {
2367                                         src << "layout (binding = 0, "<<formatQualifierStr<<") readonly uniform "<<imageTypeStr<<" u_image0;\n"
2368                                                 << "layout (binding = 1, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" u_image1;\n\n"
2369                                                 << "void main (void)\n"
2370                                                 << "{\n"
2371                                                 << "    ivec2 pos = ivec2(gl_GlobalInvocationID.xy);\n"
2372                                                 << "    imageStore(u_image1, pos, imageLoad(u_image0, pos));\n"
2373                                                 << "}\n";
2374
2375                                         break;
2376                                 }
2377
2378                                 case OPERATION_TEXEL_FETCH:
2379                                 {
2380                                         src << "layout (binding = 0) uniform "<<getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(m_parameters.imageType))<<" u_image0;\n"
2381                                                 << "layout (binding = 1, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" u_image1;\n\n"
2382                                                 << "void main (void)\n"
2383                                                 << "{\n"
2384                                                 << "    ivec3 pos = ivec3(gl_GlobalInvocationID.xyz);\n"
2385                                                 << "    imageStore(u_image1, pos.xy, texelFetch(u_image0, pos.xy, pos.z));\n"
2386                                                 << "}\n";
2387
2388                                         break;
2389                                 }
2390
2391                                 case OPERATION_TEXTURE:
2392                                 {
2393                                         src << "layout (binding = 0) uniform "<<getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(m_parameters.imageType))<<" u_image0;\n"
2394                                                 << "layout (binding = 1, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" u_image1;\n\n"
2395                                                 << "void main (void)\n"
2396                                                 << "{\n"
2397                                                 << "    const vec2 pixels_resolution = vec2(gl_NumWorkGroups.x - 1, gl_NumWorkGroups.y - 1);\n"
2398                                                 << "    const ivec2 pos = ivec2(gl_GlobalInvocationID.xy);\n"
2399                                                 << "    const vec2 coord = vec2(gl_GlobalInvocationID.xy) / vec2(pixels_resolution);\n"
2400                                                 << "    imageStore(u_image1, pos, texture(u_image0, coord));\n"
2401                                                 << "}\n";
2402
2403                                         break;
2404                                 }
2405
2406                                 case OPERATION_IMAGE_STORE:
2407                                 {
2408                                         src << "layout (binding = 0, "<<formatQualifierStr<<") uniform "<<imageTypeStr<<"           u_image0;\n"
2409                                                 << "layout (binding = 1, "<<formatQualifierStr<<") readonly uniform "<<imageTypeStr<<"  u_image1;\n"
2410                                                 << "layout (binding = 2, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" u_image2;\n\n"
2411                                                 << "void main (void)\n"
2412                                                 << "{\n"
2413                                                 << "    ivec2 pos = ivec2(gl_GlobalInvocationID.xy);\n"
2414                                                 << "    imageStore(u_image0, pos, imageLoad(u_image1, pos));\n"
2415                                                 << "    imageStore(u_image2, pos, imageLoad(u_image0, pos));\n"
2416                                                 << "}\n";
2417
2418                                         break;
2419                                 }
2420
2421                                 default:
2422                                         DE_ASSERT(false);
2423                         }
2424
2425                         src_decompress  << "layout (binding = 0) uniform "<<getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(m_parameters.imageType))<<" compressed_result;\n"
2426                                                         << "layout (binding = 1) uniform "<<getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(m_parameters.imageType))<<" compressed_reference;\n"
2427                                                         << "layout (binding = 2, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" decompressed_result;\n"
2428                                                         << "layout (binding = 3, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" decompressed_reference;\n\n"
2429                                                         << "void main (void)\n"
2430                                                         << "{\n"
2431                                                         << "    const vec2 pixels_resolution = vec2(gl_NumWorkGroups.xy);\n"
2432                                                         << "    const vec2 cord = vec2(gl_GlobalInvocationID.xy) / vec2(pixels_resolution);\n"
2433                                                         << "    const ivec2 pos = ivec2(gl_GlobalInvocationID.xy); \n"
2434                                                         << "    imageStore(decompressed_result, pos, texture(compressed_result, cord));\n"
2435                                                         << "    imageStore(decompressed_reference, pos, texture(compressed_reference, cord));\n"
2436                                                         << "}\n";
2437                         programCollection.glslSources.add("comp") << glu::ComputeSource(src.str());
2438                         programCollection.glslSources.add("decompress") << glu::ComputeSource(src_decompress.str());
2439
2440                         break;
2441                 }
2442
2443                 case SHADER_TYPE_FRAGMENT:
2444                 {
2445                         ImageType       imageTypeForFS = (m_parameters.imageType == IMAGE_TYPE_2D_ARRAY) ? IMAGE_TYPE_2D : m_parameters.imageType;
2446
2447                         // Vertex shader
2448                         {
2449                                 std::ostringstream src;
2450                                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
2451                                         << "layout(location = 0) in vec4 v_in_position;\n"
2452                                         << "\n"
2453                                         << "void main (void)\n"
2454                                         << "{\n"
2455                                         << "    gl_Position = v_in_position;\n"
2456                                         << "}\n";
2457
2458                                 programCollection.glslSources.add("vert") << glu::VertexSource(src.str());
2459                         }
2460
2461                         // Fragment shader
2462                         {
2463                                 switch(m_parameters.operation)
2464                                 {
2465                                         case OPERATION_ATTACHMENT_READ:
2466                                         case OPERATION_ATTACHMENT_WRITE:
2467                                         {
2468                                                 std::ostringstream      src;
2469
2470                                                 const std::string       dstTypeStr      = getGlslFormatType(m_parameters.formatUncompressed);
2471                                                 const std::string       srcTypeStr      = getGlslInputFormatType(m_parameters.formatUncompressed);
2472
2473                                                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
2474                                                         << "precision highp int;\n"
2475                                                         << "precision highp float;\n"
2476                                                         << "\n"
2477                                                         << "layout (location = 0) out highp " << dstTypeStr << " o_color;\n"
2478                                                         << "layout (input_attachment_index = 0, set = 0, binding = 0) uniform highp " << srcTypeStr << " inputImage1;\n"
2479                                                         << "\n"
2480                                                         << "void main (void)\n"
2481                                                         << "{\n"
2482                                                         << "    o_color = " << dstTypeStr << "(subpassLoad(inputImage1));\n"
2483                                                         << "}\n";
2484
2485                                                 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str());
2486
2487                                                 break;
2488                                         }
2489
2490                                         case OPERATION_TEXTURE_READ:
2491                                         case OPERATION_TEXTURE_WRITE:
2492                                         {
2493                                                 std::ostringstream      src;
2494
2495                                                 const std::string       srcSamplerTypeStr               = getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(imageTypeForFS));
2496                                                 const std::string       dstImageTypeStr                 = getShaderImageType(mapVkFormat(m_parameters.formatUncompressed), imageTypeForFS);
2497                                                 const std::string       dstFormatQualifierStr   = getShaderImageFormatQualifier(mapVkFormat(m_parameters.formatUncompressed));
2498
2499                                                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
2500                                                         << "layout (binding = 0) uniform " << srcSamplerTypeStr << " u_imageIn;\n"
2501                                                         << "layout (binding = 1, " << dstFormatQualifierStr << ") writeonly uniform " << dstImageTypeStr << " u_imageOut;\n"
2502                                                         << "\n"
2503                                                         << "void main (void)\n"
2504                                                         << "{\n"
2505                                                         << "    const ivec2 out_pos = ivec2(gl_FragCoord.xy);\n"
2506                                                         << "    const ivec2 pixels_resolution = ivec2(textureSize(u_imageIn, 0)) - ivec2(1,1);\n"
2507                                                         << "    const vec2 in_pos = vec2(out_pos) / vec2(pixels_resolution);\n"
2508                                                         << "    imageStore(u_imageOut, out_pos, texture(u_imageIn, in_pos));\n"
2509                                                         << "}\n";
2510
2511                                                 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str());
2512
2513                                                 break;
2514                                         }
2515
2516                                         default:
2517                                                 DE_ASSERT(false);
2518                                 }
2519                         }
2520
2521                         // Verification fragment shader
2522                         {
2523                                 std::ostringstream      src;
2524
2525                                 const std::string       samplerType                     = getGlslSamplerType(mapVkFormat(m_parameters.formatForVerify), mapImageViewType(imageTypeForFS));
2526                                 const std::string       imageTypeStr            = getShaderImageType(mapVkFormat(m_parameters.formatForVerify), imageTypeForFS);
2527                                 const std::string       formatQualifierStr      = getShaderImageFormatQualifier(mapVkFormat(m_parameters.formatForVerify));
2528
2529                                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
2530                                         << "layout (binding = 0) uniform " << samplerType << " u_imageIn0;\n"
2531                                         << "layout (binding = 1) uniform " << samplerType << " u_imageIn1;\n"
2532                                         << "layout (binding = 2, " << formatQualifierStr << ") writeonly uniform " << imageTypeStr << " u_imageOut0;\n"
2533                                         << "layout (binding = 3, " << formatQualifierStr << ") writeonly uniform " << imageTypeStr << " u_imageOut1;\n"
2534                                         << "\n"
2535                                         << "void main (void)\n"
2536                                         << "{\n"
2537                                         << "    const ivec2 out_pos = ivec2(gl_FragCoord.xy);\n"
2538                                         << "\n"
2539                                         << "    const ivec2 pixels_resolution0 = ivec2(textureSize(u_imageIn0, 0)) - ivec2(1,1);\n"
2540                                         << "    const vec2 in_pos0 = vec2(out_pos) / vec2(pixels_resolution0);\n"
2541                                         << "    imageStore(u_imageOut0, out_pos, texture(u_imageIn0, in_pos0));\n"
2542                                         << "\n"
2543                                         << "    const ivec2 pixels_resolution1 = ivec2(textureSize(u_imageIn1, 0)) - ivec2(1,1);\n"
2544                                         << "    const vec2 in_pos1 = vec2(out_pos) / vec2(pixels_resolution1);\n"
2545                                         << "    imageStore(u_imageOut1, out_pos, texture(u_imageIn1, in_pos1));\n"
2546                                         << "}\n";
2547
2548                                 programCollection.glslSources.add("frag_verify") << glu::FragmentSource(src.str());
2549                         }
2550
2551                         break;
2552                 }
2553
2554                 default:
2555                         DE_ASSERT(false);
2556         }
2557 }
2558
2559 TestInstance* TexelViewCompatibleCase::createInstance (Context& context) const
2560 {
2561         const VkPhysicalDevice                  physicalDevice                  = context.getPhysicalDevice();
2562         const InstanceInterface&                vk                                              = context.getInstanceInterface();
2563
2564         if (!m_parameters.useMipmaps)
2565         {
2566                 DE_ASSERT(getNumLayers(m_parameters.imageType, m_parameters.size)     == 1u);
2567                 DE_ASSERT(getLayerSize(m_parameters.imageType, m_parameters.size).z() == 1u);
2568         }
2569
2570         DE_ASSERT(getLayerSize(m_parameters.imageType, m_parameters.size).x() >  0u);
2571         DE_ASSERT(getLayerSize(m_parameters.imageType, m_parameters.size).y() >  0u);
2572
2573         if (std::find(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance2") == context.getDeviceExtensions().end())
2574                 TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance2 not supported");
2575
2576         {
2577                 VkImageFormatProperties imageFormatProperties;
2578
2579                 if (VK_ERROR_FORMAT_NOT_SUPPORTED == vk.getPhysicalDeviceImageFormatProperties(physicalDevice, m_parameters.formatUncompressed,
2580                                                                                                 mapImageType(m_parameters.imageType), VK_IMAGE_TILING_OPTIMAL,
2581                                                                                                 m_parameters.uncompressedImageUsage, 0u, &imageFormatProperties))
2582                         TCU_THROW(NotSupportedError, "Operation not supported with this image format");
2583
2584                 if (VK_ERROR_FORMAT_NOT_SUPPORTED == vk.getPhysicalDeviceImageFormatProperties(physicalDevice, m_parameters.formatCompressed,
2585                                                                                                 mapImageType(m_parameters.imageType), VK_IMAGE_TILING_OPTIMAL,
2586                                                                                                 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
2587                                                                                                 VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR,
2588                                                                                                 &imageFormatProperties))
2589                         TCU_THROW(NotSupportedError, "Operation not supported with this image format");
2590         }
2591
2592         {
2593                 const VkPhysicalDeviceFeatures  physicalDeviceFeatures  = getPhysicalDeviceFeatures (vk, physicalDevice);
2594
2595                 if (deInRange32(m_parameters.formatCompressed, VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_BC7_SRGB_BLOCK) &&
2596                         !physicalDeviceFeatures.textureCompressionBC)
2597                         TCU_THROW(NotSupportedError, "textureCompressionBC not supported");
2598
2599                 if (deInRange32(m_parameters.formatCompressed, VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, VK_FORMAT_EAC_R11G11_SNORM_BLOCK) &&
2600                         !physicalDeviceFeatures.textureCompressionETC2)
2601                         TCU_THROW(NotSupportedError, "textureCompressionETC2 not supported");
2602
2603                 if (deInRange32(m_parameters.formatCompressed, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_FORMAT_ASTC_12x12_SRGB_BLOCK) &&
2604                         !physicalDeviceFeatures.textureCompressionASTC_LDR)
2605                         TCU_THROW(NotSupportedError, "textureCompressionASTC_LDR not supported");
2606         }
2607
2608         switch (m_parameters.shader)
2609         {
2610                 case SHADER_TYPE_COMPUTE:
2611                 {
2612                         switch (m_parameters.operation)
2613                         {
2614                                 case OPERATION_IMAGE_LOAD:
2615                                 case OPERATION_TEXEL_FETCH:
2616                                 case OPERATION_TEXTURE:
2617                                         return new BasicComputeTestInstance(context, m_parameters);
2618                                 case OPERATION_IMAGE_STORE:
2619                                         return new ImageStoreComputeTestInstance(context, m_parameters);
2620                                 default:
2621                                         TCU_THROW(InternalError, "Impossible");
2622                         }
2623                 }
2624
2625                 case SHADER_TYPE_FRAGMENT:
2626                 {
2627                         switch (m_parameters.operation)
2628                         {
2629                                 case OPERATION_ATTACHMENT_READ:
2630                                 case OPERATION_ATTACHMENT_WRITE:
2631                                         return new GraphicsAttachmentsTestInstance(context, m_parameters);
2632
2633                                 case OPERATION_TEXTURE_READ:
2634                                 case OPERATION_TEXTURE_WRITE:
2635                                         return new GraphicsTextureTestInstance(context, m_parameters);
2636
2637                                 default:
2638                                         TCU_THROW(InternalError, "Impossible");
2639                         }
2640                 }
2641
2642                 default:
2643                         TCU_THROW(InternalError, "Impossible");
2644         }
2645 }
2646
2647 } // anonymous ns
2648
2649 static tcu::UVec3 getUnniceResolution(const VkFormat format, const deUint32 layers)
2650 {
2651         const deUint32  unniceMipmapTextureSize[]       = { 1, 1, 1, 8, 22, 48, 117, 275, 604, 208, 611, 274, 1211 };
2652         const deUint32  baseTextureWidth                        = unniceMipmapTextureSize[getBlockWidth(format)];
2653         const deUint32  baseTextureHeight                       = unniceMipmapTextureSize[getBlockHeight(format)];
2654         const deUint32  baseTextureWidthLevels          = deLog2Floor32(baseTextureWidth);
2655         const deUint32  baseTextureHeightLevels         = deLog2Floor32(baseTextureHeight);
2656         const deUint32  widthMultiplier                         = (baseTextureHeightLevels > baseTextureWidthLevels) ? 1u << (baseTextureHeightLevels - baseTextureWidthLevels) : 1u;
2657         const deUint32  heightMultiplier                        = (baseTextureWidthLevels > baseTextureHeightLevels) ? 1u << (baseTextureWidthLevels - baseTextureHeightLevels) : 1u;
2658         const deUint32  width                                           = baseTextureWidth * widthMultiplier;
2659         const deUint32  height                                          = baseTextureHeight * heightMultiplier;
2660
2661         // Number of levels should be same on both axises
2662         DE_ASSERT(deLog2Floor32(width) == deLog2Floor32(height));
2663
2664         return tcu::UVec3(width, height, layers);
2665 }
2666
2667 tcu::TestCaseGroup* createImageCompressionTranscodingTests (tcu::TestContext& testCtx)
2668 {
2669         struct FormatsArray
2670         {
2671                 const VkFormat* formats;
2672                 deUint32                count;
2673         };
2674
2675         const bool                                      mipmapness[]                                                                    =
2676         {
2677                 false,
2678                 true,
2679         };
2680
2681         const std::string                       pipelineName[SHADER_TYPE_LAST]                                  =
2682         {
2683                 "compute",
2684                 "graphic",
2685         };
2686
2687         const std::string                       mipmanpnessName[DE_LENGTH_OF_ARRAY(mipmapness)] =
2688         {
2689                 "basic",
2690                 "extended",
2691         };
2692
2693         const std::string                       operationName[OPERATION_LAST]                                   =
2694         {
2695                 "image_load",
2696                 "texel_fetch",
2697                 "texture",
2698                 "image_store",
2699                 "attachment_read",
2700                 "attachment_write",
2701                 "texture_read",
2702                 "texture_write",
2703         };
2704
2705         const VkImageUsageFlags         baseImageUsageFlagSet                                                   = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2706         const VkImageUsageFlags         compressedImageUsageFlags[OPERATION_LAST]               =
2707         {
2708                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_STORAGE_BIT),                                                                                  // "image_load"
2709                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT),                             // "texel_fetch"
2710                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT),                             // "texture"
2711                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT),                             // "image_store"
2712                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT),    // "attachment_read"
2713                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT),    // "attachment_write"
2714                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT),                                                                                  // "texture_read"
2715                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT),                             // "texture_write"
2716         };
2717
2718         const VkImageUsageFlags         compressedImageViewUsageFlags[OPERATION_LAST]   =
2719         {
2720                 compressedImageUsageFlags[0],                                                                                                                                                                                                   //"image_load"
2721                 compressedImageUsageFlags[1],                                                                                                                                                                                                   //"texel_fetch"
2722                 compressedImageUsageFlags[2],                                                                                                                                                                                                   //"texture"
2723                 compressedImageUsageFlags[3],                                                                                                                                                                                                   //"image_store"
2724                 compressedImageUsageFlags[4],                                                                                                                                                                                                   //"attachment_read"
2725                 compressedImageUsageFlags[5] | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,                                                                                                                             //"attachment_write"
2726                 compressedImageUsageFlags[6],                                                                                                                                                                                                   //"texture_read"
2727                 compressedImageUsageFlags[7],                                                                                                                                                                                                   //"texture_write"
2728         };
2729
2730         const VkImageUsageFlags         uncompressedImageUsageFlags[OPERATION_LAST]             =
2731         {
2732                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_STORAGE_BIT),                                                                                  //"image_load"
2733                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT),                             //"texel_fetch"
2734                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT),                             //"texture"
2735                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT),                             //"image_store"
2736                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT),    //"attachment_read"
2737                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT),                                                                 //"attachment_write"
2738                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT),                             //"texture_read"
2739                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT),                                                                                  //"texture_write"
2740         };
2741
2742         const VkFormat                          compressedFormats64bit[]                                                =
2743         {
2744                 VK_FORMAT_BC1_RGB_UNORM_BLOCK,
2745                 VK_FORMAT_BC1_RGB_SRGB_BLOCK,
2746                 VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
2747                 VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
2748                 VK_FORMAT_BC4_UNORM_BLOCK,
2749                 VK_FORMAT_BC4_SNORM_BLOCK,
2750                 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
2751                 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
2752                 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
2753                 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
2754                 VK_FORMAT_EAC_R11_UNORM_BLOCK,
2755                 VK_FORMAT_EAC_R11_SNORM_BLOCK,
2756         };
2757
2758         const VkFormat                          compressedFormats128bit[]                                               =
2759         {
2760                 VK_FORMAT_BC2_UNORM_BLOCK,
2761                 VK_FORMAT_BC2_SRGB_BLOCK,
2762                 VK_FORMAT_BC3_UNORM_BLOCK,
2763                 VK_FORMAT_BC3_SRGB_BLOCK,
2764                 VK_FORMAT_BC5_UNORM_BLOCK,
2765                 VK_FORMAT_BC5_SNORM_BLOCK,
2766                 VK_FORMAT_BC6H_UFLOAT_BLOCK,
2767                 VK_FORMAT_BC6H_SFLOAT_BLOCK,
2768                 VK_FORMAT_BC7_UNORM_BLOCK,
2769                 VK_FORMAT_BC7_SRGB_BLOCK,
2770                 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
2771                 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
2772                 VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
2773                 VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
2774                 VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
2775                 VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
2776                 VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
2777                 VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
2778                 VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
2779                 VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
2780                 VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
2781                 VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
2782                 VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
2783                 VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
2784                 VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
2785                 VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
2786                 VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
2787                 VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
2788                 VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
2789                 VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
2790                 VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
2791                 VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
2792                 VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
2793                 VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
2794                 VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
2795                 VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
2796                 VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
2797                 VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
2798                 VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
2799                 VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
2800                 VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
2801                 VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
2802         };
2803
2804         const VkFormat                          uncompressedFormats64bit[]                                              =
2805         {
2806                 VK_FORMAT_R16G16B16A16_UNORM,
2807                 VK_FORMAT_R16G16B16A16_SNORM,
2808                 VK_FORMAT_R16G16B16A16_USCALED,
2809                 VK_FORMAT_R16G16B16A16_SSCALED,
2810                 VK_FORMAT_R16G16B16A16_UINT,
2811                 VK_FORMAT_R16G16B16A16_SINT,
2812                 VK_FORMAT_R16G16B16A16_SFLOAT,
2813                 VK_FORMAT_R32G32_UINT,
2814                 VK_FORMAT_R32G32_SINT,
2815                 VK_FORMAT_R32G32_SFLOAT,
2816                 //VK_FORMAT_R64_UINT, remove from the test it couln'd not be use
2817                 //VK_FORMAT_R64_SINT, remove from the test it couln'd not be use
2818                 //VK_FORMAT_R64_SFLOAT, remove from the test it couln'd not be use
2819         };
2820
2821         const VkFormat                          uncompressedFormats128bit[]                                             =
2822         {
2823                 VK_FORMAT_R32G32B32A32_UINT,
2824                 VK_FORMAT_R32G32B32A32_SINT,
2825                 VK_FORMAT_R32G32B32A32_SFLOAT,
2826                 //VK_FORMAT_R64G64_UINT, remove from the test it couln'd not be use
2827                 //VK_FORMAT_R64G64_SINT, remove from the test it couln'd not be use
2828                 //VK_FORMAT_R64G64_SFLOAT, remove from the test it couln'd not be use
2829         };
2830
2831         const FormatsArray                      formatsCompressedSets[]                                                 =
2832         {
2833                 {
2834                         compressedFormats64bit,
2835                         DE_LENGTH_OF_ARRAY(compressedFormats64bit)
2836                 },
2837                 {
2838                         compressedFormats128bit,
2839                         DE_LENGTH_OF_ARRAY(compressedFormats128bit)
2840                 },
2841         };
2842
2843         const FormatsArray                      formatsUncompressedSets[]                                               =
2844         {
2845                 {
2846                         uncompressedFormats64bit,
2847                         DE_LENGTH_OF_ARRAY(uncompressedFormats64bit)
2848                 },
2849                 {
2850                         uncompressedFormats128bit,
2851                         DE_LENGTH_OF_ARRAY(uncompressedFormats128bit)
2852                 },
2853         };
2854
2855         DE_ASSERT(DE_LENGTH_OF_ARRAY(formatsCompressedSets) == DE_LENGTH_OF_ARRAY(formatsUncompressedSets));
2856
2857         MovePtr<tcu::TestCaseGroup>     texelViewCompatibleTests                                                        (new tcu::TestCaseGroup(testCtx, "texel_view_compatible", "Texel view compatible cases"));
2858
2859         for (int shaderType = SHADER_TYPE_COMPUTE; shaderType < SHADER_TYPE_LAST; ++shaderType)
2860         {
2861                 MovePtr<tcu::TestCaseGroup>     pipelineTypeGroup       (new tcu::TestCaseGroup(testCtx, pipelineName[shaderType].c_str(), ""));
2862
2863                 for (int mipmapTestNdx = 0; mipmapTestNdx < DE_LENGTH_OF_ARRAY(mipmapness); mipmapTestNdx++)
2864                 {
2865                         const bool mipmapTest = mipmapness[mipmapTestNdx];
2866
2867                         MovePtr<tcu::TestCaseGroup>     mipmapTypeGroup (new tcu::TestCaseGroup(testCtx, mipmanpnessName[mipmapTestNdx].c_str(), ""));
2868
2869                         for (int operationNdx = OPERATION_IMAGE_LOAD; operationNdx < OPERATION_LAST; ++operationNdx)
2870                         {
2871                                 if (shaderType != SHADER_TYPE_FRAGMENT && deInRange32(operationNdx, OPERATION_ATTACHMENT_READ, OPERATION_TEXTURE_WRITE))
2872                                         continue;
2873
2874                                 if (shaderType != SHADER_TYPE_COMPUTE && deInRange32(operationNdx, OPERATION_IMAGE_LOAD, OPERATION_IMAGE_STORE))
2875                                         continue;
2876
2877                                 MovePtr<tcu::TestCaseGroup>     imageOperationGroup     (new tcu::TestCaseGroup(testCtx, operationName[operationNdx].c_str(), ""));
2878
2879                                 // Iterate through bitness groups (64 bit, 128 bit, etc)
2880                                 for (deUint32 formatBitnessGroup = 0; formatBitnessGroup < DE_LENGTH_OF_ARRAY(formatsCompressedSets); ++formatBitnessGroup)
2881                                 {
2882                                         for (deUint32 formatCompressedNdx = 0; formatCompressedNdx < formatsCompressedSets[formatBitnessGroup].count; ++formatCompressedNdx)
2883                                         {
2884                                                 const VkFormat                          formatCompressed                        = formatsCompressedSets[formatBitnessGroup].formats[formatCompressedNdx];
2885                                                 const std::string                       compressedFormatGroupName       = getFormatShortString(formatCompressed);
2886                                                 MovePtr<tcu::TestCaseGroup>     compressedFormatGroup           (new tcu::TestCaseGroup(testCtx, compressedFormatGroupName.c_str(), ""));
2887
2888                                                 for (deUint32 formatUncompressedNdx = 0; formatUncompressedNdx < formatsUncompressedSets[formatBitnessGroup].count; ++formatUncompressedNdx)
2889                                                 {
2890                                                         const VkFormat                  formatUncompressed                      = formatsUncompressedSets[formatBitnessGroup].formats[formatUncompressedNdx];
2891                                                         const std::string               uncompressedFormatGroupName     = getFormatShortString(formatUncompressed);
2892                                                         const TestParameters    parameters                                      =
2893                                                         {
2894                                                                 static_cast<Operation>(operationNdx),
2895                                                                 static_cast<ShaderType>(shaderType),
2896                                                                 mipmapTest ? getUnniceResolution(formatCompressed, 3u) : UVec3(64u, 64u, 1u),
2897                                                                 IMAGE_TYPE_2D,
2898                                                                 formatCompressed,
2899                                                                 formatUncompressed,
2900                                                                 (operationNdx == OPERATION_IMAGE_STORE) ? 3u : 2u,
2901                                                                 compressedImageUsageFlags[operationNdx],
2902                                                                 compressedImageViewUsageFlags[operationNdx],
2903                                                                 uncompressedImageUsageFlags[operationNdx],
2904                                                                 mipmapTest,
2905                                                                 VK_FORMAT_R8G8B8A8_UNORM
2906                                                         };
2907
2908                                                         compressedFormatGroup->addChild(new TexelViewCompatibleCase(testCtx, uncompressedFormatGroupName, "", parameters));
2909                                                 }
2910
2911                                                 imageOperationGroup->addChild(compressedFormatGroup.release());
2912                                         }
2913                                 }
2914
2915                                 mipmapTypeGroup->addChild(imageOperationGroup.release());
2916                         }
2917
2918                         pipelineTypeGroup->addChild(mipmapTypeGroup.release());
2919                 }
2920
2921                 texelViewCompatibleTests->addChild(pipelineTypeGroup.release());
2922         }
2923
2924         return texelViewCompatibleTests.release();
2925 }
2926
2927 } // image
2928 } // vkt