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 #include <iomanip>
  54
  55 using namespace vk;
  56 namespace vkt
  57 {
  58 namespace image
  59 {
  60 namespace
  61 {
  62 using std::string;
  63 using std::vector;
  64 using tcu::TestContext;
  65 using tcu::TestStatus;
  66 using tcu::UVec3;
  67 using tcu::CompressedTexFormat;
  68 using tcu::CompressedTexture;
  69 using tcu::Resource;
  70 using tcu::Archive;
  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
  78 enum ShaderType
  79 {
  80         SHADER_TYPE_COMPUTE,
  81         SHADER_TYPE_FRAGMENT,
  82         SHADER_TYPE_LAST
  83 };
  84
  85 enum Operation
  86 {
  87         OPERATION_IMAGE_LOAD,
  88         OPERATION_TEXEL_FETCH,
  89         OPERATION_TEXTURE,
  90         OPERATION_IMAGE_STORE,
  91         OPERATION_ATTACHMENT_READ,
  92         OPERATION_ATTACHMENT_WRITE,
  93         OPERATION_TEXTURE_READ,
  94         OPERATION_TEXTURE_WRITE,
  95         OPERATION_LAST
  96 };
  97
  98 struct TestParameters
  99 {
 100         Operation                       operation;
 101         ShaderType                      shader;
 102         UVec3                           size;
 103         ImageType                       imageType;
 104         VkFormat                        formatCompressed;
 105         VkFormat                        formatUncompressed;
 106         deUint32                        imagesCount;
 107         VkImageUsageFlags       compressedImageUsage;
 108         VkImageUsageFlags       uncompressedImageUsage;
 109         bool                            useMipmaps;
 110         VkFormat                        formatForVerify;
 111 };
 112
 113 template<typename T>
 114 inline SharedPtr<Move<T> > makeVkSharedPtr (Move<T> move)
 115 {
 116         return SharedPtr<Move<T> >(new vk::Move<T>(move));
 117 }
 118
 119 template<typename T>
 120 inline SharedPtr<MovePtr<T> > makeVkSharedPtr (MovePtr<T> movePtr)
 121 {
 122         return SharedPtr<MovePtr<T> >(new MovePtr<T>(movePtr));
 123 }
 124
 125 class BasicTranscodingTestInstance : public TestInstance
 126 {
 127 public:
 128                                                         BasicTranscodingTestInstance    (Context&                               contex,
 129                                                                                                                          const TestParameters&  parameters);
 130         virtual TestStatus              iterate                                                 (void) = 0;
 131 protected:
 132         void                                    generateData                                    (deUint8*                               toFill,
 133                                                                                                                          size_t                                 size,
 134                                                                                                                          const VkFormat                 format = VK_FORMAT_UNDEFINED);
 135         const TestParameters    m_parameters;
 136 };
 137
 138 BasicTranscodingTestInstance::BasicTranscodingTestInstance (Context& context, const TestParameters& parameters)
 139         : TestInstance  (context)
 140         , m_parameters  (parameters)
 141 {
 142 }
 143
 144 void BasicTranscodingTestInstance::generateData (deUint8* toFill, size_t size, const VkFormat format)
 145 {
 146         const deUint8 pattern[] =
 147         {
 148                 // 64-bit values
 149                 0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22,
 150                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 151                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
 152                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
 153                 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
 154                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
 155                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
 156                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00,
 157                 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00,
 158                 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
 159                 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,         // Positive infinity
 160                 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,         // Negative infinity
 161                 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,         // Start of a signalling NaN (NANS)
 162                 0x7F, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,         // End of a signalling NaN (NANS)
 163                 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,         // Start of a signalling NaN (NANS)
 164                 0xFF, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,         // End of a signalling NaN (NANS)
 165                 0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,         // Start of a quiet NaN (NANQ)
 166                 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,         // End of of a quiet NaN (NANQ)
 167                 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,         // Start of a quiet NaN (NANQ)
 168                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,         // End of a quiet NaN (NANQ)
 169                 // 32-bit values
 170                 0x7F, 0x80, 0x00, 0x00,                                                         // Positive infinity
 171                 0xFF, 0x80, 0x00, 0x00,                                                         // Negative infinity
 172                 0x7F, 0x80, 0x00, 0x01,                                                         // Start of a signalling NaN (NANS)
 173                 0x7F, 0xBF, 0xFF, 0xFF,                                                         // End of a signalling NaN (NANS)
 174                 0xFF, 0x80, 0x00, 0x01,                                                         // Start of a signalling NaN (NANS)
 175                 0xFF, 0xBF, 0xFF, 0xFF,                                                         // End of a signalling NaN (NANS)
 176                 0x7F, 0xC0, 0x00, 0x00,                                                         // Start of a quiet NaN (NANQ)
 177                 0x7F, 0xFF, 0xFF, 0xFF,                                                         // End of of a quiet NaN (NANQ)
 178                 0xFF, 0xC0, 0x00, 0x00,                                                         // Start of a quiet NaN (NANQ)
 179                 0xFF, 0xFF, 0xFF, 0xFF,                                                         // End of a quiet NaN (NANQ)
 180                 0xAA, 0xAA, 0xAA, 0xAA,
 181                 0x55, 0x55, 0x55, 0x55,
 182         };
 183
 184         deUint8*        start           = toFill;
 185         size_t          sizeToRnd       = size;
 186
 187         // Pattern part
 188         if (size >= 2 * sizeof(pattern))
 189         {
 190                 // Rotated pattern
 191                 for (size_t i = 0; i < sizeof(pattern); i++)
 192                         start[sizeof(pattern) - i - 1] = pattern[i];
 193
 194                 start           += sizeof(pattern);
 195                 sizeToRnd       -= sizeof(pattern);
 196
 197                 // Direct pattern
 198                 deMemcpy(start, pattern, sizeof(pattern));
 199
 200                 start           += sizeof(pattern);
 201                 sizeToRnd       -= sizeof(pattern);
 202         }
 203
 204         // Random part
 205         {
 206                 DE_ASSERT(sizeToRnd % sizeof(deUint32) == 0);
 207
 208                 deUint32*       start32         = reinterpret_cast<deUint32*>(start);
 209                 size_t          sizeToRnd32     = sizeToRnd / sizeof(deUint32);
 210                 Random          rnd                     (static_cast<deUint32>(format));
 211
 212                 for (size_t i = 0; i < sizeToRnd32; i++)
 213                         start32[i] = rnd.getUint32();
 214         }
 215
 216         {
 217                 // Remove certain values that may not be preserved based on the uncompressed view format
 218                 if (isSnormFormat(m_parameters.formatUncompressed))
 219                 {
 220                         for (size_t i = 0; i < size; i += 2)
 221                         {
 222                                 // SNORM fix: due to write operation in SNORM format
 223                                 // replaces 0x00 0x80 to 0x01 0x80
 224                                 if (toFill[i] == 0x00 && toFill[i+1] == 0x80)
 225                                         toFill[i+1] = 0x81;
 226                         }
 227                 }
 228                 else if (isFloatFormat(m_parameters.formatUncompressed))
 229                 {
 230                         tcu::TextureFormat textureFormat = mapVkFormat(m_parameters.formatUncompressed);
 231
 232                         if (textureFormat.type == tcu::TextureFormat::HALF_FLOAT)
 233                         {
 234                                 for (size_t i = 0; i < size; i += 2)
 235                                 {
 236                                         // HALF_FLOAT fix: remove INF and NaN
 237                                         if ((toFill[i+1] & 0x7C) == 0x7C)
 238                                                 toFill[i+1] = 0x00;
 239                                 }
 240                         }
 241                         else if (textureFormat.type == tcu::TextureFormat::FLOAT)
 242                         {
 243                                 for (size_t i = 0; i < size; i += 4)
 244                                 {
 245                                         // HALF_FLOAT fix: remove INF and NaN
 246                                         if ((toFill[i+1] & 0x7C) == 0x7C)
 247                                                 toFill[i+1] = 0x00;
 248                                 }
 249
 250                                 for (size_t i = 0; i < size; i += 4)
 251                                 {
 252                                         // FLOAT fix: remove INF, NaN, and denorm
 253                                         // Little endian fix
 254                                         if (((toFill[i+3] & 0x7F) == 0x7F && (toFill[i+2] & 0x80) == 0x80) || ((toFill[i+3] & 0x7F) == 0x00 && (toFill[i+2] & 0x80) == 0x00))
 255                                                 toFill[i+3] = 0x01;
 256                                         // Big endian fix
 257                                         if (((toFill[i+0] & 0x7F) == 0x7F && (toFill[i+1] & 0x80) == 0x80) || ((toFill[i+0] & 0x7F) == 0x00 && (toFill[i+1] & 0x80) == 0x00))
 258                                                 toFill[i+0] = 0x01;
 259                                 }
 260                         }
 261                 }
 262         }
 263 }
 264
 265 class BasicComputeTestInstance : public BasicTranscodingTestInstance
 266 {
 267 public:
 268                                         BasicComputeTestInstance        (Context&                                                       contex,
 269                                                                                                 const TestParameters&                           parameters);
 270         TestStatus              iterate                                         (void);
 271 protected:
 272         void                    copyDataToImage                         (const VkCommandBuffer&                         cmdBuffer,
 273                                                                                                  const VkImage&                                         compressed,
 274                                                                                                  const VkImageCreateInfo&                       imageInfo);
 275         virtual void    executeShader                           (const VkCommandBuffer&                         cmdBuffer,
 276                                                                                                  const VkDescriptorSetLayout&           descriptorSetLayout,
 277                                                                                                  const VkDescriptorPool&                        descriptorPool,
 278                                                                                                  const vector<ImageSp>&                         images,
 279                                                                                                  const vector<ImageViewSp>&                     imageViews);
 280         bool                    copyResultAndCompare            (const VkCommandBuffer&                         cmdBuffer,
 281                                                                                                  const VkImage&                                         uncompressed);
 282         void                    descriptorSetUpdate                     (VkDescriptorSet                                        descriptorSet,
 283                                                                                                  const VkDescriptorImageInfo*           descriptorImageInfos);
 284         void                    createImageInfos                        (VkImageCreateInfo*                                     imageInfos);
 285         bool                    decompressImage                         (const VkCommandBuffer&                         cmdBuffer,
 286                                                                                                  const VkImage&                                         uncompressed,
 287                                                                                                  const VkImage&                                         compressed,
 288                                                                                                  const VkExtent3D&                                      extentunCompressed);
 289         vector<deUint8> m_data;
 290 };
 291
 292 BasicComputeTestInstance::BasicComputeTestInstance (Context& context, const TestParameters& parameters)
 293         :BasicTranscodingTestInstance   (context, parameters)
 294         ,m_data                                                 (static_cast<size_t>(getCompressedImageSizeInBytes(parameters.formatCompressed, parameters.size)))
 295 {
 296         generateData (&m_data[0], m_data.size(), m_parameters.formatCompressed);
 297 }
 298
 299 TestStatus BasicComputeTestInstance::iterate (void)
 300 {
 301         const DeviceInterface&                                  vk                                      = m_context.getDeviceInterface();
 302         const VkDevice                                                  device                          = m_context.getDevice();
 303         const deUint32                                                  queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 304         Allocator&                                                              allocator                       = m_context.getDefaultAllocator();
 305
 306         Move<VkDescriptorSetLayout>                             descriptorSetLayout;
 307         Move<VkDescriptorPool>                                  descriptorPool;
 308
 309         vector<ImageSp>                                                 images;
 310         vector<VkImageCreateInfo>                               imagesInfo                      (m_parameters.imagesCount);
 311         createImageInfos(&imagesInfo[0]);
 312         vector<ImageViewSp>                                             imageViews                      (m_parameters.imagesCount);
 313         images.resize(m_parameters.imagesCount);
 314         const deUint32                                                  compressedNdx           = 0u;
 315         const deUint32                                                  uncompressedNdx         = m_parameters.imagesCount - 1u;
 316
 317         {
 318                 DescriptorSetLayoutBuilder      descriptorSetLayoutBuilder;
 319                 DescriptorPoolBuilder           descriptorPoolBuilder;
 320
 321                 for (deUint32 imageNdx = 0; imageNdx < m_parameters.imagesCount; ++imageNdx)
 322                 {
 323                         images[imageNdx] = makeVkSharedPtr(MovePtr<Image>(new Image(vk, device, allocator, imagesInfo[imageNdx], MemoryRequirement::Any)));
 324                         if (compressedNdx == imageNdx)
 325                         {
 326                                 const VkImageViewUsageCreateInfoKHR     imageViewUsageCreateInfoKHR     =
 327                                 {
 328                                         VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR,     //VkStructureType               sType;
 329                                         DE_NULL,                                                                                        //const void*                   pNext;
 330                                         m_parameters.compressedImageUsage,                                      //VkImageUsageFlags             usage;
 331                                 };
 332                                 imageViews[imageNdx] = makeVkSharedPtr(makeImageView(vk, device, **images[imageNdx]->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed,
 333                                                 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imagesInfo[imageNdx].extent.depth, 0u, imagesInfo[imageNdx].arrayLayers), &imageViewUsageCreateInfoKHR));
 334                         }
 335                         else
 336                         {
 337                                 imageViews[imageNdx] = makeVkSharedPtr(makeImageView(vk, device, **images[imageNdx]->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed,
 338                                                                                 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imagesInfo[imageNdx].extent.depth, 0u, imagesInfo[imageNdx].arrayLayers)));
 339                         }
 340                         switch(m_parameters.operation)
 341                         {
 342                                 case OPERATION_IMAGE_LOAD:
 343                                 case OPERATION_IMAGE_STORE:
 344                                         descriptorSetLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT);
 345                                         descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, imagesInfo[imageNdx].arrayLayers);
 346                                         break;
 347                                 case OPERATION_TEXEL_FETCH:
 348                                 case OPERATION_TEXTURE:
 349                                         descriptorSetLayoutBuilder.addSingleBinding((compressedNdx == imageNdx) ? VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER : VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT);
 350                                         descriptorPoolBuilder.addType((compressedNdx == imageNdx) ? VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER : VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, imagesInfo[imageNdx].arrayLayers);
 351                                         break;
 352                                 default:
 353                                         DE_ASSERT(false);
 354                                         break;
 355                         }
 356                 }
 357                 descriptorSetLayout     = descriptorSetLayoutBuilder.build(vk, device);
 358                 descriptorPool          = descriptorPoolBuilder.build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, imagesInfo[0].arrayLayers);
 359         }
 360
 361         const Unique<VkCommandPool>                             cmdPool                         (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
 362         const Unique<VkCommandBuffer>                   cmdBuffer                       (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
 363
 364         switch(m_parameters.operation)
 365         {
 366                 case OPERATION_IMAGE_LOAD:
 367                 case OPERATION_TEXEL_FETCH:
 368                 case OPERATION_TEXTURE:
 369                         copyDataToImage(*cmdBuffer, **images[compressedNdx]->get(), imagesInfo[compressedNdx]);
 370                         break;
 371                 case OPERATION_IMAGE_STORE:
 372                         copyDataToImage(*cmdBuffer, **images[1]->get(), imagesInfo[1]);
 373                         break;
 374                 default:
 375                         DE_ASSERT(false);
 376                         break;
 377         }
 378         executeShader(*cmdBuffer, *descriptorSetLayout, *descriptorPool, images, imageViews);
 379
 380         if (copyResultAndCompare(*cmdBuffer, **images[uncompressedNdx]->get()) &&
 381                 decompressImage(*cmdBuffer, **images[uncompressedNdx]->get(), **images[compressedNdx]->get(), imagesInfo[uncompressedNdx].extent))
 382         {
 383                 return TestStatus::pass("Pass");
 384         }
 385         return TestStatus::fail("Fail");
 386 }
 387
 388 void BasicComputeTestInstance::copyDataToImage (const VkCommandBuffer& cmdBuffer, const VkImage& compressed, const VkImageCreateInfo& imageInfo)
 389 {
 390         const DeviceInterface&          vk                      = m_context.getDeviceInterface();
 391         const VkDevice                          device          = m_context.getDevice();
 392         const VkQueue                           queue           = m_context.getUniversalQueue();
 393         Allocator&                                      allocator       = m_context.getDefaultAllocator();
 394
 395         Buffer                                          imageBuffer     (vk, device, allocator,
 396                                                                                                 makeBufferCreateInfo(m_data.size(), VK_BUFFER_USAGE_TRANSFER_SRC_BIT),
 397                                                                                                 MemoryRequirement::HostVisible);
 398         {
 399                 const Allocation& alloc = imageBuffer.getAllocation();
 400                 deMemcpy(alloc.getHostPtr(), &m_data[0], m_data.size());
 401                 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), m_data.size());
 402         }
 403
 404         beginCommandBuffer(vk, cmdBuffer);
 405         {
 406                 const VkImageSubresourceRange   subresourceRange                =
 407                 {
 408                         VK_IMAGE_ASPECT_COLOR_BIT,                                                                                      //VkImageAspectFlags    aspectMask
 409                         0u,                                                                                                                                     //deUint32                              baseMipLevel
 410                         1u,                                                                                                                                     //deUint32                              levelCount
 411                         0u,                                                                                                                                     //deUint32                              baseArrayLayer
 412                         1                                                                                                                                       //deUint32                              layerCount
 413                 };
 414
 415                 const VkImageMemoryBarrier              preCopyImageBarrier             = makeImageMemoryBarrier(
 416                                                                                                                                         0u, VK_ACCESS_TRANSFER_WRITE_BIT,
 417                                                                                                                                         VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
 418                                                                                                                                         compressed, subresourceRange);
 419
 420                 const VkBufferMemoryBarrier             FlushHostCopyBarrier    = makeBufferMemoryBarrier(
 421                                                                                                                                         VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
 422                                                                                                                                         imageBuffer.get(), 0ull, m_data.size());
 423
 424                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
 425                                 (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &FlushHostCopyBarrier, 1u, &preCopyImageBarrier);
 426
 427                 const VkBufferImageCopy                 copyRegion                              =
 428                 {
 429                         0ull,                                                                                                                           //      VkDeviceSize                            bufferOffset;
 430                         0u,                                                                                                                                     //      deUint32                                        bufferRowLength;
 431                         0u,                                                                                                                                     //      deUint32                                        bufferImageHeight;
 432                         makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u),      //      VkImageSubresourceLayers        imageSubresource;
 433                         makeOffset3D(0, 0, 0),                                                                                          //      VkOffset3D                                      imageOffset;
 434                         imageInfo.extent,                                                                                                       //      VkExtent3D                                      imageExtent;
 435                 };
 436
 437                 vk.cmdCopyBufferToImage(cmdBuffer, imageBuffer.get(), compressed, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &copyRegion);
 438         }
 439         endCommandBuffer(vk, cmdBuffer);
 440         submitCommandsAndWait(vk, device, queue, cmdBuffer);
 441 }
 442
 443 void BasicComputeTestInstance::executeShader (const VkCommandBuffer&            cmdBuffer,
 444                                                                                           const VkDescriptorSetLayout&  descriptorSetLayout,
 445                                                                                           const VkDescriptorPool&               descriptorPool,
 446                                                                                           const vector<ImageSp>&                images,
 447                                                                                           const vector<ImageViewSp>&    imageViews)
 448 {
 449         const DeviceInterface&                  vk                                              = m_context.getDeviceInterface();
 450         const VkDevice                                  device                                  = m_context.getDevice();
 451         const VkQueue                                   queue                                   = m_context.getUniversalQueue();
 452         const Unique<VkShaderModule>    shaderModule                    (createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0));
 453         Move<VkDescriptorSet>                   descriptorSet                   = makeDescriptorSet(vk, device, descriptorPool, descriptorSetLayout);
 454         const Unique<VkPipelineLayout>  pipelineLayout                  (makePipelineLayout(vk, device, descriptorSetLayout));
 455         const Unique<VkPipeline>                pipeline                                (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
 456         const UVec3                                             extentUncompressed              = getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size);
 457         Move<VkSampler>                                 sampler;
 458         {
 459                 const vk::VkSamplerCreateInfo createInfo =
 460                 {
 461                         vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,      //VkStructureType               sType;
 462                         DE_NULL,                                                                        //const void*                   pNext;
 463                         0u,                                                                                     //VkSamplerCreateFlags  flags;
 464                         VK_FILTER_NEAREST,                                                      //VkFilter                              magFilter;
 465                         VK_FILTER_NEAREST,                                                      //VkFilter                              minFilter;
 466                         VK_SAMPLER_MIPMAP_MODE_NEAREST,                         //VkSamplerMipmapMode   mipmapMode;
 467                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          //VkSamplerAddressMode  addressModeU;
 468                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          //VkSamplerAddressMode  addressModeV;
 469                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,          //VkSamplerAddressMode  addressModeW;
 470                         0.0f,                                                                           //float                                 mipLodBias;
 471                         VK_FALSE,                                                                       //VkBool32                              anisotropyEnable;
 472                         1.0f,                                                                           //float                                 maxAnisotropy;
 473                         VK_TRUE,                                                                        //VkBool32                              compareEnable;
 474                         VK_COMPARE_OP_EQUAL,                                            //VkCompareOp                   compareOp;
 475                         0.0f,                                                                           //float                                 minLod;
 476                         0.0f,                                                                           //float                                 maxLod;
 477                         VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,        //VkBorderColor                 borderColor;
 478                         VK_TRUE,                                                                        //VkBool32                              unnormalizedCoordinates;
 479                 };
 480                 sampler = vk::createSampler(vk, device, &createInfo);
 481         }
 482
 483         vector<VkDescriptorImageInfo>   descriptorImageInfos    (m_parameters.imagesCount);
 484         for (deUint32 bindingNdx = 0; bindingNdx < m_parameters.imagesCount; ++bindingNdx)
 485                 descriptorImageInfos[bindingNdx] = makeDescriptorImageInfo(*sampler, **imageViews[bindingNdx], VK_IMAGE_LAYOUT_GENERAL);
 486
 487         beginCommandBuffer(vk, cmdBuffer);
 488         {
 489                 const VkImageSubresourceRange   subresourceRange                        =
 490                 {
 491                         VK_IMAGE_ASPECT_COLOR_BIT,                                      //VkImageAspectFlags    aspectMask
 492                         0u,                                                                                     //deUint32                              baseMipLevel
 493                         1u,                                                                                     //deUint32                              levelCount
 494                         0u,                                                                                     //deUint32                              baseArrayLayer
 495                         1u                                                                                      //deUint32                              layerCount
 496                 };
 497
 498                 vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
 499
 500                 const VkImageMemoryBarrier              preShaderImageBarriers[]        =
 501                 {
 502                         makeImageMemoryBarrier(
 503                                 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
 504                                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
 505                                 **images[0]->get(), subresourceRange),
 506
 507                         makeImageMemoryBarrier(
 508                                 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_WRITE_BIT,
 509                                 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
 510                                 **images[1]->get(), subresourceRange)
 511                 };
 512
 513                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
 514                         (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, (const VkBufferMemoryBarrier*)DE_NULL,
 515                         DE_LENGTH_OF_ARRAY(preShaderImageBarriers), preShaderImageBarriers);
 516
 517                 descriptorSetUpdate (*descriptorSet, &descriptorImageInfos[0]);
 518
 519                 vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
 520                 vk.cmdDispatch(cmdBuffer, extentUncompressed.x(), extentUncompressed.y(), extentUncompressed.z());
 521         }
 522         endCommandBuffer(vk, cmdBuffer);
 523         submitCommandsAndWait(vk, device, queue, cmdBuffer);
 524 }
 525
 526 bool BasicComputeTestInstance::copyResultAndCompare (const VkCommandBuffer& cmdBuffer, const VkImage& uncompressed)
 527 {
 528         const DeviceInterface&  vk                                      = m_context.getDeviceInterface();
 529         const VkQueue                   queue                           = m_context.getUniversalQueue();
 530         const VkDevice                  device                          = m_context.getDevice();
 531         Allocator&                              allocator                       = m_context.getDefaultAllocator();
 532         const UVec3                             extentUncompressed      = getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size);
 533
 534         vk::VkDeviceSize                imageResultSize         = getImageSizeBytes (tcu::IVec3(extentUncompressed.x(), extentUncompressed.y(), extentUncompressed.z()), m_parameters.formatUncompressed);
 535         Buffer                                  imageBufferResult       (vk, device, allocator,
 536                                                                                                         makeBufferCreateInfo(imageResultSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT),
 537                                                                                                         MemoryRequirement::HostVisible);
 538
 539         beginCommandBuffer(vk, cmdBuffer);
 540         {
 541                 const VkImageSubresourceRange   subresourceRange        =
 542                 {
 543                         VK_IMAGE_ASPECT_COLOR_BIT,                                                                                      //VkImageAspectFlags    aspectMask
 544                         0u,                                                                                                                                     //deUint32                              baseMipLevel
 545                         1u,                                                                                                                                     //deUint32                              levelCount
 546                         0u,                                                                                                                                     //deUint32                              baseArrayLayer
 547                         1u                                                                                                                                      //deUint32                              layerCount
 548                 };
 549
 550                 const VkBufferImageCopy                 copyRegion                      =
 551                 {
 552                         0ull,                                                                                                                           //      VkDeviceSize                            bufferOffset;
 553                         0u,                                                                                                                                     //      deUint32                                        bufferRowLength;
 554                         0u,                                                                                                                                     //      deUint32                                        bufferImageHeight;
 555                         makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u),      //      VkImageSubresourceLayers        imageSubresource;
 556                         makeOffset3D(0, 0, 0),                                                                                          //      VkOffset3D                                      imageOffset;
 557                         makeExtent3D(extentUncompressed),                                                                       //      VkExtent3D                                      imageExtent;
 558                 };
 559
 560                 const VkImageMemoryBarrier prepareForTransferBarrier = makeImageMemoryBarrier(
 561                                                                                                                                 VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
 562                                                                                                                                 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
 563                                                                                                                                 uncompressed, subresourceRange);
 564
 565                 const VkBufferMemoryBarrier copyBarrier = makeBufferMemoryBarrier(
 566                                                                                                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
 567                                                                                                         imageBufferResult.get(), 0ull, imageResultSize);
 568
 569                 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, 1, &prepareForTransferBarrier);
 570                 vk.cmdCopyImageToBuffer(cmdBuffer, uncompressed, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, imageBufferResult.get(), 1u, &copyRegion);
 571                 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);
 572         }
 573         endCommandBuffer(vk, cmdBuffer);
 574         submitCommandsAndWait(vk, device, queue, cmdBuffer);
 575
 576         const Allocation& allocResult = imageBufferResult.getAllocation();
 577         invalidateMappedMemoryRange(vk, device, allocResult.getMemory(), allocResult.getOffset(), imageResultSize);
 578
 579         if (deMemCmp(allocResult.getHostPtr(), &m_data[0], (size_t)imageResultSize) == 0)
 580                 return true;
 581         return false;
 582 }
 583
 584 void BasicComputeTestInstance::descriptorSetUpdate (VkDescriptorSet descriptorSet, const VkDescriptorImageInfo* descriptorImageInfos)
 585 {
 586         const DeviceInterface&          vk              = m_context.getDeviceInterface();
 587         const VkDevice                          device  = m_context.getDevice();
 588         DescriptorSetUpdateBuilder      descriptorSetUpdateBuilder;
 589
 590         switch(m_parameters.operation)
 591         {
 592                 case OPERATION_IMAGE_LOAD:
 593                 case OPERATION_IMAGE_STORE:
 594                 {
 595                         for (deUint32 bindingNdx = 0; bindingNdx < m_parameters.imagesCount; ++bindingNdx)
 596                                 descriptorSetUpdateBuilder.writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(bindingNdx), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfos[bindingNdx]);
 597
 598                         break;
 599                 }
 600
 601                 case OPERATION_TEXEL_FETCH:
 602                 case OPERATION_TEXTURE:
 603                 {
 604                         for (deUint32 bindingNdx = 0; bindingNdx < m_parameters.imagesCount; ++bindingNdx)
 605                         {
 606                                 descriptorSetUpdateBuilder.writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(bindingNdx),
 607                                         bindingNdx == 0 ? VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER : VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfos[bindingNdx]);
 608                         }
 609                         break;
 610                 }
 611
 612                 default:
 613                         DE_ASSERT(false);
 614         }
 615         descriptorSetUpdateBuilder.update(vk, device);
 616 }
 617
 618 void BasicComputeTestInstance::createImageInfos (VkImageCreateInfo* imageInfos)
 619 {
 620         const VkExtent3D                        extentUncompressed      = makeExtent3D(getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size));
 621         const VkExtent3D                        extentCompressed        = makeExtent3D(getLayerSize(m_parameters.imageType, m_parameters.size));
 622         const deUint32                          arrayLayers                     = getNumLayers(m_parameters.imageType, m_parameters.size);
 623         const VkImageType                       imageType                       = mapImageType(m_parameters.imageType);
 624
 625         const VkImageCreateInfo compressedInfo =
 626         {
 627                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                    // VkStructureType                      sType;
 628                 DE_NULL,                                                                                                // const void*                          pNext;
 629                 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT |
 630                 VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR |
 631                 VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR,                                 // VkImageCreateFlags           flags;
 632                 imageType,                                                                                              // VkImageType                          imageType;
 633                 m_parameters.formatCompressed,                                                  // VkFormat                                     format;
 634                 extentCompressed,                                                                               // VkExtent3D                           extent;
 635                 1u,                                                                                                             // deUint32                                     mipLevels;
 636                 arrayLayers,                                                                                    // deUint32                                     arrayLayers;
 637                 VK_SAMPLE_COUNT_1_BIT,                                                                  // VkSampleCountFlagBits        samples;
 638                 VK_IMAGE_TILING_OPTIMAL,                                                                // VkImageTiling                        tiling;
 639                 VK_IMAGE_USAGE_SAMPLED_BIT |
 640                 VK_IMAGE_USAGE_STORAGE_BIT |
 641                 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
 642                 VK_IMAGE_USAGE_TRANSFER_DST_BIT,                                                // VkImageUsageFlags            usage;
 643                 VK_SHARING_MODE_EXCLUSIVE,                                                              // VkSharingMode                        sharingMode;
 644                 0u,                                                                                                             // deUint32                                     queueFamilyIndexCount;
 645                 DE_NULL,                                                                                                // const deUint32*                      pQueueFamilyIndices;
 646                 VK_IMAGE_LAYOUT_UNDEFINED,                                                              // VkImageLayout                        initialLayout;
 647         };
 648         imageInfos[0] = compressedInfo;
 649
 650         for (size_t ndx = 1; ndx < m_parameters.imagesCount; ++ndx)
 651         {
 652                 const VkImageCreateInfo uncompressedInfo =
 653                 {
 654                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                            // VkStructureType                      sType;
 655                         DE_NULL,                                                                                        // const void*                          pNext;
 656                         0u,                                                                                                     // VkImageCreateFlags           flags;
 657                         imageType,                                                                                      // VkImageType                          imageType;
 658                         m_parameters.formatUncompressed,                                        // VkFormat                                     format;
 659                         extentUncompressed,                                                                     // VkExtent3D                           extent;
 660                         1u,                                                                                                     // deUint32                                     mipLevels;
 661                         arrayLayers,                                                                            // deUint32                                     arrayLayers;
 662                         VK_SAMPLE_COUNT_1_BIT,                                                          // VkSampleCountFlagBits        samples;
 663                         VK_IMAGE_TILING_OPTIMAL,                                                        // VkImageTiling                        tiling;
 664                         m_parameters.uncompressedImageUsage |
 665                         VK_IMAGE_USAGE_SAMPLED_BIT,                                                     // VkImageUsageFlags            usage;
 666                         VK_SHARING_MODE_EXCLUSIVE,                                                      // VkSharingMode                        sharingMode;
 667                         0u,                                                                                                     // deUint32                                     queueFamilyIndexCount;
 668                         DE_NULL,                                                                                        // const deUint32*                      pQueueFamilyIndices;
 669                         VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                        initialLayout;
 670                 };
 671                 imageInfos[ndx] = uncompressedInfo;
 672         }
 673 }
 674
 675 bool BasicComputeTestInstance::decompressImage (const VkCommandBuffer& cmdBuffer, const VkImage& uncompressed, const VkImage& compressed, const VkExtent3D& extentunCompressed)
 676 {
 677         const DeviceInterface&                          vk                                                      = m_context.getDeviceInterface();
 678         const VkDevice                                          device                                          = m_context.getDevice();
 679         const VkQueue                                           queue                                           = m_context.getUniversalQueue();
 680         Allocator&                                                      allocator                                       = m_context.getDefaultAllocator();
 681         const Unique<VkShaderModule>            shaderModule                            (createShaderModule(vk, device, m_context.getBinaryCollection().get("decompress"), 0));
 682         const VkImageCreateInfo                         decompressedImageInfo           =
 683         {
 684                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                                            // VkStructureType                      sType;
 685                 DE_NULL,                                                                                                                        // const void*                          pNext;
 686                 0u,                                                                                                                                     // VkImageCreateFlags           flags;
 687                 VK_IMAGE_TYPE_2D,                                                                                                       // VkImageType                          imageType;
 688                 VK_FORMAT_R8G8B8A8_UNORM,                                                                                       // VkFormat                                     format;
 689                 makeExtent3D(m_parameters.size),                                                                        // VkExtent3D                           extent;
 690                 1u,                                                                                                                                     // deUint32                                     mipLevels;
 691                 1u,                                                                                                                                     // deUint32                                     arrayLayers;
 692                 VK_SAMPLE_COUNT_1_BIT,                                                                                          // VkSampleCountFlagBits        samples;
 693                 VK_IMAGE_TILING_OPTIMAL,                                                                                        // VkImageTiling                        tiling;
 694                 VK_IMAGE_USAGE_SAMPLED_BIT |
 695                 VK_IMAGE_USAGE_STORAGE_BIT |
 696                 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
 697                 VK_IMAGE_USAGE_TRANSFER_DST_BIT,                                                                        // VkImageUsageFlags            usage;
 698                 VK_SHARING_MODE_EXCLUSIVE,                                                                                      // VkSharingMode                        sharingMode;
 699                 0u,                                                                                                                                     // deUint32                                     queueFamilyIndexCount;
 700                 DE_NULL,                                                                                                                        // const deUint32*                      pQueueFamilyIndices;
 701                 VK_IMAGE_LAYOUT_UNDEFINED,                                                                                      // VkImageLayout                        initialLayout;
 702         };
 703         const VkImageCreateInfo                         compressedImageInfo                     =
 704         {
 705                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                                            // VkStructureType                      sType;
 706                 DE_NULL,                                                                                                                        // const void*                          pNext;
 707                 0u,                                                                                                                                     // VkImageCreateFlags           flags;
 708                 VK_IMAGE_TYPE_2D,                                                                                                       // VkImageType                          imageType;
 709                 m_parameters.formatCompressed,                                                                          // VkFormat                                     format;
 710                 makeExtent3D(m_parameters.size),                                                                        // VkExtent3D                           extent;
 711                 1u,                                                                                                                                     // deUint32                                     mipLevels;
 712                 1u,                                                                                                                                     // deUint32                                     arrayLayers;
 713                 VK_SAMPLE_COUNT_1_BIT,                                                                                          // VkSampleCountFlagBits        samples;
 714                 VK_IMAGE_TILING_OPTIMAL,                                                                                        // VkImageTiling                        tiling;
 715                 VK_IMAGE_USAGE_SAMPLED_BIT |
 716                 VK_IMAGE_USAGE_TRANSFER_DST_BIT,                                                                        // VkImageUsageFlags            usage;
 717                 VK_SHARING_MODE_EXCLUSIVE,                                                                                      // VkSharingMode                        sharingMode;
 718                 0u,                                                                                                                                     // deUint32                                     queueFamilyIndexCount;
 719                 DE_NULL,                                                                                                                        // const deUint32*                      pQueueFamilyIndices;
 720                 VK_IMAGE_LAYOUT_UNDEFINED,                                                                                      // VkImageLayout                        initialLayout;
 721         };
 722         const VkImageUsageFlags                         compressedViewUsageFlags        = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 723         const VkImageViewUsageCreateInfoKHR     compressedViewUsageCI           =
 724         {
 725                 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR,                                     //VkStructureType               sType;
 726                 DE_NULL,                                                                                                                        //const void*                   pNext;
 727                 compressedViewUsageFlags,                                                                                       //VkImageUsageFlags             usage;
 728         };
 729         Image                                                           resultImage                                     (vk, device, allocator, decompressedImageInfo, MemoryRequirement::Any);
 730         Image                                                           referenceImage                          (vk, device, allocator, decompressedImageInfo, MemoryRequirement::Any);
 731         Image                                                           uncompressedImage                       (vk, device, allocator, compressedImageInfo, MemoryRequirement::Any);
 732         Move<VkImageView>                                       resultView                                      = makeImageView(vk, device, resultImage.get(), mapImageViewType(m_parameters.imageType), decompressedImageInfo.format,
 733                                                                                                                                                 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, decompressedImageInfo.extent.depth, 0u, decompressedImageInfo.arrayLayers));
 734         Move<VkImageView>                                       referenceView                           = makeImageView(vk, device, referenceImage.get(), mapImageViewType(m_parameters.imageType), decompressedImageInfo.format,
 735                                                                                                                                                 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, decompressedImageInfo.extent.depth, 0u, decompressedImageInfo.arrayLayers));
 736         Move<VkImageView>                                       uncompressedView                        = makeImageView(vk, device, uncompressedImage.get(), mapImageViewType(m_parameters.imageType), m_parameters.formatCompressed,
 737                                                                                                                                                 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, compressedImageInfo.extent.depth, 0u, compressedImageInfo.arrayLayers));
 738         Move<VkImageView>                                       compressedView                          = makeImageView(vk, device, compressed, mapImageViewType(m_parameters.imageType), m_parameters.formatCompressed,
 739                                                                                                                                                 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, compressedImageInfo.extent.depth, 0u, compressedImageInfo.arrayLayers), &compressedViewUsageCI);
 740         Move<VkDescriptorSetLayout>                     descriptorSetLayout                     = DescriptorSetLayoutBuilder()
 741                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_COMPUTE_BIT)
 742                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_COMPUTE_BIT)
 743                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
 744                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
 745                                                                                                                                                 .build(vk, device);
 746         Move<VkDescriptorPool>                          descriptorPool                          = DescriptorPoolBuilder()
 747                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, decompressedImageInfo.arrayLayers)
 748                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, decompressedImageInfo.arrayLayers)
 749                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, decompressedImageInfo.arrayLayers)
 750                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, decompressedImageInfo.arrayLayers)
 751                                                                                                                                                 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, decompressedImageInfo.arrayLayers);
 752
 753         Move<VkDescriptorSet>                           descriptorSet                           = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);
 754         const Unique<VkPipelineLayout>          pipelineLayout                          (makePipelineLayout(vk, device, *descriptorSetLayout));
 755         const Unique<VkPipeline>                        pipeline                                        (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
 756         const VkDeviceSize                                      bufferSize                                      = getImageSizeBytes(tcu::IVec3((int)m_parameters.size.x(), (int)m_parameters.size.y(), (int)m_parameters.size.z()), VK_FORMAT_R8G8B8A8_UNORM);
 757         Buffer                                                          resultBuffer                            (vk, device, allocator,
 758                                                                                                                                                 makeBufferCreateInfo(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible);
 759         Buffer                                                          referenceBuffer                         (vk, device, allocator,
 760                                                                                                                                                 makeBufferCreateInfo(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible);
 761         Buffer                                                          transferBuffer                          (vk, device, allocator,
 762                                                                                                                                                 makeBufferCreateInfo(m_data.size(), VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible);
 763         Move<VkSampler>                                         sampler;
 764         {
 765                 const vk::VkSamplerCreateInfo createInfo =
 766                 {
 767                         vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,                                              //VkStructureType               sType;
 768                         DE_NULL,                                                                                                                //const void*                   pNext;
 769                         0u,                                                                                                                             //VkSamplerCreateFlags  flags;
 770                         VK_FILTER_NEAREST,                                                                                              //VkFilter                              magFilter;
 771                         VK_FILTER_NEAREST,                                                                                              //VkFilter                              minFilter;
 772                         VK_SAMPLER_MIPMAP_MODE_NEAREST,                                                                 //VkSamplerMipmapMode   mipmapMode;
 773                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                                  //VkSamplerAddressMode  addressModeU;
 774                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                                  //VkSamplerAddressMode  addressModeV;
 775                         VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,                                                  //VkSamplerAddressMode  addressModeW;
 776                         0.0f,                                                                                                                   //float                                 mipLodBias;
 777                         VK_FALSE,                                                                                                               //VkBool32                              anisotropyEnable;
 778                         1.0f,                                                                                                                   //float                                 maxAnisotropy;
 779                         VK_TRUE,                                                                                                                //VkBool32                              compareEnable;
 780                         VK_COMPARE_OP_EQUAL,                                                                                    //VkCompareOp                   compareOp;
 781                         0.0f,                                                                                                                   //float                                 minLod;
 782                         0.0f,                                                                                                                   //float                                 maxLod;
 783                         VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,                                                //VkBorderColor                 borderColor;
 784                         VK_TRUE,                                                                                                                //VkBool32                              unnormalizedCoordinates;
 785                 };
 786                 sampler = vk::createSampler(vk, device, &createInfo);
 787         }
 788
 789         VkDescriptorImageInfo                   descriptorImageInfos[]  =
 790         {
 791                 makeDescriptorImageInfo(*sampler,       *uncompressedView,      VK_IMAGE_LAYOUT_GENERAL),
 792                 makeDescriptorImageInfo(*sampler,       *compressedView,        VK_IMAGE_LAYOUT_GENERAL),
 793                 makeDescriptorImageInfo(DE_NULL,        *resultView,            VK_IMAGE_LAYOUT_GENERAL),
 794                 makeDescriptorImageInfo(DE_NULL,        *referenceView,         VK_IMAGE_LAYOUT_GENERAL)
 795         };
 796         DescriptorSetUpdateBuilder()
 797                 .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(0), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorImageInfos[0])
 798                 .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(1), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorImageInfos[1])
 799                 .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(2), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfos[2])
 800                 .writeSingle(descriptorSet.get(), DescriptorSetUpdateBuilder::Location::binding(3), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfos[3])
 801                 .update(vk, device);
 802
 803
 804         beginCommandBuffer(vk, cmdBuffer);
 805         {
 806                 const VkImageSubresourceRange   subresourceRange        =
 807                 {
 808                         VK_IMAGE_ASPECT_COLOR_BIT,                                                                                      //VkImageAspectFlags                    aspectMask
 809                         0u,                                                                                                                                     //deUint32                                              baseMipLevel
 810                         1u,                                                                                                                                     //deUint32                                              levelCount
 811                         0u,                                                                                                                                     //deUint32                                              baseArrayLayer
 812                         1                                                                                                                                       //deUint32                                              layerCount
 813                 };
 814
 815                 const VkBufferImageCopy                 copyRegion                      =
 816                 {
 817                         0ull,                                                                                                                           //      VkDeviceSize                            bufferOffset;
 818                         0u,                                                                                                                                     //      deUint32                                        bufferRowLength;
 819                         0u,                                                                                                                                     //      deUint32                                        bufferImageHeight;
 820                         makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u),      //      VkImageSubresourceLayers        imageSubresource;
 821                         makeOffset3D(0, 0, 0),                                                                                          //      VkOffset3D                                      imageOffset;
 822                         decompressedImageInfo.extent,                                                                           //      VkExtent3D                                      imageExtent;
 823                 };
 824
 825                 const VkBufferImageCopy                 compressedCopyRegion                    =
 826                 {
 827                         0ull,                                                                                                                           //      VkDeviceSize                            bufferOffset;
 828                         0u,                                                                                                                                     //      deUint32                                        bufferRowLength;
 829                         0u,                                                                                                                                     //      deUint32                                        bufferImageHeight;
 830                         makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u),      //      VkImageSubresourceLayers        imageSubresource;
 831                         makeOffset3D(0, 0, 0),                                                                                          //      VkOffset3D                                      imageOffset;
 832                         extentunCompressed,                                                                                                     //      VkExtent3D                                      imageExtent;
 833                 };
 834
 835                 {
 836                         const VkBufferMemoryBarrier             preCopyBufferBarriers   = makeBufferMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT,
 837                                                                                                                                                 transferBuffer.get(), 0ull, m_data.size());
 838
 839                         vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
 840                                 (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &preCopyBufferBarriers, 0u, (const VkImageMemoryBarrier*)DE_NULL);
 841                 }
 842
 843                 vk.cmdCopyImageToBuffer(cmdBuffer, uncompressed, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, transferBuffer.get(), 1u, &compressedCopyRegion);
 844
 845                 {
 846                         const VkBufferMemoryBarrier             postCopyBufferBarriers  = makeBufferMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
 847                                                                                                                                                 transferBuffer.get(), 0ull, m_data.size());
 848
 849                         const VkImageMemoryBarrier              preCopyImageBarriers    = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT,
 850                                                                                                                                                 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, uncompressedImage.get(), subresourceRange);
 851
 852                         vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
 853                                 (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &postCopyBufferBarriers, 1u, &preCopyImageBarriers);
 854                 }
 855
 856                 vk.cmdCopyBufferToImage(cmdBuffer, transferBuffer.get(), uncompressedImage.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &copyRegion);
 857
 858                 vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
 859                 vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
 860
 861                 {
 862                         const VkImageMemoryBarrier              preShaderImageBarriers[]        =
 863                         {
 864                                 makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
 865                                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
 866                                         uncompressedImage.get(), subresourceRange),
 867
 868                                 makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_WRITE_BIT,
 869                                         VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
 870                                         resultImage.get(), subresourceRange),
 871
 872                                 makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_WRITE_BIT,
 873                                         VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
 874                                         referenceImage.get(), subresourceRange)
 875                         };
 876
 877                         vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
 878                                 (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, (const VkBufferMemoryBarrier*)DE_NULL,
 879                                 DE_LENGTH_OF_ARRAY(preShaderImageBarriers), preShaderImageBarriers);
 880                 }
 881
 882                 vk.cmdDispatch(cmdBuffer, m_parameters.size.x(), m_parameters.size.y(), m_parameters.size.z());
 883
 884                 {
 885                         const VkImageMemoryBarrier              postShaderImageBarriers[]       =
 886                         {
 887                                 makeImageMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
 888                                 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
 889                                 resultImage.get(), subresourceRange),
 890
 891                                 makeImageMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
 892                                         VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
 893                                         referenceImage.get(), subresourceRange)
 894                         };
 895
 896                          const VkBufferMemoryBarrier            preCopyBufferBarrier[]          =
 897                         {
 898                                 makeBufferMemoryBarrier( 0, VK_BUFFER_USAGE_TRANSFER_DST_BIT,
 899                                         resultBuffer.get(), 0ull, bufferSize),
 900
 901                                 makeBufferMemoryBarrier( 0, VK_BUFFER_USAGE_TRANSFER_DST_BIT,
 902                                         referenceBuffer.get(), 0ull, bufferSize),
 903                         };
 904
 905                         vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
 906                                 (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, DE_LENGTH_OF_ARRAY(preCopyBufferBarrier), preCopyBufferBarrier,
 907                                 DE_LENGTH_OF_ARRAY(postShaderImageBarriers), postShaderImageBarriers);
 908                 }
 909                 vk.cmdCopyImageToBuffer(cmdBuffer, resultImage.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, resultBuffer.get(), 1u, &copyRegion);
 910                 vk.cmdCopyImageToBuffer(cmdBuffer, referenceImage.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, referenceBuffer.get(), 1u, &copyRegion);
 911         }
 912         endCommandBuffer(vk, cmdBuffer);
 913         submitCommandsAndWait(vk, device, queue, cmdBuffer);
 914
 915         const Allocation&               resultAlloc             = resultBuffer.getAllocation();
 916         const Allocation&               referenceAlloc  = referenceBuffer.getAllocation();
 917         invalidateMappedMemoryRange(vk, device, resultAlloc.getMemory(), resultAlloc.getOffset(), bufferSize);
 918         invalidateMappedMemoryRange(vk, device, referenceAlloc.getMemory(), referenceAlloc.getOffset(), bufferSize);
 919
 920         tcu::ConstPixelBufferAccess     resultPixels            (mapVkFormat(decompressedImageInfo.format), decompressedImageInfo.extent.width, decompressedImageInfo.extent.height, decompressedImageInfo.extent.depth, resultAlloc.getHostPtr());
 921         tcu::ConstPixelBufferAccess     referencePixels         (mapVkFormat(decompressedImageInfo.format), decompressedImageInfo.extent.width, decompressedImageInfo.extent.height, decompressedImageInfo.extent.depth, referenceAlloc.getHostPtr());
 922
 923         return tcu::fuzzyCompare(m_context.getTestContext().getLog(), "ImageComparison", "Image Comparison", resultPixels, referencePixels, 0.001f, tcu::COMPARE_LOG_EVERYTHING);
 924 }
 925
 926
 927 class ImageStoreComputeTestInstance : public BasicComputeTestInstance
 928 {
 929 public:
 930                                         ImageStoreComputeTestInstance   (Context& contex, const TestParameters& parameters);
 931 protected:
 932         virtual void    executeShader           (const VkCommandBuffer&                 cmdBuffer,
 933                                                                                  const VkDescriptorSetLayout&   descriptorSetLayout,
 934                                                                                  const VkDescriptorPool&                descriptorPool,
 935                                                                                  const vector<ImageSp>&                 images,
 936                                                                                  const vector<ImageViewSp>&             imageViews);
 937 private:
 938 };
 939
 940 ImageStoreComputeTestInstance::ImageStoreComputeTestInstance (Context& contex, const TestParameters& parameters)
 941         :BasicComputeTestInstance       (contex, parameters)
 942 {
 943 }
 944
 945 void ImageStoreComputeTestInstance::executeShader (const VkCommandBuffer&               cmdBuffer,
 946                                                                                                    const VkDescriptorSetLayout& descriptorSetLayout,
 947                                                                                                    const VkDescriptorPool&              descriptorPool,
 948                                                                                                    const vector<ImageSp>&               images,
 949                                                                                                    const vector<ImageViewSp>&   imageViews)
 950 {
 951         const DeviceInterface&                  vk                                              = m_context.getDeviceInterface();
 952         const VkDevice                                  device                                  = m_context.getDevice();
 953         const VkQueue                                   queue                                   = m_context.getUniversalQueue();
 954         const Unique<VkShaderModule>    shaderModule                    (createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0));
 955         Move<VkDescriptorSet>                   descriptorSet                   = makeDescriptorSet(vk, device, descriptorPool, descriptorSetLayout);
 956         const Unique<VkPipelineLayout>  pipelineLayout                  (makePipelineLayout(vk, device, descriptorSetLayout));
 957         const Unique<VkPipeline>                pipeline                                (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
 958         const UVec3                                             extentUncompressed              = getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size);
 959
 960         vector<VkDescriptorImageInfo>   descriptorImageInfos    (m_parameters.imagesCount);
 961         for (deUint32 bindingNdx = 0; bindingNdx < m_parameters.imagesCount; ++bindingNdx)
 962                 descriptorImageInfos[bindingNdx] = makeDescriptorImageInfo(DE_NULL, **imageViews[bindingNdx], VK_IMAGE_LAYOUT_GENERAL);
 963
 964         beginCommandBuffer(vk, cmdBuffer);
 965         {
 966                 const VkImageSubresourceRange   subresourceRange                =
 967                 {
 968                         VK_IMAGE_ASPECT_COLOR_BIT,              //VkImageAspectFlags    aspectMask
 969                         0u,                                                             //deUint32                              baseMipLevel
 970                         1u,                                                             //deUint32                              levelCount
 971                         0u,                                                             //deUint32                              baseArrayLayer
 972                         1u                                                              //deUint32                              layerCount
 973                 };
 974
 975                 const VkImageMemoryBarrier              preShaderImageBarriers[]        =
 976                 {
 977                         makeImageMemoryBarrier(
 978                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT,
 979                         VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
 980                         **images[0]->get(), subresourceRange),
 981
 982                         makeImageMemoryBarrier(
 983                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
 984                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
 985                         **images[1]->get(), subresourceRange),
 986
 987                         makeImageMemoryBarrier(
 988                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_WRITE_BIT,
 989                         VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
 990                         **images[2]->get(), subresourceRange)
 991                 };
 992
 993                 vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
 994                         (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, (const VkBufferMemoryBarrier*)DE_NULL,
 995                         DE_LENGTH_OF_ARRAY(preShaderImageBarriers), preShaderImageBarriers);
 996
 997                 vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
 998                 descriptorSetUpdate (*descriptorSet, &descriptorImageInfos[0]);
 999
1000                 vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
1001
1002                 vk.cmdDispatch(cmdBuffer, extentUncompressed.x(), extentUncompressed.y(), extentUncompressed.z());
1003         }
1004         endCommandBuffer(vk, cmdBuffer);
1005         submitCommandsAndWait(vk, device, queue, cmdBuffer);
1006 }
1007
1008 class GraphicsAttachmentsTestInstance : public BasicTranscodingTestInstance
1009 {
1010 public:
1011                                                                         GraphicsAttachmentsTestInstance (Context& context, const TestParameters& parameters);
1012         virtual TestStatus                              iterate                                                 (void);
1013
1014 protected:
1015         virtual bool                                    isWriteToCompressedOperation    ();
1016         VkImageCreateInfo                               makeCreateImageInfo                             (VkFormat format, ImageType type, const UVec3& size, VkImageUsageFlags usageFlags, const VkImageCreateFlags* createFlags);
1017         VkImageViewUsageCreateInfoKHR   makeImageViewUsageCreateInfo    (VkImageUsageFlags imageUsageFlags);
1018         VkDeviceSize                                    getCompressedImageData                  (const VkFormat format, const UVec3& size, std::vector<deUint8>& data);
1019         VkDeviceSize                                    getUncompressedImageData                (const VkFormat format, const UVec3& size, std::vector<deUint8>& data);
1020         virtual void                                    transcode                                               (std::vector<deUint8>& srcData, std::vector<deUint8>& dstData, de::MovePtr<Image>& outputImage);
1021         bool                                                    compareAndLog                                   (const void* reference, const void* result, size_t size);
1022         bool                                                    verifyDecompression                             (const std::vector<deUint8>& refCompressedData, const de::MovePtr<Image>& resCompressedImage);
1023
1024         deUint32                                                m_arrayLayers;
1025         UVec3                                                   m_layerSize;
1026 };
1027
1028 GraphicsAttachmentsTestInstance::GraphicsAttachmentsTestInstance (Context& context, const TestParameters& parameters)
1029         : BasicTranscodingTestInstance(context, parameters)
1030         , m_arrayLayers(getNumLayers(m_parameters.imageType, m_parameters.size))
1031         , m_layerSize(getLayerSize(m_parameters.imageType, m_parameters.size))
1032 {
1033 }
1034
1035 TestStatus GraphicsAttachmentsTestInstance::iterate (void)
1036 {
1037         std::vector<deUint8>    srcData;
1038         std::vector<deUint8>    dstData;
1039         de::MovePtr<Image>              outputImage;
1040
1041         transcode(srcData, dstData, outputImage);
1042
1043         DE_ASSERT(srcData.size() > 0 && srcData.size() == dstData.size());
1044
1045         if (!compareAndLog(&srcData[0], &dstData[0], srcData.size()))
1046                 return TestStatus::fail("Output differs from input");
1047
1048         // Verify by sampling
1049         if (isWriteToCompressedOperation())
1050                 if (!verifyDecompression(srcData, outputImage))
1051                         return TestStatus::fail("Decompressed images difference detected");
1052
1053         return TestStatus::pass("Pass");
1054 }
1055
1056 void GraphicsAttachmentsTestInstance::transcode (std::vector<deUint8>& srcData, std::vector<deUint8>& dstData, de::MovePtr<Image>& outputImage)
1057 {
1058         const DeviceInterface&                                  vk                                              = m_context.getDeviceInterface();
1059         const VkDevice                                                  device                                  = m_context.getDevice();
1060         const deUint32                                                  queueFamilyIndex                = m_context.getUniversalQueueFamilyIndex();
1061         const VkQueue                                                   queue                                   = m_context.getUniversalQueue();
1062         Allocator&                                                              allocator                               = m_context.getDefaultAllocator();
1063
1064         const deUint32                                                  levelCount                              = m_layerSize[2];
1065         const VkImageSubresourceRange                   subresourceRange                = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, levelCount, 0u, m_arrayLayers);
1066         const VkImageCreateFlags*                               imgCreateFlagsOverride  = DE_NULL;
1067         const VkImageViewUsageCreateInfoKHR             imageViewUsageKHR               = makeImageViewUsageCreateInfo(m_parameters.compressedImageUsage);
1068         const VkImageViewUsageCreateInfoKHR*    imageViewUsageKHRNull   = (VkImageViewUsageCreateInfoKHR*)DE_NULL;
1069
1070         const UVec3                                                             compressedImageRes              = m_parameters.size;
1071         const UVec3                                                             uncompressedImageRes    = getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size);
1072
1073         const VkFormat                                                  srcFormat                               = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? m_parameters.formatCompressed :
1074                                                                                                                                           (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.formatUncompressed :
1075                                                                                                                                           VK_FORMAT_UNDEFINED;
1076         const UVec3                                                             srcImageResolution              = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? compressedImageRes :
1077                                                                                                                                           (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? uncompressedImageRes :
1078                                                                                                                                           UVec3(0, 0, 0);
1079         const VkDeviceSize                                              srcImageSizeInBytes             = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? getCompressedImageData(srcFormat, srcImageResolution, srcData) :
1080                                                                                                                                           (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? getUncompressedImageData(srcFormat, srcImageResolution, srcData) :
1081                                                                                                                                           0;
1082         const VkImageUsageFlags                                 srcImageUsageFlags              = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? m_parameters.compressedImageUsage :
1083                                                                                                                                           (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.uncompressedImageUsage :
1084                                                                                                                                           0;
1085         const VkImageViewUsageCreateInfoKHR*    srcImageViewUsageKHR    = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? &imageViewUsageKHR :
1086                                                                                                                                           (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? imageViewUsageKHRNull :
1087                                                                                                                                           imageViewUsageKHRNull;
1088
1089         const VkFormat                                                  dstFormat                               = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? m_parameters.formatUncompressed :
1090                                                                                                                                           (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.formatCompressed :
1091                                                                                                                                           VK_FORMAT_UNDEFINED;
1092         const UVec3                                                             dstImageResolution              = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? uncompressedImageRes :
1093                                                                                                                                           (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? compressedImageRes :
1094                                                                                                                                           UVec3(0, 0, 0);
1095         const VkDeviceSize                                              dstImageSizeInBytes             = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? getUncompressedImageSizeInBytes(dstFormat, dstImageResolution) :
1096                                                                                                                                           (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? getCompressedImageSizeInBytes(dstFormat, dstImageResolution) :
1097                                                                                                                                           0;
1098         const VkImageUsageFlags                                 dstImageUsageFlags              = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? m_parameters.uncompressedImageUsage :
1099                                                                                                                                           (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.compressedImageUsage :
1100                                                                                                                                           0;
1101         const VkImageViewUsageCreateInfoKHR*    dstImageViewUsageKHR    = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? imageViewUsageKHRNull :
1102                                                                                                                                           (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? &imageViewUsageKHR :
1103                                                                                                                                           imageViewUsageKHRNull;
1104
1105         const std::vector<tcu::Vec4>                    vertexArray                             = createFullscreenQuad();
1106         const deUint32                                                  vertexCount                             = static_cast<deUint32>(vertexArray.size());
1107         const size_t                                                    vertexBufferSizeInBytes = vertexCount * sizeof(vertexArray[0]);
1108         const MovePtr<Buffer>                                   vertexBuffer                    = MovePtr<Buffer>(new Buffer(vk, device, allocator, makeBufferCreateInfo(vertexBufferSizeInBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible));
1109         const Allocation&                                               vertexBufferAlloc               = vertexBuffer->getAllocation();
1110         const VkDeviceSize                                              vertexBufferOffset[]    = { 0 };
1111
1112         const VkBufferCreateInfo                                srcImageBufferInfo              (makeBufferCreateInfo(srcImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT));
1113         const MovePtr<Buffer>                                   srcImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, srcImageBufferInfo, MemoryRequirement::HostVisible));
1114
1115         const VkImageCreateInfo                                 srcImageCreateInfo              = makeCreateImageInfo(srcFormat, m_parameters.imageType, srcImageResolution, srcImageUsageFlags, imgCreateFlagsOverride);
1116         const MovePtr<Image>                                    srcImage                                (new Image(vk, device, allocator, srcImageCreateInfo, MemoryRequirement::Any));
1117         Move<VkImageView>                                               srcImageView                    (makeImageView(vk, device, srcImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, subresourceRange, srcImageViewUsageKHR));
1118
1119         const VkImageCreateInfo                                 dstImageCreateInfo              = makeCreateImageInfo(dstFormat, m_parameters.imageType, dstImageResolution, dstImageUsageFlags, imgCreateFlagsOverride);
1120         de::MovePtr<Image>                                              dstImage                                (new Image(vk, device, allocator, dstImageCreateInfo, MemoryRequirement::Any));
1121         Move<VkImageView>                                               dstImageView                    (makeImageView(vk, device, dstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, subresourceRange, dstImageViewUsageKHR));
1122
1123         const VkBufferCreateInfo                                dstImageBufferInfo              (makeBufferCreateInfo(dstImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT));
1124         MovePtr<Buffer>                                                 dstImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, dstImageBufferInfo, MemoryRequirement::HostVisible));
1125
1126         const Unique<VkShaderModule>                    vertShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
1127         const Unique<VkShaderModule>                    fragShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
1128
1129         const Unique<VkRenderPass>                              renderPass                              (makeRenderPass(vk, device, m_parameters.formatUncompressed, m_parameters.formatUncompressed));
1130
1131         const Move<VkDescriptorSetLayout>               descriptorSetLayout             (DescriptorSetLayoutBuilder()
1132                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_SHADER_STAGE_FRAGMENT_BIT)
1133                                                                                                                                                 .build(vk, device));
1134         const Move<VkDescriptorPool>                    descriptorPool                  (DescriptorPoolBuilder()
1135                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, m_arrayLayers)
1136                                                                                                                                                 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, m_arrayLayers));
1137         const Move<VkDescriptorSet>                             descriptorSet                   (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
1138         const VkDescriptorImageInfo                             descriptorSrcImageInfo  (makeDescriptorImageInfo(DE_NULL, *srcImageView, VK_IMAGE_LAYOUT_GENERAL));
1139
1140         const VkExtent2D                                                renderSize                              (makeExtent2D(uncompressedImageRes[0], uncompressedImageRes[1]));
1141         const Unique<VkPipelineLayout>                  pipelineLayout                  (makePipelineLayout(vk, device, *descriptorSetLayout));
1142         const Unique<VkPipeline>                                pipeline                                (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertShaderModule, *fragShaderModule, renderSize, 1u));
1143         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, device, VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT, queueFamilyIndex));
1144         const Unique<VkCommandBuffer>                   cmdBuffer                               (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
1145
1146         const VkBufferImageCopy                                 srcCopyRegion                   = makeBufferImageCopy(srcImageResolution[0], srcImageResolution[1]);
1147         const VkBufferMemoryBarrier                             srcCopyBufferBarrierPre = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, srcImageBuffer->get(), 0ull, srcImageSizeInBytes);
1148         const VkImageMemoryBarrier                              srcCopyImageBarrierPre  = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, srcImage->get(), subresourceRange);
1149         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(), subresourceRange);
1150         const VkBufferImageCopy                                 dstCopyRegion                   = makeBufferImageCopy(dstImageResolution[0], dstImageResolution[1]);
1151
1152         const VkImageView                                               attachmentBindInfos[]   = { *srcImageView, *dstImageView };
1153         const Move<VkFramebuffer>                               framebuffer                             (makeFramebuffer(vk, device, *renderPass, DE_LENGTH_OF_ARRAY(attachmentBindInfos), attachmentBindInfos, renderSize, m_arrayLayers));
1154
1155         DE_ASSERT(srcImageSizeInBytes == dstImageSizeInBytes);
1156
1157         // Upload vertex data
1158         deMemcpy(vertexBufferAlloc.getHostPtr(), &vertexArray[0], vertexBufferSizeInBytes);
1159         flushMappedMemoryRange(vk, device, vertexBufferAlloc.getMemory(), vertexBufferAlloc.getOffset(), vertexBufferSizeInBytes);
1160
1161         // Upload source image data
1162         const Allocation& alloc = srcImageBuffer->getAllocation();
1163         deMemcpy(alloc.getHostPtr(), &srcData[0], (size_t)srcImageSizeInBytes);
1164         flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), srcImageSizeInBytes);
1165
1166         beginCommandBuffer(vk, *cmdBuffer);
1167         vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1168
1169         //Copy buffer to image
1170         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);
1171         vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);
1172         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1u, &srcCopyImageBarrierPost);
1173
1174         beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
1175
1176         for (deUint32 layerNdx = 0; layerNdx < m_arrayLayers; ++layerNdx)
1177         {
1178                 DescriptorSetUpdateBuilder()
1179                         .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, &descriptorSrcImageInfo)
1180                         .update(vk, device);
1181
1182                 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
1183                 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer->get(), vertexBufferOffset);
1184                 vk.cmdDraw(*cmdBuffer, vertexCount, 1, 0, 0);
1185         }
1186
1187         vk.cmdEndRenderPass(*cmdBuffer);
1188
1189         const VkImageMemoryBarrier prepareForTransferBarrier = makeImageMemoryBarrier(
1190                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1191                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
1192                 dstImage->get(), subresourceRange);
1193
1194         const VkBufferMemoryBarrier copyBarrier = makeBufferMemoryBarrier(
1195                 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
1196                 dstImageBuffer->get(), 0ull, dstImageSizeInBytes);
1197
1198         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);
1199         vk.cmdCopyImageToBuffer(*cmdBuffer, dstImage->get(), VK_IMAGE_LAYOUT_GENERAL, dstImageBuffer->get(), 1u, &dstCopyRegion);
1200         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);
1201
1202         endCommandBuffer(vk, *cmdBuffer);
1203
1204         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
1205
1206         const Allocation& dstImageBufferAlloc = dstImageBuffer->getAllocation();
1207         invalidateMappedMemoryRange(vk, device, dstImageBufferAlloc.getMemory(), dstImageBufferAlloc.getOffset(), dstImageSizeInBytes);
1208         dstData.resize((size_t)dstImageSizeInBytes);
1209         deMemcpy(&dstData[0], dstImageBufferAlloc.getHostPtr(), (size_t)dstImageSizeInBytes);
1210
1211         outputImage = dstImage;
1212 }
1213
1214 bool GraphicsAttachmentsTestInstance::isWriteToCompressedOperation ()
1215 {
1216         return (m_parameters.operation == OPERATION_ATTACHMENT_WRITE);
1217 }
1218
1219 VkImageCreateInfo GraphicsAttachmentsTestInstance::makeCreateImageInfo (VkFormat format, ImageType type, const UVec3& size, VkImageUsageFlags usageFlags, const VkImageCreateFlags* createFlags)
1220 {
1221         const VkImageType                       imageType                               = mapImageType(type);
1222         const VkImageCreateFlags        imageCreateFlagsBase    = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
1223         const VkImageCreateFlags        imageCreateFlagsAddOn   = isCompressedFormat(format) ? VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR : 0;
1224         const VkImageCreateFlags        imageCreateFlags                = (createFlags != DE_NULL) ? *createFlags : (imageCreateFlagsBase | imageCreateFlagsAddOn);
1225
1226         const VkImageCreateInfo createImageInfo =
1227         {
1228                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                    // VkStructureType                      sType;
1229                 DE_NULL,                                                                                // const void*                          pNext;
1230                 imageCreateFlags,                                                               // VkImageCreateFlags           flags;
1231                 imageType,                                                                              // VkImageType                          imageType;
1232                 format,                                                                                 // VkFormat                                     format;
1233                 makeExtent3D(getLayerSize(type, size)),                 // VkExtent3D                           extent;
1234                 1u,                                                                                             // deUint32                                     mipLevels;
1235                 1u,                                                                                             // deUint32                                     arrayLayers;
1236                 VK_SAMPLE_COUNT_1_BIT,                                                  // VkSampleCountFlagBits        samples;
1237                 VK_IMAGE_TILING_OPTIMAL,                                                // VkImageTiling                        tiling;
1238                 usageFlags,                                                                             // VkImageUsageFlags            usage;
1239                 VK_SHARING_MODE_EXCLUSIVE,                                              // VkSharingMode                        sharingMode;
1240                 0u,                                                                                             // deUint32                                     queueFamilyIndexCount;
1241                 DE_NULL,                                                                                // const deUint32*                      pQueueFamilyIndices;
1242                 VK_IMAGE_LAYOUT_UNDEFINED,                                              // VkImageLayout                        initialLayout;
1243         };
1244
1245         return createImageInfo;
1246 }
1247
1248 VkImageViewUsageCreateInfoKHR GraphicsAttachmentsTestInstance::makeImageViewUsageCreateInfo (VkImageUsageFlags imageUsageFlags)
1249 {
1250         VkImageViewUsageCreateInfoKHR imageViewUsageCreateInfoKHR =
1251         {
1252                 VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR,     //VkStructureType               sType;
1253                 DE_NULL,                                                                                        //const void*                   pNext;
1254                 imageUsageFlags,                                                                        //VkImageUsageFlags             usage;
1255         };
1256
1257         return imageViewUsageCreateInfoKHR;
1258 }
1259
1260 VkDeviceSize GraphicsAttachmentsTestInstance::getCompressedImageData (const VkFormat format, const UVec3& size, std::vector<deUint8>& data)
1261 {
1262         VkDeviceSize    sizeBytes       = getCompressedImageSizeInBytes(format, size);
1263
1264         data.resize((size_t)sizeBytes);
1265         generateData(&data[0], data.size(), format);
1266
1267         return sizeBytes;
1268 }
1269
1270 VkDeviceSize GraphicsAttachmentsTestInstance::getUncompressedImageData (const VkFormat format, const UVec3& size, std::vector<deUint8>& data)
1271 {
1272         tcu::IVec3                              sizeAsIVec3     = tcu::IVec3(static_cast<int>(size[0]), static_cast<int>(size[1]), static_cast<int>(size[2]));
1273         VkDeviceSize                    sizeBytes       = getImageSizeBytes(sizeAsIVec3, format);
1274
1275         data.resize((size_t)sizeBytes);
1276         generateData(&data[0], data.size(), format);
1277
1278         return sizeBytes;
1279 }
1280
1281 bool GraphicsAttachmentsTestInstance::compareAndLog (const void* reference, const void* result, size_t size)
1282 {
1283         tcu::TestLog&   log                     = m_context.getTestContext().getLog();
1284
1285         const deUint64* ref64   = reinterpret_cast<const deUint64*>(reference);
1286         const deUint64* res64   = reinterpret_cast<const deUint64*>(result);
1287         const size_t    sizew   = size / sizeof(deUint64);
1288         bool                    equal   = true;
1289
1290         DE_ASSERT(size % sizeof(deUint64) == 0);
1291
1292         for (deUint32 ndx = 0u; ndx < static_cast<deUint32>(sizew); ndx++)
1293         {
1294                 if (ref64[ndx] != res64[ndx])
1295                 {
1296                         std::stringstream str;
1297
1298                         str     << "Difference begins near byte " << ndx * sizeof(deUint64) << "."
1299                                 << " reference value: 0x" << std::hex << std::setw(2ull * sizeof(deUint64)) << std::setfill('0') << ref64[ndx]
1300                                 << " result value: 0x" << std::hex << std::setw(2ull * sizeof(deUint64)) << std::setfill('0') << res64[ndx];
1301
1302                         log.writeMessage(str.str().c_str());
1303
1304                         equal = false;
1305
1306                         break;
1307                 }
1308         }
1309
1310         return equal;
1311 }
1312
1313 bool GraphicsAttachmentsTestInstance::verifyDecompression (const std::vector<deUint8>& refCompressedData, const de::MovePtr<Image>& resCompressedImage)
1314 {
1315         const DeviceInterface&                          vk                                                      = m_context.getDeviceInterface();
1316         const VkDevice                                          device                                          = m_context.getDevice();
1317         const deUint32                                          queueFamilyIndex                        = m_context.getUniversalQueueFamilyIndex();
1318         const VkQueue                                           queue                                           = m_context.getUniversalQueue();
1319         Allocator&                                                      allocator                                       = m_context.getDefaultAllocator();
1320
1321         const deUint32                                          levelCount                                      = m_layerSize[2];
1322         const VkImageSubresourceRange           subresourceRange                        = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, levelCount, 0u, m_arrayLayers);
1323
1324         const VkDeviceSize                                      dstBufferSize                           = getUncompressedImageSizeInBytes(m_parameters.formatForVerify, m_parameters.size);
1325         const VkImageUsageFlags                         refSrcImageUsageFlags           = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
1326
1327         const std::vector<tcu::Vec4>            vertexArray                                     = createFullscreenQuad();
1328         const deUint32                                          vertexCount                                     = static_cast<deUint32>(vertexArray.size());
1329         const size_t                                            vertexBufferSizeInBytes         = vertexCount * sizeof(vertexArray[0]);
1330         const MovePtr<Buffer>                           vertexBuffer                            (new Buffer(vk, device, allocator, makeBufferCreateInfo(vertexBufferSizeInBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible));
1331         const Allocation&                                       vertexBufferAlloc                       = vertexBuffer->getAllocation();
1332         const VkDeviceSize                                      vertexBufferOffset[]            = { 0 };
1333
1334         const VkBufferCreateInfo                        refSrcImageBufferInfo           (makeBufferCreateInfo(refCompressedData.size(), VK_BUFFER_USAGE_TRANSFER_SRC_BIT));
1335         const MovePtr<Buffer>                           refSrcImageBuffer                       = MovePtr<Buffer>(new Buffer(vk, device, allocator, refSrcImageBufferInfo, MemoryRequirement::HostVisible));
1336
1337         const VkImageCreateFlags                        refSrcImageCreateFlags          = 0;
1338         const VkImageCreateInfo                         refSrcImageCreateInfo           = makeCreateImageInfo(m_parameters.formatCompressed, m_parameters.imageType, m_parameters.size, refSrcImageUsageFlags, &refSrcImageCreateFlags);
1339         const MovePtr<Image>                            refSrcImage                                     (new Image(vk, device, allocator, refSrcImageCreateInfo, MemoryRequirement::Any));
1340         Move<VkImageView>                                       refSrcImageView                         (makeImageView(vk, device, refSrcImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatCompressed, subresourceRange));
1341
1342         const VkImageUsageFlags                         resSrcImageUsageFlags           = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
1343         const VkImageViewUsageCreateInfoKHR     resSrcImageViewUsageKHR         = makeImageViewUsageCreateInfo(resSrcImageUsageFlags);
1344         Move<VkImageView>                                       resSrcImageView                         (makeImageView(vk, device, resCompressedImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatCompressed, subresourceRange, &resSrcImageViewUsageKHR));
1345
1346         const VkImageCreateFlags                        refDstImageCreateFlags          = 0;
1347         const VkImageUsageFlags                         refDstImageUsageFlags           = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
1348         const VkImageCreateInfo                         refDstImageCreateInfo           = makeCreateImageInfo(m_parameters.formatForVerify, m_parameters.imageType, m_parameters.size, refDstImageUsageFlags, &refDstImageCreateFlags);
1349         const MovePtr<Image>                            refDstImage                                     (new Image(vk, device, allocator, refDstImageCreateInfo, MemoryRequirement::Any));
1350         const Move<VkImageView>                         refDstImageView                         (makeImageView(vk, device, refDstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatForVerify, subresourceRange));
1351         const VkImageMemoryBarrier                      refDstCopyImageBarrier          = makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, refDstImage->get(), subresourceRange);
1352         const VkBufferCreateInfo                        refDstBufferInfo                        (makeBufferCreateInfo(dstBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT));
1353         const MovePtr<Buffer>                           refDstBuffer                            = MovePtr<Buffer>(new Buffer(vk, device, allocator, refDstBufferInfo, MemoryRequirement::HostVisible));
1354
1355         const VkImageCreateFlags                        resDstImageCreateFlags          = 0;
1356         const VkImageUsageFlags                         resDstImageUsageFlags           = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
1357         const VkImageCreateInfo                         resDstImageCreateInfo           = makeCreateImageInfo(m_parameters.formatForVerify, m_parameters.imageType, m_parameters.size, resDstImageUsageFlags, &resDstImageCreateFlags);
1358         const MovePtr<Image>                            resDstImage                                     (new Image(vk, device, allocator, resDstImageCreateInfo, MemoryRequirement::Any));
1359         const Move<VkImageView>                         resDstImageView                         (makeImageView(vk, device, resDstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatForVerify, subresourceRange));
1360         const VkImageMemoryBarrier                      resDstCopyImageBarrier          = makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, resDstImage->get(), subresourceRange);
1361         const VkBufferCreateInfo                        resDstBufferInfo                        (makeBufferCreateInfo(dstBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT));
1362         const MovePtr<Buffer>                           resDstBuffer                            = MovePtr<Buffer>(new Buffer(vk, device, allocator, resDstBufferInfo, MemoryRequirement::HostVisible));
1363
1364         const Unique<VkShaderModule>            vertShaderModule                        (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
1365         const Unique<VkShaderModule>            fragShaderModule                        (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag_verify"), 0));
1366
1367         const Unique<VkRenderPass>                      renderPass                                      (makeRenderPass(vk, device));
1368
1369         const Move<VkDescriptorSetLayout>       descriptorSetLayout                     (DescriptorSetLayoutBuilder()
1370                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT)
1371                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT)
1372                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_FRAGMENT_BIT)
1373                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_FRAGMENT_BIT)
1374                                                                                                                                                 .build(vk, device));
1375         const Move<VkDescriptorPool>            descriptorPool                          (DescriptorPoolBuilder()
1376                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, m_arrayLayers)
1377                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, m_arrayLayers)
1378                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, m_arrayLayers)
1379                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, m_arrayLayers)
1380                                                                                                                                                 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, m_arrayLayers));
1381         const Move<VkDescriptorSet>                     descriptorSet                           (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
1382         const VkSamplerCreateInfo                       refSrcSamplerInfo                       (makeSamplerCreateInfo());
1383         const Move<VkSampler>                           refSrcSampler                           = vk::createSampler(vk, device, &refSrcSamplerInfo);
1384         const VkSamplerCreateInfo                       resSrcSamplerInfo                       (makeSamplerCreateInfo());
1385         const Move<VkSampler>                           resSrcSampler                           = vk::createSampler(vk, device, &resSrcSamplerInfo);
1386         const VkDescriptorImageInfo                     descriptorRefSrcImage           (makeDescriptorImageInfo(*refSrcSampler, *refSrcImageView, VK_IMAGE_LAYOUT_GENERAL));
1387         const VkDescriptorImageInfo                     descriptorResSrcImage           (makeDescriptorImageInfo(*resSrcSampler, *resSrcImageView, VK_IMAGE_LAYOUT_GENERAL));
1388         const VkDescriptorImageInfo                     descriptorRefDstImage           (makeDescriptorImageInfo(DE_NULL, *refDstImageView, VK_IMAGE_LAYOUT_GENERAL));
1389         const VkDescriptorImageInfo                     descriptorResDstImage           (makeDescriptorImageInfo(DE_NULL, *resDstImageView, VK_IMAGE_LAYOUT_GENERAL));
1390
1391         const VkExtent2D                                        renderSize                                      (makeExtent2D(m_parameters.size.x(), m_parameters.size.y()));
1392         const Unique<VkPipelineLayout>          pipelineLayout                          (makePipelineLayout(vk, device, *descriptorSetLayout));
1393         const Unique<VkPipeline>                        pipeline                                        (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertShaderModule, *fragShaderModule, renderSize, 0u));
1394         const Unique<VkCommandPool>                     cmdPool                                         (createCommandPool(vk, device, VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT, queueFamilyIndex));
1395         const Unique<VkCommandBuffer>           cmdBuffer                                       (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
1396
1397         const VkBufferImageCopy                         copyRegion                                      = makeBufferImageCopy(m_parameters.size.x(), m_parameters.size.y());
1398         const VkBufferMemoryBarrier                     refSrcCopyBufferBarrier         = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, refSrcImageBuffer->get(), 0ull, refCompressedData.size());
1399         const VkImageMemoryBarrier                      refSrcCopyImageBarrier          = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, refSrcImage->get(), subresourceRange);
1400         const VkImageMemoryBarrier                      refSrcCopyImageBarrierPost      = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, refSrcImage->get(), subresourceRange);
1401
1402         const Move<VkFramebuffer>                       framebuffer                                     (makeFramebuffer(vk, device, *renderPass, 0, DE_NULL, renderSize, m_arrayLayers));
1403
1404         // Upload vertex data
1405         deMemcpy(vertexBufferAlloc.getHostPtr(), &vertexArray[0], vertexBufferSizeInBytes);
1406         flushMappedMemoryRange(vk, device, vertexBufferAlloc.getMemory(), vertexBufferAlloc.getOffset(), vertexBufferSizeInBytes);
1407
1408         // Upload source image data
1409         {
1410                 const Allocation& refSrcImageBufferAlloc = refSrcImageBuffer->getAllocation();
1411                 deMemcpy(refSrcImageBufferAlloc.getHostPtr(), &refCompressedData[0], refCompressedData.size());
1412                 flushMappedMemoryRange(vk, device, refSrcImageBufferAlloc.getMemory(), refSrcImageBufferAlloc.getOffset(), refCompressedData.size());
1413         }
1414
1415         beginCommandBuffer(vk, *cmdBuffer);
1416         vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1417
1418         //Copy buffer to image
1419         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &refSrcCopyBufferBarrier, 1u, &refSrcCopyImageBarrier);
1420         vk.cmdCopyBufferToImage(*cmdBuffer, refSrcImageBuffer->get(), refSrcImage->get(), VK_IMAGE_LAYOUT_GENERAL, 1u, &copyRegion);
1421         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, DE_NULL, 1u, &refSrcCopyImageBarrierPost);
1422
1423         // Make reference and result images readable
1424         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, &refDstCopyImageBarrier);
1425         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, &resDstCopyImageBarrier);
1426
1427         beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
1428         for (deUint32 layerNdx = 0; layerNdx < m_arrayLayers; ++layerNdx)
1429         {
1430                 DescriptorSetUpdateBuilder()
1431                         .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorRefSrcImage)
1432                         .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorResSrcImage)
1433                         .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(2u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorRefDstImage)
1434                         .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(3u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorResDstImage)
1435                         .update(vk, device);
1436
1437                 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
1438                 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer->get(), vertexBufferOffset);
1439                 vk.cmdDraw(*cmdBuffer, vertexCount, 1, 0, 0);
1440         }
1441         vk.cmdEndRenderPass(*cmdBuffer);
1442
1443         // Decompress reference image
1444         {
1445                 const VkImageMemoryBarrier refDstImageBarrier = makeImageMemoryBarrier(
1446                         VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1447                         VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
1448                         refDstImage->get(), subresourceRange);
1449
1450                 const VkBufferMemoryBarrier refDstBufferBarrier = makeBufferMemoryBarrier(
1451                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
1452                         refDstBuffer->get(), 0ull, dstBufferSize);
1453
1454                 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);
1455                 vk.cmdCopyImageToBuffer(*cmdBuffer, refDstImage->get(), VK_IMAGE_LAYOUT_GENERAL, refDstBuffer->get(), 1u, &copyRegion);
1456                 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);
1457         }
1458
1459         // Decompress result image
1460         {
1461                 const VkImageMemoryBarrier resDstImageBarrier = makeImageMemoryBarrier(
1462                         VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1463                         VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
1464                         resDstImage->get(), subresourceRange);
1465
1466                 const VkBufferMemoryBarrier resDstBufferBarrier = makeBufferMemoryBarrier(
1467                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
1468                         resDstBuffer->get(), 0ull, dstBufferSize);
1469
1470                 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);
1471                 vk.cmdCopyImageToBuffer(*cmdBuffer, resDstImage->get(), VK_IMAGE_LAYOUT_GENERAL, resDstBuffer->get(), 1u, &copyRegion);
1472                 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);
1473         }
1474
1475         endCommandBuffer(vk, *cmdBuffer);
1476
1477         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
1478
1479         // Compare decompressed pixel data in reference and result images
1480         {
1481                 const Allocation&       refDstBufferAlloc       = refDstBuffer->getAllocation();
1482                 invalidateMappedMemoryRange(vk, device, refDstBufferAlloc.getMemory(), refDstBufferAlloc.getOffset(), dstBufferSize);
1483
1484                 const Allocation&       resDstBufferAlloc       = resDstBuffer->getAllocation();
1485                 invalidateMappedMemoryRange(vk, device, resDstBufferAlloc.getMemory(), resDstBufferAlloc.getOffset(), dstBufferSize);
1486
1487                 return compareAndLog(refDstBufferAlloc.getHostPtr(), resDstBufferAlloc.getHostPtr(), (size_t)dstBufferSize);
1488         }
1489 }
1490
1491
1492 class GraphicsTextureTestInstance : public GraphicsAttachmentsTestInstance
1493 {
1494 public:
1495                                                 GraphicsTextureTestInstance             (Context& context, const TestParameters& parameters);
1496
1497 protected:
1498         virtual bool            isWriteToCompressedOperation    ();
1499         void                            transcode                                               (std::vector<deUint8>& srcData, std::vector<deUint8>& dstData, de::MovePtr<Image>& outputImage);
1500 };
1501
1502 GraphicsTextureTestInstance::GraphicsTextureTestInstance (Context& context, const TestParameters& parameters)
1503         : GraphicsAttachmentsTestInstance(context, parameters)
1504 {
1505 }
1506
1507 bool GraphicsTextureTestInstance::isWriteToCompressedOperation ()
1508 {
1509         return (m_parameters.operation == OPERATION_TEXTURE_WRITE);
1510 }
1511
1512 void GraphicsTextureTestInstance::transcode (std::vector<deUint8>& srcData, std::vector<deUint8>& dstData, de::MovePtr<Image>& outputImage)
1513 {
1514         const DeviceInterface&                                  vk                                              = m_context.getDeviceInterface();
1515         const VkDevice                                                  device                                  = m_context.getDevice();
1516         const deUint32                                                  queueFamilyIndex                = m_context.getUniversalQueueFamilyIndex();
1517         const VkQueue                                                   queue                                   = m_context.getUniversalQueue();
1518         Allocator&                                                              allocator                               = m_context.getDefaultAllocator();
1519
1520         const deUint32                                                  levelCount                              = m_layerSize[2];
1521         const VkImageSubresourceRange                   subresourceRange                = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, levelCount, 0u, m_arrayLayers);
1522         const UVec3                                                             compressedImageRes              = m_parameters.size;
1523         const UVec3                                                             uncompressedImageRes    = getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size);
1524         const VkImageCreateFlags*                               imgCreateFlagsOverride  = DE_NULL;
1525         const VkImageViewUsageCreateInfoKHR             imageViewUsageKHR               = makeImageViewUsageCreateInfo(m_parameters.compressedImageUsage);
1526         const VkImageViewUsageCreateInfoKHR*    imageViewUsageKHRNull   = (VkImageViewUsageCreateInfoKHR*)DE_NULL;
1527
1528         const VkFormat                                                  srcFormat                               = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? m_parameters.formatCompressed :
1529                                                                                                                                           (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.formatUncompressed :
1530                                                                                                                                           VK_FORMAT_UNDEFINED;
1531         const UVec3                                                             srcImageResolution              = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? compressedImageRes :
1532                                                                                                                                           (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? uncompressedImageRes :
1533                                                                                                                                           UVec3(0, 0, 0);
1534         const VkDeviceSize                                              srcImageSizeInBytes             = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? getCompressedImageData(srcFormat, srcImageResolution, srcData) :
1535                                                                                                                                           (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? getUncompressedImageData(srcFormat, srcImageResolution, srcData) :
1536                                                                                                                                           0;
1537         const VkImageUsageFlags                                 srcImageUsageFlags              = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? m_parameters.compressedImageUsage :
1538                                                                                                                                           (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.uncompressedImageUsage :
1539                                                                                                                                           0;
1540         const VkImageViewUsageCreateInfoKHR*    srcImageViewUsageKHR    = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? &imageViewUsageKHR :
1541                                                                                                                                           (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? imageViewUsageKHRNull :
1542                                                                                                                                           imageViewUsageKHRNull;
1543
1544         const VkFormat                                                  dstFormat                               = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? m_parameters.formatUncompressed :
1545                                                                                                                                           (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.formatCompressed :
1546                                                                                                                                           VK_FORMAT_UNDEFINED;
1547         const UVec3                                                             dstImageResolution              = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? uncompressedImageRes :
1548                                                                                                                                           (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? compressedImageRes :
1549                                                                                                                                           UVec3(0, 0, 0);
1550         const VkDeviceSize                                              dstImageSizeInBytes             = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? getUncompressedImageSizeInBytes(dstFormat, dstImageResolution) :
1551                                                                                                                                           (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? getCompressedImageSizeInBytes(dstFormat, dstImageResolution) :
1552                                                                                                                                           0;
1553         const VkImageUsageFlags                                 dstImageUsageFlags              = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? m_parameters.uncompressedImageUsage :
1554                                                                                                                                           (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.compressedImageUsage :
1555                                                                                                                                           0;
1556         const VkImageViewUsageCreateInfoKHR*    dstImageViewUsageKHR    = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? imageViewUsageKHRNull :
1557                                                                                                                                           (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? &imageViewUsageKHR :
1558                                                                                                                                           imageViewUsageKHRNull;
1559
1560         const std::vector<tcu::Vec4>                    vertexArray                             = createFullscreenQuad();
1561         const deUint32                                                  vertexCount                             = static_cast<deUint32>(vertexArray.size());
1562         const size_t                                                    vertexBufferSizeInBytes = vertexCount * sizeof(vertexArray[0]);
1563         const MovePtr<Buffer>                                   vertexBuffer                    = MovePtr<Buffer>(new Buffer(vk, device, allocator, makeBufferCreateInfo(vertexBufferSizeInBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible));
1564         const Allocation&                                               vertexBufferAlloc               = vertexBuffer->getAllocation();
1565         const VkDeviceSize                                              vertexBufferOffset[]    = { 0 };
1566
1567         const VkBufferCreateInfo                                srcImageBufferInfo              (makeBufferCreateInfo(srcImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT));
1568         const MovePtr<Buffer>                                   srcImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, srcImageBufferInfo, MemoryRequirement::HostVisible));
1569
1570         const VkImageCreateInfo                                 srcImageCreateInfo              = makeCreateImageInfo(srcFormat, m_parameters.imageType, srcImageResolution, srcImageUsageFlags, imgCreateFlagsOverride);
1571         const MovePtr<Image>                                    srcImage                                (new Image(vk, device, allocator, srcImageCreateInfo, MemoryRequirement::Any));
1572         Move<VkImageView>                                               srcImageView                    (makeImageView(vk, device, srcImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, subresourceRange, srcImageViewUsageKHR));
1573
1574         const VkImageCreateInfo                                 dstImageCreateInfo              = makeCreateImageInfo(dstFormat, m_parameters.imageType, dstImageResolution, dstImageUsageFlags, imgCreateFlagsOverride);
1575         de::MovePtr<Image>                                              dstImage                                (new Image(vk, device, allocator, dstImageCreateInfo, MemoryRequirement::Any));
1576         Move<VkImageView>                                               dstImageView                    (makeImageView(vk, device, dstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatUncompressed, subresourceRange, dstImageViewUsageKHR));
1577         const VkImageMemoryBarrier                              dstCopyImageBarrier             = makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, dstImage->get(), subresourceRange);
1578
1579         const VkBufferCreateInfo                                dstImageBufferInfo              (makeBufferCreateInfo(dstImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT));
1580         MovePtr<Buffer>                                                 dstImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, dstImageBufferInfo, MemoryRequirement::HostVisible));
1581
1582         const Unique<VkShaderModule>                    vertShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
1583         const Unique<VkShaderModule>                    fragShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
1584
1585         const Unique<VkRenderPass>                              renderPass                              (makeRenderPass(vk, device));
1586
1587         const Move<VkDescriptorSetLayout>               descriptorSetLayout             (DescriptorSetLayoutBuilder()
1588                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT)
1589                                                                                                                                                 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_FRAGMENT_BIT)
1590                                                                                                                                                 .build(vk, device));
1591         const Move<VkDescriptorPool>                    descriptorPool                  (DescriptorPoolBuilder()
1592                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, m_arrayLayers)
1593                                                                                                                                                 .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, m_arrayLayers)
1594                                                                                                                                                 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, m_arrayLayers));
1595         const Move<VkDescriptorSet>                             descriptorSet                   (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
1596         const VkSamplerCreateInfo                               srcSamplerInfo                  (makeSamplerCreateInfo());
1597         const Move<VkSampler>                                   srcSampler                              = vk::createSampler(vk, device, &srcSamplerInfo);
1598         const VkDescriptorImageInfo                             descriptorSrcImage              (makeDescriptorImageInfo(*srcSampler, *srcImageView, VK_IMAGE_LAYOUT_GENERAL));
1599         const VkDescriptorImageInfo                             descriptorDstImage              (makeDescriptorImageInfo(DE_NULL, *dstImageView, VK_IMAGE_LAYOUT_GENERAL));
1600
1601         const VkExtent2D                                                renderSize                              (makeExtent2D(uncompressedImageRes[0], uncompressedImageRes[1]));
1602         const Unique<VkPipelineLayout>                  pipelineLayout                  (makePipelineLayout(vk, device, *descriptorSetLayout));
1603         const Unique<VkPipeline>                                pipeline                                (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertShaderModule, *fragShaderModule, renderSize, 0u));
1604         const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, device, VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT, queueFamilyIndex));
1605         const Unique<VkCommandBuffer>                   cmdBuffer                               (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
1606
1607         const VkBufferImageCopy                                 srcCopyRegion                   = makeBufferImageCopy(srcImageResolution[0], srcImageResolution[1]);
1608         const VkBufferMemoryBarrier                             srcCopyBufferBarrier    = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, srcImageBuffer->get(), 0ull, srcImageSizeInBytes);
1609         const VkImageMemoryBarrier                              srcCopyImageBarrier             = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, srcImage->get(), subresourceRange);
1610         const VkImageMemoryBarrier                              srcCopyImageBarrierPost = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, srcImage->get(), subresourceRange);
1611
1612         const VkBufferImageCopy                                 dstCopyRegion                   = makeBufferImageCopy(dstImageResolution[0], dstImageResolution[1]);
1613
1614         const VkExtent2D                                                framebufferSize                 (makeExtent2D(dstImageResolution[0], dstImageResolution[1]));
1615         const Move<VkFramebuffer>                               framebuffer                             (makeFramebuffer(vk, device, *renderPass, 0, DE_NULL, framebufferSize, m_arrayLayers));
1616
1617         DE_ASSERT(srcImageSizeInBytes == dstImageSizeInBytes);
1618
1619         // Upload vertex data
1620         deMemcpy(vertexBufferAlloc.getHostPtr(), &vertexArray[0], vertexBufferSizeInBytes);
1621         flushMappedMemoryRange(vk, device, vertexBufferAlloc.getMemory(), vertexBufferAlloc.getOffset(), vertexBufferSizeInBytes);
1622
1623         // Upload source image data
1624         const Allocation& alloc = srcImageBuffer->getAllocation();
1625         deMemcpy(alloc.getHostPtr(), &srcData[0], (size_t)srcImageSizeInBytes);
1626         flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), srcImageSizeInBytes);
1627
1628         beginCommandBuffer(vk, *cmdBuffer);
1629         vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1630
1631         //Copy buffer to image
1632         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrier, 1u, &srcCopyImageBarrier);
1633         vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_GENERAL, 1u, &srcCopyRegion);
1634         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1u, &srcCopyImageBarrierPost);
1635
1636         // Make source image readable
1637         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, &dstCopyImageBarrier);
1638
1639         beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
1640
1641         for (deUint32 layerNdx = 0; layerNdx < m_arrayLayers; ++layerNdx)
1642         {
1643                 DescriptorSetUpdateBuilder()
1644                         .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorSrcImage)
1645                         .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorDstImage)
1646                         .update(vk, device);
1647
1648                 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
1649                 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer->get(), vertexBufferOffset);
1650                 vk.cmdDraw(*cmdBuffer, vertexCount, 1, 0, 0);
1651         }
1652
1653         vk.cmdEndRenderPass(*cmdBuffer);
1654
1655         const VkImageMemoryBarrier prepareForTransferBarrier = makeImageMemoryBarrier(
1656                 VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
1657                 VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
1658                 dstImage->get(), subresourceRange);
1659
1660         const VkBufferMemoryBarrier copyBarrier = makeBufferMemoryBarrier(
1661                 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
1662                 dstImageBuffer->get(), 0ull, dstImageSizeInBytes);
1663
1664         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);
1665         vk.cmdCopyImageToBuffer(*cmdBuffer, dstImage->get(), VK_IMAGE_LAYOUT_GENERAL, dstImageBuffer->get(), 1u, &dstCopyRegion);
1666         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);
1667
1668         endCommandBuffer(vk, *cmdBuffer);
1669
1670         submitCommandsAndWait(vk, device, queue, *cmdBuffer);
1671
1672         const Allocation& dstImageBufferAlloc = dstImageBuffer->getAllocation();
1673         invalidateMappedMemoryRange(vk, device, dstImageBufferAlloc.getMemory(), dstImageBufferAlloc.getOffset(), dstImageSizeInBytes);
1674         dstData.resize((size_t)dstImageSizeInBytes);
1675         deMemcpy(&dstData[0], dstImageBufferAlloc.getHostPtr(), (size_t)dstImageSizeInBytes);
1676
1677         outputImage = dstImage;
1678 }
1679
1680
1681 class TexelViewCompatibleCase : public TestCase
1682 {
1683 public:
1684                                                         TexelViewCompatibleCase         (TestContext&                           testCtx,
1685                                                                                                                  const std::string&                     name,
1686                                                                                                                  const std::string&                     desc,
1687                                                                                                                  const TestParameters&          parameters);
1688         void                                    initPrograms                            (SourceCollections&                     programCollection) const;
1689         TestInstance*                   createInstance                          (Context&                                       context) const;
1690 protected:
1691         const TestParameters    m_parameters;
1692 };
1693
1694 TexelViewCompatibleCase::TexelViewCompatibleCase (TestContext& testCtx, const std::string& name, const std::string& desc, const TestParameters& parameters)
1695         : TestCase                              (testCtx, name, desc)
1696         , m_parameters                  (parameters)
1697 {
1698 }
1699
1700 void TexelViewCompatibleCase::initPrograms (vk::SourceCollections&      programCollection) const
1701 {
1702         switch (m_parameters.shader)
1703         {
1704                 case SHADER_TYPE_COMPUTE:
1705                 {
1706                         const std::string       imageTypeStr            = getShaderImageType(mapVkFormat(m_parameters.formatUncompressed), m_parameters.imageType);
1707                         const std::string       formatQualifierStr      = getShaderImageFormatQualifier(mapVkFormat(m_parameters.formatUncompressed));
1708                         std::ostringstream      src;
1709                         std::ostringstream      src_decompress;
1710
1711                         src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
1712                                 << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n\n";
1713                         src_decompress << src.str();
1714
1715                         switch(m_parameters.operation)
1716                         {
1717                                 case OPERATION_IMAGE_LOAD:
1718                                 {
1719                                         src << "layout (binding = 0, "<<formatQualifierStr<<") readonly uniform "<<imageTypeStr<<" u_image0;\n"
1720                                                 << "layout (binding = 1, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" u_image1;\n\n"
1721                                                 << "void main (void)\n"
1722                                                 << "{\n"
1723                                                 << "    ivec2 pos = ivec2(gl_GlobalInvocationID.xy);\n"
1724                                                 << "    imageStore(u_image1, pos, imageLoad(u_image0, pos));\n"
1725                                                 << "}\n";
1726
1727                                         break;
1728                                 }
1729
1730                                 case OPERATION_TEXEL_FETCH:
1731                                 {
1732                                         src << "layout (binding = 0) uniform "<<getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(m_parameters.imageType))<<" u_image0;\n"
1733                                                 << "layout (binding = 1, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" u_image1;\n\n"
1734                                                 << "void main (void)\n"
1735                                                 << "{\n"
1736                                                 << "    ivec3 pos = ivec3(gl_GlobalInvocationID.xyz);\n"
1737                                                 << "    imageStore(u_image1, pos.xy, texelFetch(u_image0, pos.xy, pos.z));\n"
1738                                                 << "}\n";
1739
1740                                         break;
1741                                 }
1742
1743                                 case OPERATION_TEXTURE:
1744                                 {
1745                                         src << "layout (binding = 0) uniform "<<getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(m_parameters.imageType))<<" u_image0;\n"
1746                                                 << "layout (binding = 1, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" u_image1;\n\n"
1747                                                 << "void main (void)\n"
1748                                                 << "{\n"
1749                                                 << "    ivec2 pos = ivec2(gl_GlobalInvocationID.xy);\n"
1750                                                 << "    imageStore(u_image1, pos, texture(u_image0, pos));\n"
1751                                                 << "}\n";
1752
1753                                         break;
1754                                 }
1755
1756                                 case OPERATION_IMAGE_STORE:
1757                                 {
1758                                         src << "layout (binding = 0, "<<formatQualifierStr<<") uniform "<<imageTypeStr<<"           u_image0;\n"
1759                                                 << "layout (binding = 1, "<<formatQualifierStr<<") readonly uniform "<<imageTypeStr<<"  u_image1;\n"
1760                                                 << "layout (binding = 2, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" u_image2;\n\n"
1761                                                 << "void main (void)\n"
1762                                                 << "{\n"
1763                                                 << "    ivec2 pos = ivec2(gl_GlobalInvocationID.xy);\n"
1764                                                 << "    imageStore(u_image0, pos, imageLoad(u_image1, pos));\n"
1765                                                 << "    imageStore(u_image2, pos, imageLoad(u_image0, pos));\n"
1766                                                 << "}\n";
1767
1768                                         break;
1769                                 }
1770
1771                                 default:
1772                                         DE_ASSERT(false);
1773                         }
1774
1775                         src_decompress  << "layout (binding = 0) uniform "<<getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(m_parameters.imageType))<<" compressed_result;\n"
1776                                                         << "layout (binding = 1) uniform "<<getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(m_parameters.imageType))<<" compressed_reference;\n"
1777                                                         << "layout (binding = 2, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" decompressed_result;\n"
1778                                                         << "layout (binding = 3, "<<formatQualifierStr<<") writeonly uniform "<<imageTypeStr<<" decompressed_reference;\n\n"
1779                                                         << "void main (void)\n"
1780                                                         << "{\n"
1781                                                         << "    ivec2 pos = ivec2(gl_GlobalInvocationID.xy);\n"
1782                                                         << "    imageStore(decompressed_result, pos, texture(compressed_result, pos));\n"
1783                                                         << "    imageStore(decompressed_reference, pos, texture(compressed_reference, pos));\n"
1784                                                         << "}\n";
1785                         programCollection.glslSources.add("comp") << glu::ComputeSource(src.str());
1786                         programCollection.glslSources.add("decompress") << glu::ComputeSource(src_decompress.str());
1787
1788                         break;
1789                 }
1790
1791                 case SHADER_TYPE_FRAGMENT:
1792                 {
1793                         DE_ASSERT(m_parameters.size[0] > 0);
1794                         DE_ASSERT(m_parameters.size[1] > 0);
1795
1796                         // Vertex shader
1797                         {
1798                                 std::ostringstream src;
1799                                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
1800                                         << "layout(location = 0) in vec4 v_in_position;\n"
1801                                         << "\n"
1802                                         << "void main (void)\n"
1803                                         << "{\n"
1804                                         << "    gl_Position = v_in_position;\n"
1805                                         << "}\n";
1806
1807                                 programCollection.glslSources.add("vert") << glu::VertexSource(src.str());
1808                         }
1809
1810                         // Fragment shader
1811                         {
1812                                 switch(m_parameters.operation)
1813                                 {
1814                                         case OPERATION_ATTACHMENT_READ:
1815                                         case OPERATION_ATTACHMENT_WRITE:
1816                                         {
1817                                                 std::ostringstream      src;
1818
1819                                                 const std::string       dstTypeStr      = getGlslFormatType(m_parameters.formatUncompressed);
1820                                                 const std::string       srcTypeStr      = getGlslInputFormatType(m_parameters.formatUncompressed);
1821
1822                                                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
1823                                                         << "precision highp int;\n"
1824                                                         << "precision highp float;\n"
1825                                                         << "\n"
1826                                                         << "layout (location = 0) out highp " << dstTypeStr << " o_color;\n"
1827                                                         << "layout (input_attachment_index = 0, set = 0, binding = 0) uniform highp " << srcTypeStr << " inputImage1;\n"
1828                                                         << "\n"
1829                                                         << "void main (void)\n"
1830                                                         << "{\n"
1831                                                         << "    o_color = " << dstTypeStr << "(subpassLoad(inputImage1));\n"
1832                                                         << "}\n";
1833
1834                                                 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str());
1835
1836                                                 break;
1837                                         }
1838
1839                                         case OPERATION_TEXTURE_READ:
1840                                         case OPERATION_TEXTURE_WRITE:
1841                                         {
1842                                                 std::ostringstream      src;
1843
1844                                                 const std::string       srcSamplerTypeStr               = getGlslSamplerType(mapVkFormat(m_parameters.formatUncompressed), mapImageViewType(m_parameters.imageType));
1845                                                 const std::string       dstImageTypeStr                 = getShaderImageType(mapVkFormat(m_parameters.formatUncompressed), m_parameters.imageType);
1846                                                 const std::string       dstFormatQualifierStr   = getShaderImageFormatQualifier(mapVkFormat(m_parameters.formatUncompressed));
1847                                                 const UVec3                     uncompressedImageRes    = getCompressedImageResolutionInBlocks(m_parameters.formatCompressed, m_parameters.size);
1848
1849                                                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
1850                                                         << "layout (binding = 0) uniform " << srcSamplerTypeStr << " u_imageIn;\n"
1851                                                         << "layout (binding = 1, " << dstFormatQualifierStr << ") writeonly uniform " << dstImageTypeStr << " u_imageOut;\n"
1852                                                         << "\n"
1853                                                         << "void main (void)\n"
1854                                                         << "{\n"
1855                                                         << "    const ivec2 out_pos = ivec2(gl_FragCoord.xy);\n"
1856                                                         << "    const ivec2 pixels_resolution = ivec2(" << uncompressedImageRes[0] - 1 << ", " << uncompressedImageRes[1] - 1 << ");\n"
1857                                                         << "    const vec2 in_pos = vec2(out_pos) / vec2(pixels_resolution);\n"
1858                                                         << "    imageStore(u_imageOut, out_pos, texture(u_imageIn, in_pos));\n"
1859                                                         << "}\n";
1860
1861                                                 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str());
1862
1863                                                 break;
1864                                         }
1865
1866                                         default:
1867                                                 DE_ASSERT(false);
1868                                 }
1869                         }
1870
1871                         // Verification fragment shader
1872                         {
1873                                 switch(m_parameters.operation)
1874                                 {
1875                                         case OPERATION_ATTACHMENT_WRITE:
1876                                         case OPERATION_TEXTURE_WRITE:
1877                                         {
1878                                                 std::ostringstream      src;
1879
1880                                                 const std::string       samplerType                     = getGlslSamplerType(mapVkFormat(m_parameters.formatForVerify), mapImageViewType(m_parameters.imageType));
1881                                                 const std::string       imageTypeStr            = getShaderImageType(mapVkFormat(m_parameters.formatForVerify), m_parameters.imageType);
1882                                                 const std::string       formatQualifierStr      = getShaderImageFormatQualifier(mapVkFormat(m_parameters.formatForVerify));
1883
1884                                                 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
1885                                                         << "layout (binding = 0) uniform " << samplerType << " u_imageIn0;\n"
1886                                                         << "layout (binding = 1) uniform " << samplerType << " u_imageIn1;\n"
1887                                                         << "layout (binding = 2, " << formatQualifierStr << ") writeonly uniform " << imageTypeStr << " u_imageOut0;\n"
1888                                                         << "layout (binding = 3, " << formatQualifierStr << ") writeonly uniform " << imageTypeStr << " u_imageOut1;\n"
1889                                                         << "\n"
1890                                                         << "void main (void)\n"
1891                                                         << "{\n"
1892                                                         << "    const ivec2 out_pos = ivec2(gl_FragCoord.xy);\n"
1893                                                         << "    const ivec2 pixels_resolution = ivec2(" << m_parameters.size[0] - 1 << ", " << m_parameters.size[1] - 1 << ");\n"
1894                                                         << "    const vec2 in_pos = vec2(out_pos) / vec2(pixels_resolution);\n"
1895                                                         << "    imageStore(u_imageOut0, out_pos, texture(u_imageIn0, in_pos));\n"
1896                                                         << "    imageStore(u_imageOut1, out_pos, texture(u_imageIn1, in_pos));\n"
1897                                                         << "}\n";
1898
1899                                                 programCollection.glslSources.add("frag_verify") << glu::FragmentSource(src.str());
1900
1901                                                 break;
1902                                         }
1903
1904                                         case OPERATION_ATTACHMENT_READ:
1905                                         case OPERATION_TEXTURE_READ:
1906                                                 // Read operations do not have sampling verification
1907                                                 break;
1908
1909                                         default:
1910                                                 DE_ASSERT(false);
1911                                 }
1912                         }
1913
1914                         break;
1915                 }
1916
1917                 default:
1918                         DE_ASSERT(false);
1919         }
1920 }
1921
1922 TestInstance* TexelViewCompatibleCase::createInstance (Context& context) const
1923 {
1924         const VkPhysicalDevice                  physicalDevice                  = context.getPhysicalDevice();
1925         const InstanceInterface&                vk                                              = context.getInstanceInterface();
1926
1927         DE_ASSERT(getNumLayers(m_parameters.imageType, m_parameters.size)     == 1u);
1928         DE_ASSERT(getLayerSize(m_parameters.imageType, m_parameters.size).z() == 1u);
1929         DE_ASSERT(getLayerSize(m_parameters.imageType, m_parameters.size).x() >  0u);
1930         DE_ASSERT(getLayerSize(m_parameters.imageType, m_parameters.size).y() >  0u);
1931
1932         if (std::find(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance2") == context.getDeviceExtensions().end())
1933                 TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance2 not supported");
1934
1935         {
1936                 VkImageFormatProperties imageFormatProperties;
1937
1938                 if (VK_ERROR_FORMAT_NOT_SUPPORTED == vk.getPhysicalDeviceImageFormatProperties(physicalDevice, m_parameters.formatUncompressed,
1939                                                                                                 mapImageType(m_parameters.imageType), VK_IMAGE_TILING_OPTIMAL,
1940                                                                                                 m_parameters.uncompressedImageUsage, 0u, &imageFormatProperties))
1941                         TCU_THROW(NotSupportedError, "Operation not supported with this image format");
1942
1943                 if (VK_ERROR_FORMAT_NOT_SUPPORTED == vk.getPhysicalDeviceImageFormatProperties(physicalDevice, m_parameters.formatCompressed,
1944                                                                                                 mapImageType(m_parameters.imageType), VK_IMAGE_TILING_OPTIMAL,
1945                                                                                                 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1946                                                                                                 VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR,
1947                                                                                                 &imageFormatProperties))
1948                         TCU_THROW(NotSupportedError, "Operation not supported with this image format");
1949         }
1950
1951         {
1952                 const VkPhysicalDeviceFeatures  physicalDeviceFeatures  = getPhysicalDeviceFeatures (vk, physicalDevice);
1953
1954                 if (deInRange32(m_parameters.formatCompressed, VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_BC7_SRGB_BLOCK) &&
1955                         !physicalDeviceFeatures.textureCompressionBC)
1956                         TCU_THROW(NotSupportedError, "textureCompressionBC not supported");
1957
1958                 if (deInRange32(m_parameters.formatCompressed, VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, VK_FORMAT_EAC_R11G11_SNORM_BLOCK) &&
1959                         !physicalDeviceFeatures.textureCompressionETC2)
1960                         TCU_THROW(NotSupportedError, "textureCompressionETC2 not supported");
1961
1962                 if (deInRange32(m_parameters.formatCompressed, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_FORMAT_ASTC_12x12_SRGB_BLOCK) &&
1963                         !physicalDeviceFeatures.textureCompressionASTC_LDR)
1964                         TCU_THROW(NotSupportedError, "textureCompressionASTC_LDR not supported");
1965         }
1966
1967         switch (m_parameters.shader)
1968         {
1969                 case SHADER_TYPE_COMPUTE:
1970                 {
1971                         switch (m_parameters.operation)
1972                         {
1973                                 case OPERATION_IMAGE_LOAD:
1974                                 case OPERATION_TEXEL_FETCH:
1975                                 case OPERATION_TEXTURE:
1976                                         return new BasicComputeTestInstance(context, m_parameters);
1977                                 case OPERATION_IMAGE_STORE:
1978                                         return new ImageStoreComputeTestInstance(context, m_parameters);
1979                                 default:
1980                                         TCU_THROW(InternalError, "Impossible");
1981                         }
1982                 }
1983
1984                 case SHADER_TYPE_FRAGMENT:
1985                 {
1986                         switch (m_parameters.operation)
1987                         {
1988                                 case OPERATION_ATTACHMENT_READ:
1989                                 case OPERATION_ATTACHMENT_WRITE:
1990                                         return new GraphicsAttachmentsTestInstance(context, m_parameters);
1991
1992                                 case OPERATION_TEXTURE_READ:
1993                                 case OPERATION_TEXTURE_WRITE:
1994                                         return new GraphicsTextureTestInstance(context, m_parameters);
1995
1996                                 default:
1997                                         TCU_THROW(InternalError, "Impossible");
1998                         }
1999                 }
2000
2001                 default:
2002                         TCU_THROW(InternalError, "Impossible");
2003         }
2004 }
2005
2006 } // anonymous ns
2007
2008
2009 tcu::TestCaseGroup* createImageCompressionTranscodingTests (tcu::TestContext& testCtx)
2010 {
2011         MovePtr<tcu::TestCaseGroup>     texelViewCompatibleTests                                                (new tcu::TestCaseGroup(testCtx, "texel_view_compatible", "Texel view compatible cases"));
2012
2013         struct FormatsArray
2014         {
2015                 const VkFormat* formats;
2016                 deUint32                count;
2017         };
2018
2019         const std::string                       pipelineName[SHADER_TYPE_LAST]                                  =
2020         {
2021                 "compute",
2022                 "graphic",
2023         };
2024
2025         const std::string                       operationName[OPERATION_LAST]                                   =
2026         {
2027                 "image_load",
2028                 "texel_fetch",
2029                 "texture",
2030                 "image_store",
2031                 "attachment_read",
2032                 "attachment_write",
2033                 "texture_read",
2034                 "texture_write",
2035         };
2036
2037         const VkImageUsageFlags         baseImageUsageFlagSet                                                   = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2038         const VkImageUsageFlags         compressedImageUsageFlags[OPERATION_LAST]               =
2039         {
2040                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_STORAGE_BIT),                                                                                  // "image_load"
2041                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT),                             // "texel_fetch"
2042                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT),                             // "texture"
2043                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT),                             // "image_store"
2044                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT),    // "attachment_read"
2045                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT),    // "attachment_write"
2046                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT),                                                                                  // "texture_read"
2047                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT),                             // "texture_write"
2048         };
2049
2050         const VkImageUsageFlags         uncompressedImageUsageFlags[OPERATION_LAST]             =
2051         {
2052                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_STORAGE_BIT),                                                                                  //"image_load"
2053                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT),                             //"texel_fetch"
2054                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT),                             //"texture"
2055                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT),                             //"image_store"
2056                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT),    //"attachment_read"
2057                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT),                                                                 //"attachment_write"
2058                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT),                             //"texture_read"
2059                 baseImageUsageFlagSet | static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_SAMPLED_BIT),                                                                                  //"texture_write"
2060         };
2061
2062         const VkFormat                          compressedFormats64bit[]                                                =
2063         {
2064                 VK_FORMAT_BC1_RGB_UNORM_BLOCK,
2065                 VK_FORMAT_BC1_RGB_SRGB_BLOCK,
2066                 VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
2067                 VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
2068                 VK_FORMAT_BC4_UNORM_BLOCK,
2069                 VK_FORMAT_BC4_SNORM_BLOCK,
2070                 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
2071                 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
2072                 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
2073                 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
2074                 VK_FORMAT_EAC_R11_UNORM_BLOCK,
2075                 VK_FORMAT_EAC_R11_SNORM_BLOCK,
2076         };
2077
2078         const VkFormat                          compressedFormats128bit[]                                               =
2079         {
2080                 VK_FORMAT_BC2_UNORM_BLOCK,
2081                 VK_FORMAT_BC2_SRGB_BLOCK,
2082                 VK_FORMAT_BC3_UNORM_BLOCK,
2083                 VK_FORMAT_BC3_SRGB_BLOCK,
2084                 VK_FORMAT_BC5_UNORM_BLOCK,
2085                 VK_FORMAT_BC5_SNORM_BLOCK,
2086                 VK_FORMAT_BC6H_UFLOAT_BLOCK,
2087                 VK_FORMAT_BC6H_SFLOAT_BLOCK,
2088                 VK_FORMAT_BC7_UNORM_BLOCK,
2089                 VK_FORMAT_BC7_SRGB_BLOCK,
2090                 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
2091                 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
2092                 VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
2093                 VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
2094                 VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
2095                 VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
2096                 VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
2097                 VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
2098                 VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
2099                 VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
2100                 VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
2101                 VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
2102                 VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
2103                 VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
2104                 VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
2105                 VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
2106                 VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
2107                 VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
2108                 VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
2109                 VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
2110                 VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
2111                 VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
2112                 VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
2113                 VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
2114                 VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
2115                 VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
2116                 VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
2117                 VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
2118                 VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
2119                 VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
2120                 VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
2121                 VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
2122         };
2123
2124         const VkFormat                          uncompressedFormats64bit[]                                              =
2125         {
2126                 VK_FORMAT_R16G16B16A16_UNORM,
2127                 VK_FORMAT_R16G16B16A16_SNORM,
2128                 VK_FORMAT_R16G16B16A16_USCALED,
2129                 VK_FORMAT_R16G16B16A16_SSCALED,
2130                 VK_FORMAT_R16G16B16A16_UINT,
2131                 VK_FORMAT_R16G16B16A16_SINT,
2132                 VK_FORMAT_R16G16B16A16_SFLOAT,
2133                 VK_FORMAT_R32G32_UINT,
2134                 VK_FORMAT_R32G32_SINT,
2135                 VK_FORMAT_R32G32_SFLOAT,
2136                 //VK_FORMAT_R64_UINT, remove from the test it couln'd not be use
2137                 //VK_FORMAT_R64_SINT, remove from the test it couln'd not be use
2138                 //VK_FORMAT_R64_SFLOAT, remove from the test it couln'd not be use
2139         };
2140
2141         const VkFormat                          uncompressedFormats128bit[]                                             =
2142         {
2143                 VK_FORMAT_R32G32B32A32_UINT,
2144                 VK_FORMAT_R32G32B32A32_SINT,
2145                 VK_FORMAT_R32G32B32A32_SFLOAT,
2146                 //VK_FORMAT_R64G64_UINT, remove from the test it couln'd not be use
2147                 //VK_FORMAT_R64G64_SINT, remove from the test it couln'd not be use
2148                 //VK_FORMAT_R64G64_SFLOAT, remove from the test it couln'd not be use
2149         };
2150
2151         const FormatsArray                      formatsCompressed[]                                                             =
2152         {
2153                 {
2154                         compressedFormats64bit,
2155                         DE_LENGTH_OF_ARRAY(compressedFormats64bit)
2156                 },
2157                 {
2158                         compressedFormats128bit,
2159                         DE_LENGTH_OF_ARRAY(compressedFormats128bit)
2160                 },
2161         };
2162
2163         const FormatsArray                      formatsUncompressed[]                                                   =
2164         {
2165                 {
2166                         uncompressedFormats64bit,
2167                         DE_LENGTH_OF_ARRAY(uncompressedFormats64bit)
2168                 },
2169                 {
2170                         uncompressedFormats128bit,
2171                         DE_LENGTH_OF_ARRAY(uncompressedFormats128bit)
2172                 },
2173         };
2174
2175         const bool                                      mipmapTest                                                                              = false; // TODO
2176         const deUint32                          unniceMipmapTextureSize[]                                               = { 1, 1, 1, 2, 6, 8, 21, 51, 92, 209, 295, 512, 1134 };
2177
2178         DE_ASSERT(DE_LENGTH_OF_ARRAY(formatsCompressed) == DE_LENGTH_OF_ARRAY(formatsUncompressed));
2179
2180         for (int shaderType = SHADER_TYPE_COMPUTE; shaderType < SHADER_TYPE_LAST; ++shaderType)
2181         {
2182                 MovePtr<tcu::TestCaseGroup>     pipelineTypeGroup       (new tcu::TestCaseGroup(testCtx, pipelineName[shaderType].c_str(), ""));
2183
2184                 for (int operationNdx = OPERATION_IMAGE_LOAD; operationNdx < OPERATION_LAST; ++operationNdx)
2185                 {
2186                         if (shaderType != SHADER_TYPE_FRAGMENT && deInRange32(operationNdx, OPERATION_ATTACHMENT_READ, OPERATION_TEXTURE_WRITE))
2187                                 continue;
2188
2189                         if (shaderType != SHADER_TYPE_COMPUTE && deInRange32(operationNdx, OPERATION_IMAGE_LOAD, OPERATION_IMAGE_STORE))
2190                                 continue;
2191
2192                         MovePtr<tcu::TestCaseGroup>     imageOperationGroup     (new tcu::TestCaseGroup(testCtx, operationName[operationNdx].c_str(), ""));
2193
2194                         // Iterate through bitness groups (64 bit, 128 bit, etc)
2195                         for (deUint32 formatBitnessGroup = 0; formatBitnessGroup < DE_LENGTH_OF_ARRAY(formatsCompressed); ++formatBitnessGroup)
2196                         {
2197                                 for (deUint32 formatCompressedNdx = 0; formatCompressedNdx < formatsCompressed[formatBitnessGroup].count; ++formatCompressedNdx)
2198                                 {
2199                                         const VkFormat                          formatCompressed                        = formatsCompressed[formatBitnessGroup].formats[formatCompressedNdx];
2200                                         const std::string                       compressedFormatGroupName       = getFormatShortString(formatCompressed);
2201                                         MovePtr<tcu::TestCaseGroup>     compressedFormatGroup           (new tcu::TestCaseGroup(testCtx, compressedFormatGroupName.c_str(), ""));
2202
2203                                         for (deUint32 formatUncompressedNdx = 0; formatUncompressedNdx < formatsUncompressed[formatBitnessGroup].count; ++formatUncompressedNdx)
2204                                         {
2205                                                 const VkFormat                  formatUncompressed                      = formatsUncompressed[formatBitnessGroup].formats[formatUncompressedNdx];
2206                                                 const std::string               uncompressedFormatGroupName     = getFormatShortString(formatUncompressed);
2207                                                 const deUint32                  testTextureWidth                        = mipmapTest
2208                                                                                                                                                         ? unniceMipmapTextureSize[getBlockWidth(formatCompressed)]
2209                                                                                                                                                         : 64u;
2210                                                 const deUint32                  testTextureHeight                       = mipmapTest
2211                                                                                                                                                         ? unniceMipmapTextureSize[getBlockWidth(formatCompressed)]
2212                                                                                                                                                         : 64u;
2213                                                 const TestParameters    parameters                                      =
2214                                                 {
2215                                                         static_cast<Operation>(operationNdx),
2216                                                         static_cast<ShaderType>(shaderType),
2217                                                         UVec3(testTextureWidth, testTextureHeight, 1u),
2218                                                         IMAGE_TYPE_2D,
2219                                                         formatCompressed,
2220                                                         formatUncompressed,
2221                                                         (operationNdx == OPERATION_IMAGE_STORE) ? 3u : 2u,
2222                                                         compressedImageUsageFlags[operationNdx],
2223                                                         uncompressedImageUsageFlags[operationNdx],
2224                                                         false,
2225                                                         VK_FORMAT_R8G8B8A8_UNORM
2226                                                 };
2227
2228                                                 compressedFormatGroup->addChild(new TexelViewCompatibleCase(testCtx, uncompressedFormatGroupName, "", parameters));
2229                                         }
2230
2231                                         imageOperationGroup->addChild(compressedFormatGroup.release());
2232                                 }
2233                         }
2234
2235                         pipelineTypeGroup->addChild(imageOperationGroup.release());
2236                 }
2237
2238                 texelViewCompatibleTests->addChild(pipelineTypeGroup.release());
2239         }
2240
2241         return texelViewCompatibleTests.release();
2242 }
2243
2244 } // image
2245 } // vkt