external/vulkancts/modules/vulkan/api/vktApiCopiesAndBlittingTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015-2016 The Khronos Group Inc.
   6  * Copyright (c) 2015-2016 Samsung Electronics Co., Ltd.
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  *//*!
  21  * \file
  22  * \brief Vulkan Copies And Blitting Tests
  23  *//*--------------------------------------------------------------------*/
  24
  25 #include "vktApiCopiesAndBlittingTests.hpp"
  26
  27 #include "deStringUtil.hpp"
  28 #include "deUniquePtr.hpp"
  29
  30 #include "tcuImageCompare.hpp"
  31 #include "tcuTexture.hpp"
  32 #include "tcuTextureUtil.hpp"
  33 #include "tcuVectorType.hpp"
  34 #include "tcuVectorUtil.hpp"
  35
  36 #include "vkImageUtil.hpp"
  37 #include "vkMemUtil.hpp"
  38 #include "vkPrograms.hpp"
  39 #include "vkQueryUtil.hpp"
  40 #include "vkRefUtil.hpp"
  41 #include "vktTestCase.hpp"
  42 #include "vktTestCaseUtil.hpp"
  43 #include "vkTypeUtil.hpp"
  44
  45 namespace vkt
  46 {
  47
  48 namespace api
  49 {
  50
  51 namespace
  52 {
  53 enum MirrorMode
  54 {
  55         MIRROR_MODE_NONE = 0,
  56         MIRROR_MODE_X = (1<<0),
  57         MIRROR_MODE_Y = (1<<1),
  58         MIRROR_MODE_XY = MIRROR_MODE_X | MIRROR_MODE_Y,
  59
  60         MIRROR_MODE_LAST
  61 };
  62
  63 }
  64
  65 using namespace vk;
  66
  67 static VkImageAspectFlags getAspectFlags (tcu::TextureFormat format)
  68 {
  69         VkImageAspectFlags      aspectFlag      = 0;
  70         aspectFlag |= (tcu::hasDepthComponent(format.order)? VK_IMAGE_ASPECT_DEPTH_BIT : 0);
  71         aspectFlag |= (tcu::hasStencilComponent(format.order)? VK_IMAGE_ASPECT_STENCIL_BIT : 0);
  72
  73         if (!aspectFlag)
  74                 aspectFlag = VK_IMAGE_ASPECT_COLOR_BIT;
  75
  76         return aspectFlag;
  77 }
  78
  79 namespace
  80 {
  81
  82 union CopyRegion
  83 {
  84         VkBufferCopy            bufferCopy;
  85         VkImageCopy                     imageCopy;
  86         VkBufferImageCopy       bufferImageCopy;
  87         VkImageBlit                     imageBlit;
  88         VkImageResolve          imageResolve;
  89 };
  90
  91 struct ImageParms
  92 {
  93         VkImageType             imageType;
  94         VkFormat                format;
  95         VkExtent3D              extent;
  96 };
  97
  98 struct TestParams
  99 {
 100         union Data
 101         {
 102                 struct Buffer
 103                 {
 104                         VkDeviceSize    size;
 105                 } buffer;
 106
 107                 ImageParms      image;
 108         } src, dst;
 109
 110         std::vector<CopyRegion> regions;
 111
 112         union
 113         {
 114                 VkFilter                                filter;
 115                 VkSampleCountFlagBits   samples;
 116         };
 117 };
 118
 119 inline deUint32 getArraySize(const ImageParms& parms)
 120 {
 121         return (parms.imageType == VK_IMAGE_TYPE_2D) ? parms.extent.depth : 1u;
 122 }
 123
 124 inline VkExtent3D getExtent3D(const ImageParms& parms)
 125 {
 126         const VkExtent3D                extent                                  =
 127         {
 128                 parms.extent.width,
 129                 parms.extent.height,
 130                 (parms.imageType == VK_IMAGE_TYPE_2D) ? 1u : parms.extent.depth
 131         };
 132         return extent;
 133 }
 134
 135 class CopiesAndBlittingTestInstance : public vkt::TestInstance
 136 {
 137 public:
 138                                                                                 CopiesAndBlittingTestInstance           (Context&       context,
 139                                                                                                                                                          TestParams     testParams);
 140         virtual tcu::TestStatus                         iterate                                                         (void) = 0;
 141
 142         enum FillMode
 143         {
 144                 FILL_MODE_GRADIENT = 0,
 145                 FILL_MODE_WHITE,
 146                 FILL_MODE_RED,
 147                 FILL_MODE_MULTISAMPLE,
 148
 149                 FILL_MODE_LAST
 150         };
 151
 152 protected:
 153         const TestParams                                        m_params;
 154
 155         Move<VkCommandPool>                                     m_cmdPool;
 156         Move<VkCommandBuffer>                           m_cmdBuffer;
 157         Move<VkFence>                                           m_fence;
 158         de::MovePtr<tcu::TextureLevel>          m_sourceTextureLevel;
 159         de::MovePtr<tcu::TextureLevel>          m_destinationTextureLevel;
 160         de::MovePtr<tcu::TextureLevel>          m_expectedTextureLevel;
 161
 162         VkCommandBufferBeginInfo                        m_cmdBufferBeginInfo;
 163
 164         void                                                            generateBuffer                                          (tcu::PixelBufferAccess buffer, int width, int height, int depth = 1, FillMode = FILL_MODE_GRADIENT);
 165         virtual void                                            generateExpectedResult                          (void);
 166         void                                                            uploadBuffer                                            (tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc);
 167         void                                                            uploadImage                                                     (tcu::ConstPixelBufferAccess imageAccess, const VkImage& image, const ImageParms& parms);
 168         virtual tcu::TestStatus                         checkTestResult                                         (tcu::ConstPixelBufferAccess result);
 169         virtual void                                            copyRegionToTextureLevel                        (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region) = 0;
 170         deUint32                                                        calculateSize                                           (tcu::ConstPixelBufferAccess src) const
 171                                                                                 {
 172                                                                                         return src.getWidth() * src.getHeight() * src.getDepth() * tcu::getPixelSize(src.getFormat());
 173                                                                                 }
 174
 175         de::MovePtr<tcu::TextureLevel>          readImage                                                       (const vk::DeviceInterface&     vk,
 176                                                                                                                                                          vk::VkDevice                           device,
 177                                                                                                                                                          vk::VkQueue                            queue,
 178                                                                                                                                                          vk::Allocator&                         allocator,
 179                                                                                                                                                          vk::VkImage                            image,
 180                                                                                                                                                          const ImageParms&                      imageParms);
 181         void                                                            submitCommandsAndWait                           (const DeviceInterface&         vk,
 182                                                                                                                                                         const VkDevice                          device,
 183                                                                                                                                                         const VkQueue                           queue,
 184                                                                                                                                                         const VkCommandBuffer&          cmdBuffer);
 185 };
 186
 187 CopiesAndBlittingTestInstance::CopiesAndBlittingTestInstance (Context& context, TestParams testParams)
 188         : vkt::TestInstance     (context)
 189         , m_params                      (testParams)
 190 {
 191         const DeviceInterface&          vk                                      = context.getDeviceInterface();
 192         const VkDevice                          vkDevice                        = context.getDevice();
 193         const deUint32                          queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
 194
 195         // Create command pool
 196         {
 197                 const VkCommandPoolCreateInfo           cmdPoolParams                   =
 198                 {
 199                         VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,             // VkStructureType              sType;
 200                         DE_NULL,                                                                                // const void*                  pNext;
 201                         VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,// VkCmdPoolCreateFlags flags;
 202                         queueFamilyIndex,                                                               // deUint32                             queueFamilyIndex;
 203                 };
 204
 205                 m_cmdPool = createCommandPool(vk, vkDevice, &cmdPoolParams);
 206         }
 207
 208         // Create command buffer
 209         {
 210                 const VkCommandBufferAllocateInfo       cmdBufferAllocateInfo   =
 211                 {
 212                         VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType                      sType;
 213                         DE_NULL,                                                                                // const void*                          pNext;
 214                         *m_cmdPool,                                                                             // VkCommandPool                        commandPool;
 215                         VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                // VkCommandBufferLevel         level;
 216                         1u                                                                                              // deUint32                                     bufferCount;
 217                 };
 218
 219                 m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, &cmdBufferAllocateInfo);
 220         }
 221
 222         // Create fence
 223         {
 224                 const VkFenceCreateInfo                         fenceParams                             =
 225                 {
 226                         VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,    // VkStructureType              sType;
 227                         DE_NULL,                                                                // const void*                  pNext;
 228                         0u                                                                              // VkFenceCreateFlags   flags;
 229                 };
 230
 231                 m_fence = createFence(vk, vkDevice, &fenceParams);
 232         }
 233 }
 234
 235 void CopiesAndBlittingTestInstance::generateBuffer (tcu::PixelBufferAccess buffer, int width, int height, int depth, FillMode mode)
 236 {
 237         if (mode == FILL_MODE_GRADIENT)
 238         {
 239                 tcu::fillWithComponentGradients(buffer, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
 240                 return;
 241         }
 242
 243         const tcu::Vec4         redColor        (1.0, 0.0, 0.0, 1.0);
 244         const tcu::Vec4         greenColor      (0.0, 1.0, 0.0, 1.0);
 245         const tcu::Vec4         blueColor       (0.0, 0.0, 1.0, 1.0);
 246         const tcu::Vec4         whiteColor      (1.0, 1.0, 1.0, 1.0);
 247
 248         for (int z = 0; z < depth; z++)
 249         {
 250                 for (int y = 0; y < height; y++)
 251                 {
 252                         for (int x = 0; x < width; x++)
 253                         {
 254                                 switch (mode)
 255                                 {
 256                                         case FILL_MODE_WHITE:
 257                                                 if (tcu::isCombinedDepthStencilType(buffer.getFormat().type))
 258                                                 {
 259                                                         buffer.setPixDepth(1.0f, x, y, z);
 260                                                         if (tcu::hasStencilComponent(buffer.getFormat().order))
 261                                                                 buffer.setPixStencil(255, x, y, z);
 262                                                 }
 263                                                 else
 264                                                         buffer.setPixel(whiteColor, x, y, z);
 265                                                 break;
 266                                         case FILL_MODE_RED:
 267                                                 DE_ASSERT(!tcu::isCombinedDepthStencilType(buffer.getFormat().type)); // combined types cannot be accessed directly
 268                                                 buffer.setPixel(redColor, x, y, z);
 269                                                 break;
 270                                         case FILL_MODE_MULTISAMPLE:
 271                                                 buffer.setPixel((x == y) ? tcu::Vec4(0.0, 0.5, 0.5, 1.0) : ((x > y) ? greenColor : blueColor), x, y, z);
 272                                                 break;
 273                                         default:
 274                                                 break;
 275                                 }
 276                         }
 277                 }
 278         }
 279 }
 280
 281 void CopiesAndBlittingTestInstance::uploadBuffer (tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc)
 282 {
 283         const DeviceInterface&          vk                      = m_context.getDeviceInterface();
 284         const VkDevice                          vkDevice        = m_context.getDevice();
 285         const deUint32                          bufferSize      = calculateSize(bufferAccess);
 286
 287         // Write buffer data
 288         deMemcpy(bufferAlloc.getHostPtr(), bufferAccess.getDataPtr(), bufferSize);
 289         flushMappedMemoryRange(vk, vkDevice, bufferAlloc.getMemory(), bufferAlloc.getOffset(), bufferSize);
 290 }
 291
 292 void CopiesAndBlittingTestInstance::uploadImage (tcu::ConstPixelBufferAccess imageAccess, const VkImage& image, const ImageParms& parms)
 293 {
 294         const DeviceInterface&          vk                                      = m_context.getDeviceInterface();
 295         const VkDevice                          vkDevice                        = m_context.getDevice();
 296         const VkQueue                           queue                           = m_context.getUniversalQueue();
 297         const deUint32                          queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 298         Allocator&                                      memAlloc                        = m_context.getDefaultAllocator();
 299         Move<VkBuffer>                          buffer;
 300         const deUint32                          bufferSize                      = calculateSize(imageAccess);
 301         de::MovePtr<Allocation>         bufferAlloc;
 302         const deUint32                          arraySize                       = getArraySize(parms);
 303         const VkExtent3D                        imageExtent                     = getExtent3D(parms);
 304
 305         // Create source buffer
 306         {
 307                 const VkBufferCreateInfo                        bufferParams                    =
 308                 {
 309                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
 310                         DE_NULL,                                                                        // const void*                  pNext;
 311                         0u,                                                                                     // VkBufferCreateFlags  flags;
 312                         bufferSize,                                                                     // VkDeviceSize                 size;
 313                         VK_BUFFER_USAGE_TRANSFER_SRC_BIT,                       // VkBufferUsageFlags   usage;
 314                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
 315                         1u,                                                                                     // deUint32                             queueFamilyIndexCount;
 316                         &queueFamilyIndex,                                                      // const deUint32*              pQueueFamilyIndices;
 317                 };
 318
 319                 buffer          = createBuffer(vk, vkDevice, &bufferParams);
 320                 bufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *buffer), MemoryRequirement::HostVisible);
 321                 VK_CHECK(vk.bindBufferMemory(vkDevice, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
 322         }
 323
 324         // Barriers for copying buffer to image
 325         const VkBufferMemoryBarrier                             preBufferBarrier                =
 326         {
 327                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,                // VkStructureType      sType;
 328                 DE_NULL,                                                                                // const void*          pNext;
 329                 VK_ACCESS_HOST_WRITE_BIT,                                               // VkAccessFlags        srcAccessMask;
 330                 VK_ACCESS_TRANSFER_READ_BIT,                                    // VkAccessFlags        dstAccessMask;
 331                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                     srcQueueFamilyIndex;
 332                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                     dstQueueFamilyIndex;
 333                 *buffer,                                                                                // VkBuffer                     buffer;
 334                 0u,                                                                                             // VkDeviceSize         offset;
 335                 bufferSize                                                                              // VkDeviceSize         size;
 336         };
 337
 338         const VkImageAspectFlags                                aspect                                  = getAspectFlags(imageAccess.getFormat());
 339         const VkImageMemoryBarrier                              preImageBarrier                 =
 340         {
 341                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // VkStructureType                      sType;
 342                 DE_NULL,                                                                                // const void*                          pNext;
 343                 0u,                                                                                             // VkAccessFlags                        srcAccessMask;
 344                 VK_ACCESS_TRANSFER_WRITE_BIT,                                   // VkAccessFlags                        dstAccessMask;
 345                 VK_IMAGE_LAYOUT_UNDEFINED,                                              // VkImageLayout                        oldLayout;
 346                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                   // VkImageLayout                        newLayout;
 347                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     srcQueueFamilyIndex;
 348                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     dstQueueFamilyIndex;
 349                 image,                                                                                  // VkImage                                      image;
 350                 {                                                                                               // VkImageSubresourceRange      subresourceRange;
 351                         aspect,                 // VkImageAspectFlags   aspect;
 352                         0u,                             // deUint32                             baseMipLevel;
 353                         1u,                             // deUint32                             mipLevels;
 354                         0u,                             // deUint32                             baseArraySlice;
 355                         arraySize,              // deUint32                             arraySize;
 356                 }
 357         };
 358
 359         const VkImageMemoryBarrier                              postImageBarrier                =
 360         {
 361                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // VkStructureType                      sType;
 362                 DE_NULL,                                                                                // const void*                          pNext;
 363                 VK_ACCESS_TRANSFER_WRITE_BIT,                                   // VkAccessFlags                        srcAccessMask;
 364                 VK_ACCESS_TRANSFER_WRITE_BIT,                                   // VkAccessFlags                        dstAccessMask;
 365                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                   // VkImageLayout                        oldLayout;
 366                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                   // VkImageLayout                        newLayout;
 367                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     srcQueueFamilyIndex;
 368                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     dstQueueFamilyIndex;
 369                 image,                                                                                  // VkImage                                      image;
 370                 {                                                                                               // VkImageSubresourceRange      subresourceRange;
 371                         aspect,                                         // VkImageAspectFlags   aspect;
 372                         0u,                                                     // deUint32                             baseMipLevel;
 373                         1u,                                                     // deUint32                             mipLevels;
 374                         0u,                                                     // deUint32                             baseArraySlice;
 375                         arraySize,                                      // deUint32                             arraySize;
 376                 }
 377         };
 378
 379         const deUint32                          regionCount                     = tcu::isCombinedDepthStencilType(imageAccess.getFormat().type) ? 2u : 1u;
 380         const VkImageAspectFlags        firstRegionAspect       = aspect & VK_IMAGE_ASPECT_DEPTH_BIT ? VkImageAspectFlags(VK_IMAGE_ASPECT_DEPTH_BIT) : aspect;
 381         const VkBufferImageCopy         copyRegion[]            =
 382         {
 383                 {
 384                         0u,                                                                     // VkDeviceSize                         bufferOffset;
 385                         (deUint32)imageAccess.getWidth(),       // deUint32                                     bufferRowLength;
 386                         (deUint32)imageAccess.getHeight(),      // deUint32                                     bufferImageHeight;
 387                         {                                                                       // VkImageSubresourceLayers     imageSubresource;
 388                                 firstRegionAspect,                              // VkImageAspectFlags   aspect;
 389                                 0u,                                                             // deUint32                             mipLevel;
 390                                 0u,                                                             // deUint32                             baseArrayLayer;
 391                                 arraySize,                                              // deUint32                             layerCount;
 392                         },
 393                         { 0, 0, 0 },                                            // VkOffset3D                           imageOffset;
 394                         imageExtent                                                     // VkExtent3D                           imageExtent;
 395                 },
 396                 {
 397                         0u,                                                                     // VkDeviceSize                         bufferOffset;
 398                         (deUint32)imageAccess.getWidth(),       // deUint32                                     bufferRowLength;
 399                         (deUint32)imageAccess.getHeight(),      // deUint32                                     bufferImageHeight;
 400                         {                                                                       // VkImageSubresourceLayers     imageSubresource;
 401                                 VK_IMAGE_ASPECT_STENCIL_BIT,    // VkImageAspectFlags   aspect;
 402                                 0u,                                                             // deUint32                             mipLevel;
 403                                 0u,                                                             // deUint32                             baseArrayLayer;
 404                                 arraySize,                                              // deUint32                             layerCount;
 405                         },
 406                         { 0, 0, 0 },                                            // VkOffset3D                           imageOffset;
 407                         imageExtent                                                     // VkExtent3D                           imageExtent;
 408                 },
 409         };
 410
 411         // Write buffer data
 412         deMemcpy(bufferAlloc->getHostPtr(), imageAccess.getDataPtr(), bufferSize);
 413         flushMappedMemoryRange(vk, vkDevice, bufferAlloc->getMemory(), bufferAlloc->getOffset(), bufferSize);
 414
 415         // Copy buffer to image
 416         const VkCommandBufferBeginInfo                  cmdBufferBeginInfo              =
 417         {
 418                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
 419                 DE_NULL,                                                                                                // const void*                                          pNext;
 420                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
 421                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 422         };
 423
 424         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
 425         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &preBufferBarrier, 1, &preImageBarrier);
 426         vk.cmdCopyBufferToImage(*m_cmdBuffer, *buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, regionCount, copyRegion);
 427         vk.cmdPipelineBarrier(*m_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, 1, &postImageBarrier);
 428         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
 429
 430         submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
 431 }
 432
 433 tcu::TestStatus CopiesAndBlittingTestInstance::checkTestResult (tcu::ConstPixelBufferAccess result)
 434 {
 435         const tcu::ConstPixelBufferAccess       expected        = m_expectedTextureLevel->getAccess();
 436
 437         if (isFloatFormat(mapTextureFormat(result.getFormat())))
 438         {
 439                 const tcu::Vec4 threshold (0.0f);
 440                 if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expected, result, threshold, tcu::COMPARE_LOG_RESULT))
 441                         return tcu::TestStatus::fail("CopiesAndBlitting test");
 442         }
 443         else
 444         {
 445                 const tcu::UVec4 threshold (0u);
 446                 if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expected, result, threshold, tcu::COMPARE_LOG_RESULT))
 447                         return tcu::TestStatus::fail("CopiesAndBlitting test");
 448         }
 449
 450         return tcu::TestStatus::pass("CopiesAndBlitting test");
 451 }
 452
 453 void CopiesAndBlittingTestInstance::generateExpectedResult (void)
 454 {
 455         const tcu::ConstPixelBufferAccess       src     = m_sourceTextureLevel->getAccess();
 456         const tcu::ConstPixelBufferAccess       dst     = m_destinationTextureLevel->getAccess();
 457
 458         m_expectedTextureLevel  = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
 459         tcu::copy(m_expectedTextureLevel->getAccess(), dst);
 460
 461         for (deUint32 i = 0; i < m_params.regions.size(); i++)
 462                 copyRegionToTextureLevel(src, m_expectedTextureLevel->getAccess(), m_params.regions[i]);
 463 }
 464
 465 class CopiesAndBlittingTestCase : public vkt::TestCase
 466 {
 467 public:
 468                                                         CopiesAndBlittingTestCase       (tcu::TestContext&                      testCtx,
 469                                                                                                                  const std::string&                     name,
 470                                                                                                                  const std::string&                     description)
 471                                                                 : vkt::TestCase (testCtx, name, description)
 472                                                         {}
 473
 474         virtual TestInstance*   createInstance                          (Context&                                       context) const = 0;
 475 };
 476
 477 de::MovePtr<tcu::TextureLevel> CopiesAndBlittingTestInstance::readImage (const vk::DeviceInterface&     vk,
 478                                                                                                                                                  vk::VkDevice                           device,
 479                                                                                                                                                  vk::VkQueue                            queue,
 480                                                                                                                                                  vk::Allocator&                         allocator,
 481                                                                                                                                                  vk::VkImage                            image,
 482                                                                                                                                                  const ImageParms&                      imageParms)
 483 {
 484         Move<VkBuffer>                                  buffer;
 485         de::MovePtr<Allocation>                 bufferAlloc;
 486         const deUint32                                  queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 487         const tcu::TextureFormat                tcuFormat                       = mapVkFormat(imageParms.format);
 488         const VkDeviceSize                              pixelDataSize           = imageParms.extent.width * imageParms.extent.height * imageParms.extent.depth * tcu::getPixelSize(tcuFormat);
 489         de::MovePtr<tcu::TextureLevel>  resultLevel                     (new tcu::TextureLevel(tcuFormat,imageParms.extent.width, imageParms.extent.height, imageParms.extent.depth));
 490
 491         // Create destination buffer
 492         {
 493                 const VkBufferCreateInfo                        bufferParams                    =
 494                 {
 495                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
 496                         DE_NULL,                                                                        // const void*                  pNext;
 497                         0u,                                                                                     // VkBufferCreateFlags  flags;
 498                         pixelDataSize,                                                          // VkDeviceSize                 size;
 499                         VK_BUFFER_USAGE_TRANSFER_DST_BIT,                       // VkBufferUsageFlags   usage;
 500                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
 501                         1u,                                                                                     // deUint32                             queueFamilyIndexCount;
 502                         &queueFamilyIndex,                                                      // const deUint32*              pQueueFamilyIndices;
 503                 };
 504
 505                 buffer          = createBuffer(vk, device, &bufferParams);
 506                 bufferAlloc     = allocator.allocate(getBufferMemoryRequirements(vk, device, *buffer), MemoryRequirement::HostVisible);
 507                 VK_CHECK(vk.bindBufferMemory(device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
 508
 509                 deMemset(bufferAlloc->getHostPtr(), 0, static_cast<size_t>(pixelDataSize));
 510                 flushMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
 511         }
 512
 513         // Barriers for copying image to buffer
 514         const VkImageAspectFlags                                aspect                                  = getAspectFlags(tcuFormat);
 515         const VkImageMemoryBarrier                              imageBarrier                    =
 516         {
 517                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
 518                 DE_NULL,                                                                        // const void*                          pNext;
 519                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
 520                 VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags                        dstAccessMask;
 521                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        oldLayout;
 522                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // VkImageLayout                        newLayout;
 523                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
 524                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
 525                 image,                                                                          // VkImage                                      image;
 526                 {                                                                                       // VkImageSubresourceRange      subresourceRange;
 527                         aspect,                                 // VkImageAspectFlags   aspectMask;
 528                         0u,                                             // deUint32                             baseMipLevel;
 529                         1u,                                             // deUint32                             mipLevels;
 530                         0u,                                             // deUint32                             baseArraySlice;
 531                         getArraySize(imageParms)// deUint32                             arraySize;
 532                 }
 533         };
 534
 535         const VkBufferMemoryBarrier                             bufferBarrier                   =
 536         {
 537                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
 538                 DE_NULL,                                                                        // const void*          pNext;
 539                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags        srcAccessMask;
 540                 VK_ACCESS_HOST_READ_BIT,                                        // VkAccessFlags        dstAccessMask;
 541                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
 542                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
 543                 *buffer,                                                                        // VkBuffer                     buffer;
 544                 0u,                                                                                     // VkDeviceSize         offset;
 545                 pixelDataSize                                                           // VkDeviceSize         size;
 546         };
 547
 548         // Copy image to buffer
 549         const deUint32                          regionCount                     = tcu::isCombinedDepthStencilType(tcuFormat.type) ? 2u : 1u;
 550         const VkImageAspectFlags        firstRegionAspect       = aspect & VK_IMAGE_ASPECT_DEPTH_BIT ? VkImageAspectFlags(VK_IMAGE_ASPECT_DEPTH_BIT) : aspect;
 551         const VkBufferImageCopy         copyRegion[]            =
 552         {
 553                 {
 554                         0u,                                                                     // VkDeviceSize                         bufferOffset;
 555                         (deUint32)imageParms.extent.width,      // deUint32                                     bufferRowLength;
 556                         (deUint32)imageParms.extent.height,     // deUint32                                     bufferImageHeight;
 557                         {                                                                       // VkImageSubresourceLayers     imageSubresource;
 558                                 firstRegionAspect,                      // VkImageAspectFlags           aspect;
 559                                 0u,                                                     // deUint32                                     mipLevel;
 560                                 0u,                                                     // deUint32                                     baseArrayLayer;
 561                                 getArraySize(imageParms),       // deUint32                                     layerCount;
 562                         },
 563                         { 0, 0, 0 },                                            // VkOffset3D                           imageOffset;
 564                         getExtent3D(imageParms)                         // VkExtent3D                           imageExtent;
 565                 },
 566                 {
 567                         0u,                                                                     // VkDeviceSize                         bufferOffset;
 568                         (deUint32)imageParms.extent.width,      // deUint32                                     bufferRowLength;
 569                         (deUint32)imageParms.extent.height,     // deUint32                                     bufferImageHeight;
 570                         {                                                                       // VkImageSubresourceLayers     imageSubresource;
 571                                 VK_IMAGE_ASPECT_STENCIL_BIT,    // VkImageAspectFlags           aspect;
 572                                 0u,                                                             // deUint32                                     mipLevel;
 573                                 0u,                                                             // deUint32                                     baseArrayLayer;
 574                                 getArraySize(imageParms),               // deUint32                                     layerCount;
 575                         },
 576                         { 0, 0, 0 },                                            // VkOffset3D                           imageOffset;
 577                         getExtent3D(imageParms)                         // VkExtent3D                           imageExtent;
 578                 },
 579         };
 580
 581         const VkCommandBufferBeginInfo                  cmdBufferBeginInfo              =
 582         {
 583                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
 584                 DE_NULL,                                                                                                // const void*                                          pNext;
 585                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
 586                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 587         };
 588
 589         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
 590         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
 591         vk.cmdCopyImageToBuffer(*m_cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, regionCount, copyRegion);
 592         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
 593         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
 594
 595         submitCommandsAndWait (vk, device, queue, *m_cmdBuffer);
 596
 597         // Read buffer data
 598         invalidateMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
 599         tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), bufferAlloc->getHostPtr()));
 600
 601         return resultLevel;
 602 }
 603
 604 void CopiesAndBlittingTestInstance::submitCommandsAndWait (const DeviceInterface& vk, const VkDevice device, const VkQueue queue, const VkCommandBuffer& cmdBuffer)
 605 {
 606         const VkSubmitInfo                                              submitInfo                              =
 607         {
 608                 VK_STRUCTURE_TYPE_SUBMIT_INFO,  // VkStructureType                      sType;
 609                 DE_NULL,                                                // const void*                          pNext;
 610                 0u,                                                             // deUint32                                     waitSemaphoreCount;
 611                 DE_NULL,                                                // const VkSemaphore*           pWaitSemaphores;
 612                 (const VkPipelineStageFlags*)DE_NULL,
 613                 1u,                                                             // deUint32                                     commandBufferCount;
 614                 &cmdBuffer,                                             // const VkCommandBuffer*       pCommandBuffers;
 615                 0u,                                                             // deUint32                                     signalSemaphoreCount;
 616                 DE_NULL                                                 // const VkSemaphore*           pSignalSemaphores;
 617         };
 618
 619         VK_CHECK(vk.resetFences(device, 1, &m_fence.get()));
 620         VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
 621         VK_CHECK(vk.waitForFences(device, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
 622 }
 623
 624 // Copy from image to image.
 625
 626 class CopyImageToImage : public CopiesAndBlittingTestInstance
 627 {
 628 public:
 629                                                                                 CopyImageToImage                        (Context&       context,
 630                                                                                                                                          TestParams params);
 631         virtual tcu::TestStatus                         iterate                                         (void);
 632 private:
 633         Move<VkImage>                                           m_source;
 634         de::MovePtr<Allocation>                         m_sourceImageAlloc;
 635         Move<VkImage>                                           m_destination;
 636         de::MovePtr<Allocation>                         m_destinationImageAlloc;
 637
 638         virtual void                                            copyRegionToTextureLevel        (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
 639 };
 640
 641 CopyImageToImage::CopyImageToImage (Context& context, TestParams params)
 642         : CopiesAndBlittingTestInstance(context, params)
 643 {
 644         const DeviceInterface&          vk                                      = context.getDeviceInterface();
 645         const VkDevice                          vkDevice                        = context.getDevice();
 646         const deUint32                          queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
 647         Allocator&                                      memAlloc                        = context.getDefaultAllocator();
 648
 649         if ((m_params.dst.image.imageType == VK_IMAGE_TYPE_3D && m_params.src.image.imageType == VK_IMAGE_TYPE_2D) ||
 650                 (m_params.dst.image.imageType == VK_IMAGE_TYPE_2D && m_params.src.image.imageType == VK_IMAGE_TYPE_3D))
 651         {
 652                 if (std::find(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance1") == context.getDeviceExtensions().end())
 653                         TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance1 not supported");
 654         }
 655
 656         VkImageFormatProperties properties;
 657         if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
 658                                                                                                                                                                 m_params.src.image.format,
 659                                                                                                                                                                 m_params.src.image.imageType,
 660                                                                                                                                                                 VK_IMAGE_TILING_OPTIMAL,
 661                                                                                                                                                                 VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
 662                                                                                                                                                                 0,
 663                                                                                                                                                                 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
 664                 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
 665                                                                                                                                                                 m_params.dst.image.format,
 666                                                                                                                                                                 m_params.dst.image.imageType,
 667                                                                                                                                                                 VK_IMAGE_TILING_OPTIMAL,
 668                                                                                                                                                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT,
 669                                                                                                                                                                 0,
 670                                                                                                                                                                 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
 671         {
 672                 TCU_THROW(NotSupportedError, "Format not supported");
 673         }
 674
 675         // Create source image
 676         {
 677                 const VkImageCreateInfo sourceImageParams               =
 678                 {
 679                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType              sType;
 680                         DE_NULL,                                                                // const void*                  pNext;
 681                         0u,                                                                             // VkImageCreateFlags   flags;
 682                         m_params.src.image.imageType,                   // VkImageType                  imageType;
 683                         m_params.src.image.format,                              // VkFormat                             format;
 684                         getExtent3D(m_params.src.image),                // VkExtent3D                   extent;
 685                         1u,                                                                             // deUint32                             mipLevels;
 686                         getArraySize(m_params.src.image),               // deUint32                             arraySize;
 687                         VK_SAMPLE_COUNT_1_BIT,                                  // deUint32                             samples;
 688                         VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                tiling;
 689                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
 690                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT,        // VkImageUsageFlags    usage;
 691                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                sharingMode;
 692                         1u,                                                                             // deUint32                             queueFamilyCount;
 693                         &queueFamilyIndex,                                              // const deUint32*              pQueueFamilyIndices;
 694                         VK_IMAGE_LAYOUT_UNDEFINED,                              // VkImageLayout                initialLayout;
 695                 };
 696
 697                 m_source                                = createImage(vk, vkDevice, &sourceImageParams);
 698                 m_sourceImageAlloc              = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
 699                 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
 700         }
 701
 702         // Create destination image
 703         {
 704                 const VkImageCreateInfo destinationImageParams  =
 705                 {
 706                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType              sType;
 707                         DE_NULL,                                                                // const void*                  pNext;
 708                         0u,                                                                             // VkImageCreateFlags   flags;
 709                         m_params.dst.image.imageType,                   // VkImageType                  imageType;
 710                         m_params.dst.image.format,                              // VkFormat                             format;
 711                         getExtent3D(m_params.dst.image),                // VkExtent3D                   extent;
 712                         1u,                                                                             // deUint32                             mipLevels;
 713                         getArraySize(m_params.dst.image),               // deUint32                             arraySize;
 714                         VK_SAMPLE_COUNT_1_BIT,                                  // deUint32                             samples;
 715                         VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                tiling;
 716                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
 717                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT,        // VkImageUsageFlags    usage;
 718                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                sharingMode;
 719                         1u,                                                                             // deUint32                             queueFamilyCount;
 720                         &queueFamilyIndex,                                              // const deUint32*              pQueueFamilyIndices;
 721                         VK_IMAGE_LAYOUT_UNDEFINED,                              // VkImageLayout                initialLayout;
 722                 };
 723
 724                 m_destination                   = createImage(vk, vkDevice, &destinationImageParams);
 725                 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
 726                 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
 727         }
 728 }
 729
 730 tcu::TestStatus CopyImageToImage::iterate (void)
 731 {
 732         const tcu::TextureFormat        srcTcuFormat            = mapVkFormat(m_params.src.image.format);
 733         const tcu::TextureFormat        dstTcuFormat            = mapVkFormat(m_params.dst.image.format);
 734         m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
 735                                                                                                                                                                 (int)m_params.src.image.extent.width,
 736                                                                                                                                                                 (int)m_params.src.image.extent.height,
 737                                                                                                                                                                 (int)m_params.src.image.extent.depth));
 738         generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.src.image.extent.depth, FILL_MODE_WHITE);
 739         m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
 740                                                                                                                                                                 (int)m_params.dst.image.extent.width,
 741                                                                                                                                                                 (int)m_params.dst.image.extent.height,
 742                                                                                                                                                                 (int)m_params.dst.image.extent.depth));
 743         generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth, FILL_MODE_GRADIENT);
 744         generateExpectedResult();
 745
 746         uploadImage(m_sourceTextureLevel->getAccess(), m_source.get(), m_params.src.image);
 747         uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
 748
 749         const DeviceInterface&          vk                                      = m_context.getDeviceInterface();
 750         const VkDevice                          vkDevice                        = m_context.getDevice();
 751         const VkQueue                           queue                           = m_context.getUniversalQueue();
 752         Allocator&                                      memAlloc                        = m_context.getDefaultAllocator();
 753
 754         std::vector<VkImageCopy>        imageCopies;
 755         for (deUint32 i = 0; i < m_params.regions.size(); i++)
 756                 imageCopies.push_back(m_params.regions[i].imageCopy);
 757
 758         const VkImageMemoryBarrier      imageBarriers[]         =
 759         {
 760                 // source image
 761                 {
 762                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
 763                         DE_NULL,                                                                        // const void*                          pNext;
 764                         VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
 765                         VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags                        dstAccessMask;
 766                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        oldLayout;
 767                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // VkImageLayout                        newLayout;
 768                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
 769                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
 770                         m_source.get(),                                                         // VkImage                                      image;
 771                         {                                                                                       // VkImageSubresourceRange      subresourceRange;
 772                                 getAspectFlags(srcTcuFormat),   // VkImageAspectFlags   aspectMask;
 773                                 0u,                                                             // deUint32                             baseMipLevel;
 774                                 1u,                                                             // deUint32                             mipLevels;
 775                                 0u,                                                             // deUint32                             baseArraySlice;
 776                                 getArraySize(m_params.src.image)// deUint32                             arraySize;
 777                         }
 778                 },
 779                 // destination image
 780                 {
 781                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
 782                         DE_NULL,                                                                        // const void*                          pNext;
 783                         VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
 784                         VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        dstAccessMask;
 785                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        oldLayout;
 786                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        newLayout;
 787                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
 788                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
 789                         m_destination.get(),                                            // VkImage                                      image;
 790                         {                                                                                       // VkImageSubresourceRange      subresourceRange;
 791                                 getAspectFlags(dstTcuFormat),   // VkImageAspectFlags   aspectMask;
 792                                 0u,                                                             // deUint32                             baseMipLevel;
 793                                 1u,                                                             // deUint32                             mipLevels;
 794                                 0u,                                                             // deUint32                             baseArraySlice;
 795                                 getArraySize(m_params.dst.image)// deUint32                             arraySize;
 796                         }
 797                 },
 798         };
 799
 800         const VkCommandBufferBeginInfo  cmdBufferBeginInfo      =
 801         {
 802                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
 803                 DE_NULL,                                                                                                // const void*                                          pNext;
 804                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
 805                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 806         };
 807
 808         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
 809         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, DE_LENGTH_OF_ARRAY(imageBarriers), imageBarriers);
 810         vk.cmdCopyImage(*m_cmdBuffer, m_source.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_destination.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)m_params.regions.size(), imageCopies.data());
 811         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
 812
 813         submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
 814
 815         de::MovePtr<tcu::TextureLevel>  resultTextureLevel      = readImage(vk, vkDevice, queue, memAlloc, *m_destination, m_params.dst.image);
 816
 817         return checkTestResult(resultTextureLevel->getAccess());
 818 }
 819
 820 void CopyImageToImage::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
 821 {
 822         VkOffset3D srcOffset    = region.imageCopy.srcOffset;
 823         VkOffset3D dstOffset    = region.imageCopy.dstOffset;
 824         VkExtent3D extent               = region.imageCopy.extent;
 825
 826         if (m_params.src.image.imageType == VK_IMAGE_TYPE_3D && m_params.dst.image.imageType == VK_IMAGE_TYPE_2D)
 827                 dstOffset.z = srcOffset.z;
 828         if (m_params.src.image.imageType == VK_IMAGE_TYPE_2D && m_params.dst.image.imageType == VK_IMAGE_TYPE_3D)
 829         {
 830                 srcOffset.z = dstOffset.z;
 831                 extent.depth = std::max(region.imageCopy.extent.depth, region.imageCopy.srcSubresource.layerCount);
 832         }
 833
 834
 835         if (tcu::isCombinedDepthStencilType(src.getFormat().type))
 836         {
 837                 DE_ASSERT(src.getFormat() == dst.getFormat());
 838                 // Copy depth.
 839                 {
 840                         const tcu::ConstPixelBufferAccess       srcSubRegion    = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_DEPTH);
 841                         const tcu::PixelBufferAccess            dstWithSrcFormat(srcSubRegion.getFormat(), dst.getSize(), dst.getDataPtr());
 842                         const tcu::PixelBufferAccess            dstSubRegion    = getEffectiveDepthStencilAccess(tcu::getSubregion(dstWithSrcFormat, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_DEPTH);
 843
 844                         tcu::copy(dstSubRegion, srcSubRegion);
 845                 }
 846
 847                 // Copy stencil.
 848                 if (tcu::hasStencilComponent(src.getFormat().order))
 849                 {
 850                         const tcu::ConstPixelBufferAccess       srcSubRegion    = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_STENCIL);
 851                         const tcu::PixelBufferAccess            dstWithSrcFormat(srcSubRegion.getFormat(), dst.getSize(), dst.getDataPtr());
 852                         const tcu::PixelBufferAccess            dstSubRegion    = getEffectiveDepthStencilAccess(tcu::getSubregion(dstWithSrcFormat, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_STENCIL);
 853
 854                         tcu::copy(dstSubRegion, srcSubRegion);
 855                 }
 856         }
 857         else
 858         {
 859                 const tcu::ConstPixelBufferAccess       srcSubRegion            = tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth);
 860                 // CopyImage acts like a memcpy. Replace the destination format with the srcformat to use a memcpy.
 861                 const tcu::PixelBufferAccess            dstWithSrcFormat        (srcSubRegion.getFormat(), dst.getSize(), dst.getDataPtr());
 862                 const tcu::PixelBufferAccess            dstSubRegion            = tcu::getSubregion(dstWithSrcFormat, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth);
 863
 864                 tcu::copy(dstSubRegion, srcSubRegion);
 865         }
 866 }
 867
 868 class CopyImageToImageTestCase : public vkt::TestCase
 869 {
 870 public:
 871                                                         CopyImageToImageTestCase        (tcu::TestContext&                              testCtx,
 872                                                                                                                  const std::string&                             name,
 873                                                                                                                  const std::string&                             description,
 874                                                                                                                  const TestParams                               params)
 875                                                                 : vkt::TestCase (testCtx, name, description)
 876                                                                 , m_params              (params)
 877                                                         {}
 878
 879         virtual TestInstance*   createInstance                          (Context&                                               context) const
 880                                                         {
 881                                                                 return new CopyImageToImage(context, m_params);
 882                                                         }
 883 private:
 884         TestParams                              m_params;
 885 };
 886
 887 // Copy from buffer to buffer.
 888
 889 class CopyBufferToBuffer : public CopiesAndBlittingTestInstance
 890 {
 891 public:
 892                                                                 CopyBufferToBuffer                      (Context& context, TestParams params);
 893         virtual tcu::TestStatus         iterate                                         (void);
 894 private:
 895         virtual void                            copyRegionToTextureLevel        (tcu::ConstPixelBufferAccess, tcu::PixelBufferAccess, CopyRegion);
 896         Move<VkBuffer>                          m_source;
 897         de::MovePtr<Allocation>         m_sourceBufferAlloc;
 898         Move<VkBuffer>                          m_destination;
 899         de::MovePtr<Allocation>         m_destinationBufferAlloc;
 900 };
 901
 902 CopyBufferToBuffer::CopyBufferToBuffer (Context& context, TestParams params)
 903         : CopiesAndBlittingTestInstance (context, params)
 904 {
 905         const DeviceInterface&          vk                                      = context.getDeviceInterface();
 906         const VkDevice                          vkDevice                        = context.getDevice();
 907         const deUint32                          queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
 908         Allocator&                                      memAlloc                        = context.getDefaultAllocator();
 909
 910         // Create source buffer
 911         {
 912                 const VkBufferCreateInfo        sourceBufferParams              =
 913                 {
 914                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
 915                         DE_NULL,                                                                        // const void*                  pNext;
 916                         0u,                                                                                     // VkBufferCreateFlags  flags;
 917                         m_params.src.buffer.size,                                       // VkDeviceSize                 size;
 918                         VK_BUFFER_USAGE_TRANSFER_SRC_BIT,                       // VkBufferUsageFlags   usage;
 919                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
 920                         1u,                                                                                     // deUint32                             queueFamilyIndexCount;
 921                         &queueFamilyIndex,                                                      // const deUint32*              pQueueFamilyIndices;
 922                 };
 923
 924                 m_source                                = createBuffer(vk, vkDevice, &sourceBufferParams);
 925                 m_sourceBufferAlloc             = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::HostVisible);
 926                 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_source, m_sourceBufferAlloc->getMemory(), m_sourceBufferAlloc->getOffset()));
 927         }
 928
 929         // Create destination buffer
 930         {
 931                 const VkBufferCreateInfo        destinationBufferParams =
 932                 {
 933                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
 934                         DE_NULL,                                                                        // const void*                  pNext;
 935                         0u,                                                                                     // VkBufferCreateFlags  flags;
 936                         m_params.dst.buffer.size,                                       // VkDeviceSize                 size;
 937                         VK_BUFFER_USAGE_TRANSFER_DST_BIT,                       // VkBufferUsageFlags   usage;
 938                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
 939                         1u,                                                                                     // deUint32                             queueFamilyIndexCount;
 940                         &queueFamilyIndex,                                                      // const deUint32*              pQueueFamilyIndices;
 941                 };
 942
 943                 m_destination                           = createBuffer(vk, vkDevice, &destinationBufferParams);
 944                 m_destinationBufferAlloc        = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::HostVisible);
 945                 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_destination, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset()));
 946         }
 947 }
 948
 949 tcu::TestStatus CopyBufferToBuffer::iterate (void)
 950 {
 951         const int srcLevelWidth         = (int)(m_params.src.buffer.size/4); // Here the format is VK_FORMAT_R32_UINT, we need to divide the buffer size by 4
 952         m_sourceTextureLevel            = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), srcLevelWidth, 1));
 953         generateBuffer(m_sourceTextureLevel->getAccess(), srcLevelWidth, 1, 1, FILL_MODE_RED);
 954
 955         const int dstLevelWidth         = (int)(m_params.dst.buffer.size/4);
 956         m_destinationTextureLevel       = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), dstLevelWidth, 1));
 957         generateBuffer(m_destinationTextureLevel->getAccess(), dstLevelWidth, 1, 1, FILL_MODE_WHITE);
 958
 959         generateExpectedResult();
 960
 961         uploadBuffer(m_sourceTextureLevel->getAccess(), *m_sourceBufferAlloc);
 962         uploadBuffer(m_destinationTextureLevel->getAccess(), *m_destinationBufferAlloc);
 963
 964         const DeviceInterface&          vk                      = m_context.getDeviceInterface();
 965         const VkDevice                          vkDevice        = m_context.getDevice();
 966         const VkQueue                           queue           = m_context.getUniversalQueue();
 967
 968         const VkBufferMemoryBarrier             srcBufferBarrier        =
 969         {
 970                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
 971                 DE_NULL,                                                                        // const void*          pNext;
 972                 VK_ACCESS_HOST_WRITE_BIT,                                       // VkAccessFlags        srcAccessMask;
 973                 VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags        dstAccessMask;
 974                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
 975                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
 976                 *m_source,                                                                      // VkBuffer                     buffer;
 977                 0u,                                                                                     // VkDeviceSize         offset;
 978                 m_params.src.buffer.size                                        // VkDeviceSize         size;
 979         };
 980
 981         const VkBufferMemoryBarrier             dstBufferBarrier        =
 982         {
 983                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
 984                 DE_NULL,                                                                        // const void*          pNext;
 985                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags        srcAccessMask;
 986                 VK_ACCESS_HOST_READ_BIT,                                        // VkAccessFlags        dstAccessMask;
 987                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
 988                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
 989                 *m_destination,                                                         // VkBuffer                     buffer;
 990                 0u,                                                                                     // VkDeviceSize         offset;
 991                 m_params.dst.buffer.size                                        // VkDeviceSize         size;
 992         };
 993
 994         std::vector<VkBufferCopy>               bufferCopies;
 995         for (deUint32 i = 0; i < m_params.regions.size(); i++)
 996                 bufferCopies.push_back(m_params.regions[i].bufferCopy);
 997
 998         const VkCommandBufferBeginInfo  cmdBufferBeginInfo      =
 999         {
1000                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
1001                 DE_NULL,                                                                                                // const void*                                          pNext;
1002                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
1003                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1004         };
1005
1006         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1007         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &srcBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1008         vk.cmdCopyBuffer(*m_cmdBuffer, m_source.get(), m_destination.get(), (deUint32)m_params.regions.size(), &bufferCopies[0]);
1009         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &dstBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1010         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1011         submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
1012
1013
1014
1015         // Read buffer data
1016         de::MovePtr<tcu::TextureLevel>  resultLevel             (new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), dstLevelWidth, 1));
1017         invalidateMappedMemoryRange(vk, vkDevice, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset(), m_params.dst.buffer.size);
1018         tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), m_destinationBufferAlloc->getHostPtr()));
1019
1020         return checkTestResult(resultLevel->getAccess());
1021 }
1022
1023 void CopyBufferToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1024 {
1025         deMemcpy((deUint8*) dst.getDataPtr() + region.bufferCopy.dstOffset,
1026                          (deUint8*) src.getDataPtr() + region.bufferCopy.srcOffset,
1027                          (size_t)region.bufferCopy.size);
1028 }
1029
1030 class BufferToBufferTestCase : public vkt::TestCase
1031 {
1032 public:
1033                                                         BufferToBufferTestCase  (tcu::TestContext&      testCtx,
1034                                                                                                          const std::string&     name,
1035                                                                                                          const std::string&     description,
1036                                                                                                          const TestParams       params)
1037                                                                 : vkt::TestCase (testCtx, name, description)
1038                                                                 , m_params              (params)
1039                                                         {}
1040
1041         virtual TestInstance*   createInstance                  (Context& context) const
1042                                                         {
1043                                                                 return new CopyBufferToBuffer(context, m_params);
1044                                                         }
1045 private:
1046         TestParams                              m_params;
1047 };
1048
1049 // Copy from image to buffer.
1050
1051 class CopyImageToBuffer : public CopiesAndBlittingTestInstance
1052 {
1053 public:
1054                                                                 CopyImageToBuffer                       (Context&       context,
1055                                                                                                                          TestParams     testParams);
1056         virtual tcu::TestStatus         iterate                                         (void);
1057 private:
1058         virtual void                            copyRegionToTextureLevel        (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1059
1060         tcu::TextureFormat                      m_textureFormat;
1061         VkDeviceSize                            m_bufferSize;
1062
1063         Move<VkImage>                           m_source;
1064         de::MovePtr<Allocation>         m_sourceImageAlloc;
1065         Move<VkBuffer>                          m_destination;
1066         de::MovePtr<Allocation>         m_destinationBufferAlloc;
1067 };
1068
1069 CopyImageToBuffer::CopyImageToBuffer (Context& context, TestParams testParams)
1070         : CopiesAndBlittingTestInstance(context, testParams)
1071         , m_textureFormat(mapVkFormat(testParams.src.image.format))
1072         , m_bufferSize(m_params.dst.buffer.size * tcu::getPixelSize(m_textureFormat))
1073 {
1074         const DeviceInterface&          vk                                      = context.getDeviceInterface();
1075         const VkDevice                          vkDevice                        = context.getDevice();
1076         const deUint32                          queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
1077         Allocator&                                      memAlloc                        = context.getDefaultAllocator();
1078
1079         // Create source image
1080         {
1081                 const VkImageCreateInfo         sourceImageParams               =
1082                 {
1083                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType              sType;
1084                         DE_NULL,                                                                // const void*                  pNext;
1085                         0u,                                                                             // VkImageCreateFlags   flags;
1086                         m_params.src.image.imageType,                   // VkImageType                  imageType;
1087                         m_params.src.image.format,                              // VkFormat                             format;
1088                         getExtent3D(m_params.src.image),                // VkExtent3D                   extent;
1089                         1u,                                                                             // deUint32                             mipLevels;
1090                         getArraySize(m_params.src.image),               // deUint32                             arraySize;
1091                         VK_SAMPLE_COUNT_1_BIT,                                  // deUint32                             samples;
1092                         VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                tiling;
1093                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1094                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT,        // VkImageUsageFlags    usage;
1095                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                sharingMode;
1096                         1u,                                                                             // deUint32                             queueFamilyCount;
1097                         &queueFamilyIndex,                                              // const deUint32*              pQueueFamilyIndices;
1098                         VK_IMAGE_LAYOUT_UNDEFINED,                              // VkImageLayout                initialLayout;
1099                 };
1100
1101                 m_source                        = createImage(vk, vkDevice, &sourceImageParams);
1102                 m_sourceImageAlloc      = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
1103                 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
1104         }
1105
1106         // Create destination buffer
1107         {
1108                 const VkBufferCreateInfo        destinationBufferParams =
1109                 {
1110                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
1111                         DE_NULL,                                                                        // const void*                  pNext;
1112                         0u,                                                                                     // VkBufferCreateFlags  flags;
1113                         m_bufferSize,                                                           // VkDeviceSize                 size;
1114                         VK_BUFFER_USAGE_TRANSFER_DST_BIT,                       // VkBufferUsageFlags   usage;
1115                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
1116                         1u,                                                                                     // deUint32                             queueFamilyIndexCount;
1117                         &queueFamilyIndex,                                                      // const deUint32*              pQueueFamilyIndices;
1118                 };
1119
1120                 m_destination                           = createBuffer(vk, vkDevice, &destinationBufferParams);
1121                 m_destinationBufferAlloc        = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::HostVisible);
1122                 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_destination, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset()));
1123         }
1124 }
1125
1126 tcu::TestStatus CopyImageToBuffer::iterate (void)
1127 {
1128         m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat,
1129                                                                                                                                                                 m_params.src.image.extent.width,
1130                                                                                                                                                                 m_params.src.image.extent.height,
1131                                                                                                                                                                 m_params.src.image.extent.depth));
1132         generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.src.image.extent.depth);
1133         m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat, (int)m_params.dst.buffer.size, 1));
1134         generateBuffer(m_destinationTextureLevel->getAccess(), (int)m_params.dst.buffer.size, 1, 1);
1135
1136         generateExpectedResult();
1137
1138         uploadImage(m_sourceTextureLevel->getAccess(), *m_source, m_params.src.image);
1139         uploadBuffer(m_destinationTextureLevel->getAccess(), *m_destinationBufferAlloc);
1140
1141         const DeviceInterface&          vk                      = m_context.getDeviceInterface();
1142         const VkDevice                          vkDevice        = m_context.getDevice();
1143         const VkQueue                           queue           = m_context.getUniversalQueue();
1144
1145         // Barriers for copying image to buffer
1146         const VkImageMemoryBarrier              imageBarrier            =
1147         {
1148                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
1149                 DE_NULL,                                                                        // const void*                          pNext;
1150                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
1151                 VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags                        dstAccessMask;
1152                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        oldLayout;
1153                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // VkImageLayout                        newLayout;
1154                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
1155                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
1156                 *m_source,                                                                      // VkImage                                      image;
1157                 {                                                                                       // VkImageSubresourceRange      subresourceRange;
1158                         getAspectFlags(m_textureFormat),        // VkImageAspectFlags   aspectMask;
1159                         0u,                                                             // deUint32                             baseMipLevel;
1160                         1u,                                                             // deUint32                             mipLevels;
1161                         0u,                                                             // deUint32                             baseArraySlice;
1162                         1u                                                              // deUint32                             arraySize;
1163                 }
1164         };
1165
1166         const VkBufferMemoryBarrier             bufferBarrier           =
1167         {
1168                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
1169                 DE_NULL,                                                                        // const void*          pNext;
1170                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags        srcAccessMask;
1171                 VK_ACCESS_HOST_READ_BIT,                                        // VkAccessFlags        dstAccessMask;
1172                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
1173                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
1174                 *m_destination,                                                         // VkBuffer                     buffer;
1175                 0u,                                                                                     // VkDeviceSize         offset;
1176                 m_bufferSize                                                            // VkDeviceSize         size;
1177         };
1178
1179         // Copy from image to buffer
1180         std::vector<VkBufferImageCopy>  bufferImageCopies;
1181         for (deUint32 i = 0; i < m_params.regions.size(); i++)
1182                 bufferImageCopies.push_back(m_params.regions[i].bufferImageCopy);
1183
1184         const VkCommandBufferBeginInfo  cmdBufferBeginInfo      =
1185         {
1186                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
1187                 DE_NULL,                                                                                                // const void*                                          pNext;
1188                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
1189                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1190         };
1191
1192         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1193         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
1194         vk.cmdCopyImageToBuffer(*m_cmdBuffer, m_source.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_destination.get(), (deUint32)m_params.regions.size(), &bufferImageCopies[0]);
1195         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1196         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1197
1198         submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
1199
1200         // Read buffer data
1201         de::MovePtr<tcu::TextureLevel>  resultLevel             (new tcu::TextureLevel(m_textureFormat, (int)m_params.dst.buffer.size, 1));
1202         invalidateMappedMemoryRange(vk, vkDevice, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset(), m_bufferSize);
1203         tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), m_destinationBufferAlloc->getHostPtr()));
1204
1205         return checkTestResult(resultLevel->getAccess());
1206 }
1207
1208 class CopyImageToBufferTestCase : public vkt::TestCase
1209 {
1210 public:
1211                                                         CopyImageToBufferTestCase       (tcu::TestContext&              testCtx,
1212                                                                                                                  const std::string&             name,
1213                                                                                                                  const std::string&             description,
1214                                                                                                                  const TestParams               params)
1215                                                                 : vkt::TestCase (testCtx, name, description)
1216                                                                 , m_params              (params)
1217                                                         {}
1218
1219         virtual TestInstance*   createInstance                          (Context&                               context) const
1220                                                         {
1221                                                                 return new CopyImageToBuffer(context, m_params);
1222                                                         }
1223 private:
1224         TestParams                              m_params;
1225 };
1226
1227 void CopyImageToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1228 {
1229         deUint32                        rowLength       = region.bufferImageCopy.bufferRowLength;
1230         if (!rowLength)
1231                 rowLength = region.bufferImageCopy.imageExtent.width;
1232
1233         deUint32                        imageHeight     = region.bufferImageCopy.bufferImageHeight;
1234         if (!imageHeight)
1235                 imageHeight = region.bufferImageCopy.imageExtent.height;
1236
1237         const int                       texelSize       = src.getFormat().getPixelSize();
1238         const VkExtent3D        extent          = region.bufferImageCopy.imageExtent;
1239         const VkOffset3D        srcOffset       = region.bufferImageCopy.imageOffset;
1240         const int                       texelOffset     = (int) region.bufferImageCopy.bufferOffset / texelSize;
1241
1242         for (deUint32 z = 0; z < extent.depth; z++)
1243         {
1244                 for (deUint32 y = 0; y < extent.height; y++)
1245                 {
1246                         int                                                                     texelIndex              = texelOffset + (z * imageHeight + y) * rowLength;
1247                         const tcu::ConstPixelBufferAccess       srcSubRegion    = tcu::getSubregion(src, srcOffset.x, srcOffset.y + y, srcOffset.z + z,
1248                                                                                                                                                                         region.bufferImageCopy.imageExtent.width, 1, 1);
1249                         const tcu::PixelBufferAccess            dstSubRegion    = tcu::getSubregion(dst, texelIndex, 0, region.bufferImageCopy.imageExtent.width, 1);
1250                         tcu::copy(dstSubRegion, srcSubRegion);
1251                 }
1252         }
1253 }
1254
1255 // Copy from buffer to image.
1256
1257 class CopyBufferToImage : public CopiesAndBlittingTestInstance
1258 {
1259 public:
1260                                                                 CopyBufferToImage                       (Context&       context,
1261                                                                                                                          TestParams     testParams);
1262         virtual tcu::TestStatus         iterate                                         (void);
1263 private:
1264         virtual void                            copyRegionToTextureLevel        (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1265
1266         tcu::TextureFormat                      m_textureFormat;
1267         VkDeviceSize                            m_bufferSize;
1268
1269         Move<VkBuffer>                          m_source;
1270         de::MovePtr<Allocation>         m_sourceBufferAlloc;
1271         Move<VkImage>                           m_destination;
1272         de::MovePtr<Allocation>         m_destinationImageAlloc;
1273 };
1274
1275 CopyBufferToImage::CopyBufferToImage (Context& context, TestParams testParams)
1276         : CopiesAndBlittingTestInstance(context, testParams)
1277         , m_textureFormat(mapVkFormat(testParams.dst.image.format))
1278         , m_bufferSize(m_params.src.buffer.size * tcu::getPixelSize(m_textureFormat))
1279 {
1280         const DeviceInterface&          vk                                      = context.getDeviceInterface();
1281         const VkDevice                          vkDevice                        = context.getDevice();
1282         const deUint32                          queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
1283         Allocator&                                      memAlloc                        = context.getDefaultAllocator();
1284
1285         // Create source buffer
1286         {
1287                 const VkBufferCreateInfo        sourceBufferParams              =
1288                 {
1289                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
1290                         DE_NULL,                                                                        // const void*                  pNext;
1291                         0u,                                                                                     // VkBufferCreateFlags  flags;
1292                         m_bufferSize,                                                           // VkDeviceSize                 size;
1293                         VK_BUFFER_USAGE_TRANSFER_SRC_BIT,                       // VkBufferUsageFlags   usage;
1294                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
1295                         1u,                                                                                     // deUint32                             queueFamilyIndexCount;
1296                         &queueFamilyIndex,                                                      // const deUint32*              pQueueFamilyIndices;
1297                 };
1298
1299                 m_source                                = createBuffer(vk, vkDevice, &sourceBufferParams);
1300                 m_sourceBufferAlloc             = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::HostVisible);
1301                 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_source, m_sourceBufferAlloc->getMemory(), m_sourceBufferAlloc->getOffset()));
1302         }
1303
1304         // Create destination image
1305         {
1306                 const VkImageCreateInfo         destinationImageParams  =
1307                 {
1308                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType              sType;
1309                         DE_NULL,                                                                // const void*                  pNext;
1310                         0u,                                                                             // VkImageCreateFlags   flags;
1311                         m_params.dst.image.imageType,                   // VkImageType                  imageType;
1312                         m_params.dst.image.format,                              // VkFormat                             format;
1313                         getExtent3D(m_params.dst.image),                // VkExtent3D                   extent;
1314                         1u,                                                                             // deUint32                             mipLevels;
1315                         getArraySize(m_params.dst.image),               // deUint32                             arraySize;
1316                         VK_SAMPLE_COUNT_1_BIT,                                  // deUint32                             samples;
1317                         VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                tiling;
1318                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1319                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT,        // VkImageUsageFlags    usage;
1320                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                sharingMode;
1321                         1u,                                                                             // deUint32                             queueFamilyCount;
1322                         &queueFamilyIndex,                                              // const deUint32*              pQueueFamilyIndices;
1323                         VK_IMAGE_LAYOUT_UNDEFINED,                              // VkImageLayout                initialLayout;
1324                 };
1325
1326                 m_destination                   = createImage(vk, vkDevice, &destinationImageParams);
1327                 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
1328                 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
1329         }
1330 }
1331
1332 tcu::TestStatus CopyBufferToImage::iterate (void)
1333 {
1334         m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat, (int)m_params.src.buffer.size, 1));
1335         generateBuffer(m_sourceTextureLevel->getAccess(), (int)m_params.src.buffer.size, 1, 1);
1336         m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat,
1337                                                                                                                                                                         m_params.dst.image.extent.width,
1338                                                                                                                                                                         m_params.dst.image.extent.height,
1339                                                                                                                                                                         m_params.dst.image.extent.depth));
1340
1341         generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth);
1342
1343         generateExpectedResult();
1344
1345         uploadBuffer(m_sourceTextureLevel->getAccess(), *m_sourceBufferAlloc);
1346         uploadImage(m_destinationTextureLevel->getAccess(), *m_destination, m_params.dst.image);
1347
1348         const DeviceInterface&          vk                      = m_context.getDeviceInterface();
1349         const VkDevice                          vkDevice        = m_context.getDevice();
1350         const VkQueue                           queue           = m_context.getUniversalQueue();
1351         SimpleAllocator                         memAlloc        (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
1352
1353         const VkImageMemoryBarrier      imageBarrier    =
1354         {
1355                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
1356                 DE_NULL,                                                                        // const void*                          pNext;
1357                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
1358                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        dstAccessMask;
1359                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        oldLayout;
1360                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        newLayout;
1361                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
1362                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
1363                 *m_destination,                                                         // VkImage                                      image;
1364                 {                                                                                       // VkImageSubresourceRange      subresourceRange;
1365                         getAspectFlags(m_textureFormat),        // VkImageAspectFlags   aspectMask;
1366                         0u,                                                             // deUint32                             baseMipLevel;
1367                         1u,                                                             // deUint32                             mipLevels;
1368                         0u,                                                             // deUint32                             baseArraySlice;
1369                         1u                                                              // deUint32                             arraySize;
1370                 }
1371         };
1372
1373         // Copy from buffer to image
1374         std::vector<VkBufferImageCopy>          bufferImageCopies;
1375         for (deUint32 i = 0; i < m_params.regions.size(); i++)
1376                 bufferImageCopies.push_back(m_params.regions[i].bufferImageCopy);
1377
1378         const VkCommandBufferBeginInfo  cmdBufferBeginInfo      =
1379         {
1380                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
1381                 DE_NULL,                                                                                                // const void*                                          pNext;
1382                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
1383                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1384         };
1385
1386         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1387         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
1388         vk.cmdCopyBufferToImage(*m_cmdBuffer, m_source.get(), m_destination.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)m_params.regions.size(), bufferImageCopies.data());
1389         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1390
1391         submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
1392
1393         de::MovePtr<tcu::TextureLevel>  resultLevel     = readImage(vk, vkDevice, queue, memAlloc, *m_destination, m_params.dst.image);
1394
1395         return checkTestResult(resultLevel->getAccess());
1396 }
1397
1398 class CopyBufferToImageTestCase : public vkt::TestCase
1399 {
1400 public:
1401                                                         CopyBufferToImageTestCase       (tcu::TestContext&              testCtx,
1402                                                                                                                  const std::string&             name,
1403                                                                                                                  const std::string&             description,
1404                                                                                                                  const TestParams               params)
1405                                                                 : vkt::TestCase (testCtx, name, description)
1406                                                                 , m_params              (params)
1407                                                         {}
1408
1409         virtual                                 ~CopyBufferToImageTestCase      (void) {}
1410
1411         virtual TestInstance*   createInstance                          (Context&                               context) const
1412                                                         {
1413                                                                 return new CopyBufferToImage(context, m_params);
1414                                                         }
1415 private:
1416         TestParams                              m_params;
1417 };
1418
1419 void CopyBufferToImage::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1420 {
1421         deUint32                        rowLength       = region.bufferImageCopy.bufferRowLength;
1422         if (!rowLength)
1423                 rowLength = region.bufferImageCopy.imageExtent.width;
1424
1425         deUint32                        imageHeight     = region.bufferImageCopy.bufferImageHeight;
1426         if (!imageHeight)
1427                 imageHeight = region.bufferImageCopy.imageExtent.height;
1428
1429         const int                       texelSize       = dst.getFormat().getPixelSize();
1430         const VkExtent3D        extent          = region.bufferImageCopy.imageExtent;
1431         const VkOffset3D        dstOffset       = region.bufferImageCopy.imageOffset;
1432         const int                       texelOffset     = (int) region.bufferImageCopy.bufferOffset / texelSize;
1433
1434         for (deUint32 z = 0; z < extent.depth; z++)
1435         {
1436                 for (deUint32 y = 0; y < extent.height; y++)
1437                 {
1438                         int                                                                     texelIndex              = texelOffset + (z * imageHeight + y) * rowLength;
1439                         const tcu::ConstPixelBufferAccess       srcSubRegion    = tcu::getSubregion(src, texelIndex, 0, region.bufferImageCopy.imageExtent.width, 1);
1440                         const tcu::PixelBufferAccess            dstSubRegion    = tcu::getSubregion(dst, dstOffset.x, dstOffset.y + y, dstOffset.z + z,
1441                                                                                                                                                                         region.bufferImageCopy.imageExtent.width, 1, 1);
1442                         tcu::copy(dstSubRegion, srcSubRegion);
1443                 }
1444         }
1445 }
1446
1447 // Copy from image to image with scaling.
1448
1449 class BlittingImages : public CopiesAndBlittingTestInstance
1450 {
1451 public:
1452                                                                                 BlittingImages                                  (Context&       context,
1453                                                                                                                                                  TestParams params);
1454         virtual tcu::TestStatus                         iterate                                                 (void);
1455 protected:
1456         virtual tcu::TestStatus                         checkTestResult                                 (tcu::ConstPixelBufferAccess result);
1457         virtual void                                            copyRegionToTextureLevel                (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1458         virtual void                                            generateExpectedResult                  (void);
1459 private:
1460         bool                                                            checkClampedAndUnclampedResult  (const tcu::ConstPixelBufferAccess&, const tcu::ConstPixelBufferAccess&, const tcu::ConstPixelBufferAccess&);
1461         Move<VkImage>                                           m_source;
1462         de::MovePtr<Allocation>                         m_sourceImageAlloc;
1463         Move<VkImage>                                           m_destination;
1464         de::MovePtr<Allocation>                         m_destinationImageAlloc;
1465
1466         de::MovePtr<tcu::TextureLevel>          m_unclampedExpectedTextureLevel;
1467 };
1468
1469 BlittingImages::BlittingImages (Context& context, TestParams params)
1470         : CopiesAndBlittingTestInstance(context, params)
1471 {
1472         const DeviceInterface&          vk                                      = context.getDeviceInterface();
1473         const VkDevice                          vkDevice                        = context.getDevice();
1474         const deUint32                          queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
1475         Allocator&                                      memAlloc                        = context.getDefaultAllocator();
1476
1477         VkImageFormatProperties properties;
1478         if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
1479                                                                                                                                                                 m_params.src.image.format,
1480                                                                                                                                                                 VK_IMAGE_TYPE_2D,
1481                                                                                                                                                                 VK_IMAGE_TILING_OPTIMAL,
1482                                                                                                                                                                 VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
1483                                                                                                                                                                 0,
1484                                                                                                                                                                 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
1485                 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
1486                                                                                                                                                                 m_params.dst.image.format,
1487                                                                                                                                                                 VK_IMAGE_TYPE_2D,
1488                                                                                                                                                                 VK_IMAGE_TILING_OPTIMAL,
1489                                                                                                                                                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1490                                                                                                                                                                 0,
1491                                                                                                                                                                 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
1492         {
1493                 TCU_THROW(NotSupportedError, "Format not supported");
1494         }
1495
1496         VkFormatProperties srcFormatProperties;
1497         context.getInstanceInterface().getPhysicalDeviceFormatProperties(context.getPhysicalDevice(), m_params.src.image.format, &srcFormatProperties);
1498         if (!(srcFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT))
1499         {
1500                 TCU_THROW(NotSupportedError, "Format feature blit source not supported");
1501         }
1502
1503         VkFormatProperties dstFormatProperties;
1504         context.getInstanceInterface().getPhysicalDeviceFormatProperties(context.getPhysicalDevice(), m_params.dst.image.format, &dstFormatProperties);
1505         if (!(dstFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_DST_BIT))
1506         {
1507                 TCU_THROW(NotSupportedError, "Format feature blit destination not supported");
1508         }
1509
1510         if (m_params.filter == VK_FILTER_LINEAR)
1511         {
1512                 if (!(srcFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT))
1513                         TCU_THROW(NotSupportedError, "Source format feature sampled image filter linear not supported");
1514                 if (!(dstFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT))
1515                         TCU_THROW(NotSupportedError, "Destination format feature sampled image filter linear not supported");
1516         }
1517
1518         // Create source image
1519         {
1520                 const VkImageCreateInfo         sourceImageParams               =
1521                 {
1522                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType              sType;
1523                         DE_NULL,                                                                // const void*                  pNext;
1524                         0u,                                                                             // VkImageCreateFlags   flags;
1525                         m_params.src.image.imageType,                   // VkImageType                  imageType;
1526                         m_params.src.image.format,                              // VkFormat                             format;
1527                         getExtent3D(m_params.src.image),                // VkExtent3D                   extent;
1528                         1u,                                                                             // deUint32                             mipLevels;
1529                         getArraySize(m_params.src.image),               // deUint32                             arraySize;
1530                         VK_SAMPLE_COUNT_1_BIT,                                  // deUint32                             samples;
1531                         VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                tiling;
1532                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1533                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT,        // VkImageUsageFlags    usage;
1534                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                sharingMode;
1535                         1u,                                                                             // deUint32                             queueFamilyCount;
1536                         &queueFamilyIndex,                                              // const deUint32*              pQueueFamilyIndices;
1537                         VK_IMAGE_LAYOUT_UNDEFINED,                              // VkImageLayout                initialLayout;
1538                 };
1539
1540                 m_source = createImage(vk, vkDevice, &sourceImageParams);
1541                 m_sourceImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
1542                 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
1543         }
1544
1545         // Create destination image
1546         {
1547                 const VkImageCreateInfo         destinationImageParams  =
1548                 {
1549                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType              sType;
1550                         DE_NULL,                                                                // const void*                  pNext;
1551                         0u,                                                                             // VkImageCreateFlags   flags;
1552                         m_params.dst.image.imageType,                   // VkImageType                  imageType;
1553                         m_params.dst.image.format,                              // VkFormat                             format;
1554                         getExtent3D(m_params.dst.image),                // VkExtent3D                   extent;
1555                         1u,                                                                             // deUint32                             mipLevels;
1556                         getArraySize(m_params.dst.image),               // deUint32                             arraySize;
1557                         VK_SAMPLE_COUNT_1_BIT,                                  // deUint32                             samples;
1558                         VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                tiling;
1559                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1560                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT,        // VkImageUsageFlags    usage;
1561                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                sharingMode;
1562                         1u,                                                                             // deUint32                             queueFamilyCount;
1563                         &queueFamilyIndex,                                              // const deUint32*              pQueueFamilyIndices;
1564                         VK_IMAGE_LAYOUT_UNDEFINED,                              // VkImageLayout                initialLayout;
1565                 };
1566
1567                 m_destination = createImage(vk, vkDevice, &destinationImageParams);
1568                 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
1569                 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
1570         }
1571 }
1572
1573 tcu::TestStatus BlittingImages::iterate (void)
1574 {
1575         const tcu::TextureFormat        srcTcuFormat            = mapVkFormat(m_params.src.image.format);
1576         const tcu::TextureFormat        dstTcuFormat            = mapVkFormat(m_params.dst.image.format);
1577         m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
1578                                                                                                                                                                 m_params.src.image.extent.width,
1579                                                                                                                                                                 m_params.src.image.extent.height,
1580                                                                                                                                                                 m_params.src.image.extent.depth));
1581         generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.src.image.extent.depth, FILL_MODE_GRADIENT);
1582         m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
1583                                                                                                                                                                          (int)m_params.dst.image.extent.width,
1584                                                                                                                                                                          (int)m_params.dst.image.extent.height,
1585                                                                                                                                                                          (int)m_params.dst.image.extent.depth));
1586         generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth, FILL_MODE_WHITE);
1587         generateExpectedResult();
1588
1589         uploadImage(m_sourceTextureLevel->getAccess(), m_source.get(), m_params.src.image);
1590         uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
1591
1592         const DeviceInterface&          vk                                      = m_context.getDeviceInterface();
1593         const VkDevice                          vkDevice                        = m_context.getDevice();
1594         const VkQueue                           queue                           = m_context.getUniversalQueue();
1595         Allocator&                                      memAlloc                        = m_context.getDefaultAllocator();
1596
1597         std::vector<VkImageBlit>        regions;
1598         for (deUint32 i = 0; i < m_params.regions.size(); i++)
1599                 regions.push_back(m_params.regions[i].imageBlit);
1600
1601         // Barriers for copying image to buffer
1602         const VkImageMemoryBarrier              srcImageBarrier         =
1603         {
1604                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
1605                 DE_NULL,                                                                        // const void*                          pNext;
1606                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
1607                 VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags                        dstAccessMask;
1608                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        oldLayout;
1609                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // VkImageLayout                        newLayout;
1610                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
1611                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
1612                 m_source.get(),                                                         // VkImage                                      image;
1613                 {                                                                                       // VkImageSubresourceRange      subresourceRange;
1614                         getAspectFlags(srcTcuFormat),   // VkImageAspectFlags   aspectMask;
1615                         0u,                                                             // deUint32                             baseMipLevel;
1616                         1u,                                                             // deUint32                             mipLevels;
1617                         0u,                                                             // deUint32                             baseArraySlice;
1618                         1u                                                              // deUint32                             arraySize;
1619                 }
1620         };
1621
1622         const VkImageMemoryBarrier              dstImageBarrier         =
1623         {
1624                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
1625                 DE_NULL,                                                                        // const void*                          pNext;
1626                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
1627                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        dstAccessMask;
1628                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        oldLayout;
1629                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        newLayout;
1630                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
1631                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
1632                 m_destination.get(),                                            // VkImage                                      image;
1633                 {                                                                                       // VkImageSubresourceRange      subresourceRange;
1634                         getAspectFlags(dstTcuFormat),   // VkImageAspectFlags   aspectMask;
1635                         0u,                                                             // deUint32                             baseMipLevel;
1636                         1u,                                                             // deUint32                             mipLevels;
1637                         0u,                                                             // deUint32                             baseArraySlice;
1638                         1u                                                              // deUint32                             arraySize;
1639                 }
1640         };
1641
1642         const VkCommandBufferBeginInfo  cmdBufferBeginInfo      =
1643         {
1644                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
1645                 DE_NULL,                                                                                                // const void*                                          pNext;
1646                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
1647                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1648         };
1649
1650         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1651         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &srcImageBarrier);
1652         vk.cmdBlitImage(*m_cmdBuffer, m_source.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_destination.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)m_params.regions.size(), &regions[0], m_params.filter);
1653         vk.cmdPipelineBarrier(*m_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, 1, &dstImageBarrier);
1654         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1655         submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
1656
1657         de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(vk, vkDevice, queue, memAlloc, *m_destination, m_params.dst.image);
1658
1659         return checkTestResult(resultTextureLevel->getAccess());
1660 }
1661
1662 static float calculateFloatConversionError (int srcBits)
1663 {
1664         if (srcBits > 0)
1665         {
1666                 const int       clampedBits     = de::clamp<int>(srcBits, 0, 32);
1667                 const float     srcMaxValue     = de::max((float)(1ULL<<clampedBits) - 1.0f, 1.0f);
1668                 const float     error           = 1.0f / srcMaxValue;
1669
1670                 return de::clamp<float>(error, 0.0f, 1.0f);
1671         }
1672         else
1673                 return 1.0f;
1674 }
1675
1676 tcu::Vec4 getFormatThreshold (const tcu::TextureFormat& format)
1677 {
1678         tcu::Vec4 threshold(0.01f);
1679
1680         switch (format.type)
1681         {
1682         case tcu::TextureFormat::HALF_FLOAT:
1683                 threshold = tcu::Vec4(0.005f);
1684                 break;
1685
1686         case tcu::TextureFormat::FLOAT:
1687         case tcu::TextureFormat::FLOAT64:
1688                 threshold = tcu::Vec4(0.001f);
1689                 break;
1690
1691         case tcu::TextureFormat::UNSIGNED_INT_11F_11F_10F_REV:
1692                 threshold = tcu::Vec4(0.02f, 0.02f, 0.0625f, 1.0f);
1693                 break;
1694
1695         case tcu::TextureFormat::UNSIGNED_INT_999_E5_REV:
1696                 threshold = tcu::Vec4(0.05f, 0.05f, 0.05f, 1.0f);
1697                 break;
1698
1699         default:
1700                 const tcu::IVec4 bits = tcu::getTextureFormatMantissaBitDepth(format);
1701                 threshold = tcu::Vec4(calculateFloatConversionError(bits.x()),
1702                                       calculateFloatConversionError(bits.y()),
1703                                       calculateFloatConversionError(bits.z()),
1704                                       calculateFloatConversionError(bits.w()));
1705         }
1706
1707         // Return value matching the channel order specified by the format
1708         if (format.order == tcu::TextureFormat::BGR || format.order == tcu::TextureFormat::BGRA)
1709                 return threshold.swizzle(2, 1, 0, 3);
1710         else
1711                 return threshold;
1712 }
1713
1714 bool BlittingImages::checkClampedAndUnclampedResult(const tcu::ConstPixelBufferAccess& result,
1715                                                                                                         const tcu::ConstPixelBufferAccess& clampedExpected,
1716                                                                                                         const tcu::ConstPixelBufferAccess& unclampedExpected)
1717 {
1718         tcu::TestLog&                           log                     (m_context.getTestContext().getLog());
1719         const bool                                      isLinear        = m_params.filter == VK_FILTER_LINEAR;
1720         const tcu::TextureFormat        srcFormat       = m_sourceTextureLevel->getFormat();
1721         const tcu::TextureFormat        dstFormat       = result.getFormat();
1722         bool                                            isOk            = false;
1723
1724         if (isLinear)
1725                 log << tcu::TestLog::Section("ClampedSourceImage", "Region with clamped edges on source image.");
1726
1727         if (isFloatFormat(mapTextureFormat(dstFormat)))
1728         {
1729                 const bool              srcIsSRGB       = tcu::isSRGB(srcFormat);
1730                 const tcu::Vec4 srcMaxDiff      = getFormatThreshold(srcFormat) * tcu::Vec4(srcIsSRGB ? 2.0f : 1.0f);
1731                 const tcu::Vec4 dstMaxDiff      = getFormatThreshold(dstFormat);
1732                 const tcu::Vec4 threshold       = tcu::max(srcMaxDiff, dstMaxDiff);
1733
1734                 isOk = tcu::floatThresholdCompare(log, "Compare", "Result comparsion", clampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1735
1736                 if (isLinear)
1737                         log << tcu::TestLog::EndSection;
1738
1739                 if (!isOk && isLinear)
1740                 {
1741                         log << tcu::TestLog::Section("NonClampedSourceImage", "Region with non-clamped edges on source image.");
1742                         isOk = tcu::floatThresholdCompare(log, "Compare", "Result comparsion", unclampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1743                         log << tcu::TestLog::EndSection;
1744                 }
1745         }
1746         else
1747         {
1748                 tcu::UVec4      threshold;
1749                 // Calculate threshold depending on channel width of destination format.
1750                 const tcu::IVec4        bitDepth        = tcu::getTextureFormatBitDepth(dstFormat);
1751                 for (deUint32 i = 0; i < 4; ++i)
1752                         threshold[i] = de::max( (0x1 << bitDepth[i]) / 256, 1);
1753
1754                 isOk = tcu::intThresholdCompare(log, "Compare", "Result comparsion", clampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1755
1756                 if (isLinear)
1757                         log << tcu::TestLog::EndSection;
1758
1759                 if (!isOk && isLinear)
1760                 {
1761                         log << tcu::TestLog::Section("NonClampedSourceImage", "Region with non-clamped edges on source image.");
1762                         isOk = tcu::intThresholdCompare(log, "Compare", "Result comparsion", unclampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1763                         log << tcu::TestLog::EndSection;
1764                 }
1765         }
1766         return isOk;
1767 }
1768
1769 tcu::TestStatus BlittingImages::checkTestResult (tcu::ConstPixelBufferAccess result)
1770 {
1771         DE_ASSERT(m_params.filter == VK_FILTER_NEAREST || m_params.filter == VK_FILTER_LINEAR);
1772
1773         if (tcu::isCombinedDepthStencilType(result.getFormat().type))
1774         {
1775                 if (tcu::hasDepthComponent(result.getFormat().order))
1776                 {
1777                         const tcu::Sampler::DepthStencilMode    mode                            = tcu::Sampler::MODE_DEPTH;
1778                         const tcu::ConstPixelBufferAccess               depthResult                     = tcu::getEffectiveDepthStencilAccess(result, mode);
1779                         const tcu::ConstPixelBufferAccess               clampedExpected         = tcu::getEffectiveDepthStencilAccess(m_expectedTextureLevel->getAccess(), mode);
1780                         const tcu::ConstPixelBufferAccess               unclampedExpected       = m_params.filter == VK_FILTER_LINEAR ? tcu::getEffectiveDepthStencilAccess(m_unclampedExpectedTextureLevel->getAccess(), mode) : tcu::ConstPixelBufferAccess();
1781
1782                         if (!checkClampedAndUnclampedResult(depthResult, clampedExpected, unclampedExpected))
1783                         {
1784                                 return tcu::TestStatus::fail("CopiesAndBlitting test");
1785                         }
1786                 }
1787
1788                 if (tcu::hasStencilComponent(result.getFormat().order))
1789                 {
1790                         const tcu::Sampler::DepthStencilMode    mode                            = tcu::Sampler::MODE_STENCIL;
1791                         const tcu::ConstPixelBufferAccess               stencilResult           = tcu::getEffectiveDepthStencilAccess(result, mode);
1792                         const tcu::ConstPixelBufferAccess               clampedExpected         = tcu::getEffectiveDepthStencilAccess(m_expectedTextureLevel->getAccess(), mode);
1793                         const tcu::ConstPixelBufferAccess               unclampedExpected       = m_params.filter == VK_FILTER_LINEAR ? tcu::getEffectiveDepthStencilAccess(m_unclampedExpectedTextureLevel->getAccess(), mode) : tcu::ConstPixelBufferAccess();
1794
1795                         if (!checkClampedAndUnclampedResult(stencilResult, clampedExpected, unclampedExpected))
1796                         {
1797                                 return tcu::TestStatus::fail("CopiesAndBlitting test");
1798                         }
1799                 }
1800         }
1801         else
1802         {
1803                 if (!checkClampedAndUnclampedResult(result, m_expectedTextureLevel->getAccess(), m_params.filter == VK_FILTER_LINEAR ? m_unclampedExpectedTextureLevel->getAccess() : tcu::ConstPixelBufferAccess()))
1804                 {
1805                         return tcu::TestStatus::fail("CopiesAndBlitting test");
1806                 }
1807         }
1808
1809         return tcu::TestStatus::pass("CopiesAndBlitting test");
1810 }
1811
1812 tcu::Vec4 linearToSRGBIfNeeded (const tcu::TextureFormat& format, const tcu::Vec4& color)
1813 {
1814         return isSRGB(format) ? linearToSRGB(color) : color;
1815 }
1816
1817 void scaleFromWholeSrcBuffer (const tcu::PixelBufferAccess& dst, const tcu::ConstPixelBufferAccess& src, const VkOffset3D regionOffset, const VkOffset3D regionExtent, tcu::Sampler::FilterMode filter)
1818 {
1819         DE_ASSERT(filter == tcu::Sampler::LINEAR);
1820         DE_ASSERT(dst.getDepth() == 1 && src.getDepth() == 1);
1821
1822         tcu::Sampler sampler(tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE,
1823                                         filter, filter, 0.0f, false);
1824
1825         float sX = (float)regionExtent.x / (float)dst.getWidth();
1826         float sY = (float)regionExtent.y / (float)dst.getHeight();
1827
1828         for (int y = 0; y < dst.getHeight(); y++)
1829         for (int x = 0; x < dst.getWidth(); x++)
1830                 dst.setPixel(linearToSRGBIfNeeded(dst.getFormat(), src.sample2D(sampler, filter, (float)regionOffset.x + ((float)x+0.5f)*sX, (float)regionOffset.y + ((float)y+0.5f)*sY, 0)), x, y);
1831 }
1832
1833 void blit (const tcu::PixelBufferAccess& dst, const tcu::ConstPixelBufferAccess& src, const tcu::Sampler::FilterMode filter, const MirrorMode mirrorMode)
1834 {
1835         DE_ASSERT(filter == tcu::Sampler::NEAREST || filter == tcu::Sampler::LINEAR);
1836
1837         tcu::Sampler sampler(tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE,
1838                                                  filter, filter, 0.0f, false);
1839
1840         const float sX = (float)src.getWidth() / (float)dst.getWidth();
1841         const float sY = (float)src.getHeight() / (float)dst.getHeight();
1842         const float sZ = (float)src.getDepth() / (float)dst.getDepth();
1843
1844         tcu::Mat2 rotMatrix;
1845         rotMatrix(0,0) = (mirrorMode & MIRROR_MODE_X) ? -1.0f : 1.0f;
1846         rotMatrix(0,1) = 0.0f;
1847         rotMatrix(1,0) = 0.0f;
1848         rotMatrix(1,1) = (mirrorMode & MIRROR_MODE_Y) ? -1.0f : 1.0f;
1849
1850         const int xOffset = (mirrorMode & MIRROR_MODE_X) ? dst.getWidth() - 1 : 0;
1851         const int yOffset = (mirrorMode & MIRROR_MODE_Y) ? dst.getHeight() - 1 : 0;
1852
1853         if (dst.getDepth() == 1 && src.getDepth() == 1)
1854         {
1855                 for (int y = 0; y < dst.getHeight(); ++y)
1856                 for (int x = 0; x < dst.getWidth(); ++x)
1857                 {
1858                         const tcu::Vec2 xy = rotMatrix * tcu::Vec2((float)x,(float)y);
1859                         dst.setPixel(linearToSRGBIfNeeded(dst.getFormat(), src.sample2D(sampler, filter, ((float)x+0.5f)*sX, ((float)y+0.5f)*sY, 0)), (int)round(xy[0]) + xOffset, (int)round(xy[1]) + yOffset);
1860                 }
1861         }
1862         else
1863         {
1864                 for (int z = 0; z < dst.getDepth(); ++z)
1865                 for (int y = 0; y < dst.getHeight(); ++y)
1866                 for (int x = 0; x < dst.getWidth(); ++x)
1867                 {
1868                         const tcu::Vec2 xy = rotMatrix * tcu::Vec2((float)x,(float)y);
1869                         dst.setPixel(linearToSRGBIfNeeded(dst.getFormat(), src.sample3D(sampler, filter, ((float)x+0.5f)*sX, ((float)y+0.5f)*sY, ((float)z+0.5f)*sZ)), (int)round(xy[0]) + xOffset, (int)round(xy[1]) + yOffset, z);
1870                 }
1871         }
1872 }
1873
1874 void flipCoordinates (CopyRegion& region, const MirrorMode mirrorMode)
1875 {
1876         const VkOffset3D dstOffset0 = region.imageBlit.dstOffsets[0];
1877         const VkOffset3D dstOffset1 = region.imageBlit.dstOffsets[1];
1878         const VkOffset3D srcOffset0 = region.imageBlit.srcOffsets[0];
1879         const VkOffset3D srcOffset1 = region.imageBlit.srcOffsets[1];
1880
1881         if (mirrorMode > MIRROR_MODE_NONE && mirrorMode < MIRROR_MODE_LAST)
1882         {
1883                 //sourceRegion
1884                 region.imageBlit.srcOffsets[0].x = std::min(srcOffset0.x, srcOffset1.x);
1885                 region.imageBlit.srcOffsets[0].y = std::min(srcOffset0.y, srcOffset1.y);
1886
1887                 region.imageBlit.srcOffsets[1].x = std::max(srcOffset0.x, srcOffset1.x);
1888                 region.imageBlit.srcOffsets[1].y = std::max(srcOffset0.y, srcOffset1.y);
1889
1890                 //destinationRegion
1891                 region.imageBlit.dstOffsets[0].x = std::min(dstOffset0.x, dstOffset1.x);
1892                 region.imageBlit.dstOffsets[0].y = std::min(dstOffset0.y, dstOffset1.y);
1893
1894                 region.imageBlit.dstOffsets[1].x = std::max(dstOffset0.x, dstOffset1.x);
1895                 region.imageBlit.dstOffsets[1].y = std::max(dstOffset0.y, dstOffset1.y);
1896         }
1897 }
1898
1899 MirrorMode getMirrorMode(const VkOffset3D x1, const VkOffset3D x2)
1900 {
1901         if (x1.x >= x2.x && x1.y >= x2.y)
1902         {
1903                 return MIRROR_MODE_XY;
1904         }
1905         else if (x1.x <= x2.x && x1.y <= x2.y)
1906         {
1907                 return MIRROR_MODE_NONE;
1908         }
1909         else if (x1.x <= x2.x && x1.y >= x2.y)
1910         {
1911                 return MIRROR_MODE_Y;
1912         }
1913         else if (x1.x >= x2.x && x1.y <= x2.y)
1914         {
1915                 return MIRROR_MODE_X;
1916         }
1917         return MIRROR_MODE_LAST;
1918 }
1919
1920 MirrorMode getMirrorMode(const VkOffset3D s1, const VkOffset3D s2, const VkOffset3D d1, const VkOffset3D d2)
1921 {
1922         const MirrorMode source          = getMirrorMode(s1, s2);
1923         const MirrorMode destination = getMirrorMode(d1, d2);
1924
1925         if (source == destination)
1926         {
1927                 return MIRROR_MODE_NONE;
1928         }
1929         else if ((source == MIRROR_MODE_XY && destination == MIRROR_MODE_X)       || (destination == MIRROR_MODE_XY && source == MIRROR_MODE_X) ||
1930                          (source == MIRROR_MODE_Y && destination == MIRROR_MODE_NONE) || (destination == MIRROR_MODE_Y && source == MIRROR_MODE_NONE))
1931         {
1932                 return MIRROR_MODE_Y;
1933         }
1934         else if ((source == MIRROR_MODE_XY && destination == MIRROR_MODE_Y)       || (destination == MIRROR_MODE_XY && source == MIRROR_MODE_Y) ||
1935                          (source == MIRROR_MODE_X && destination == MIRROR_MODE_NONE) || (destination == MIRROR_MODE_X && source == MIRROR_MODE_NONE))
1936         {
1937                 return MIRROR_MODE_X;
1938         }
1939         else if ((source == MIRROR_MODE_XY && destination == MIRROR_MODE_NONE) || (destination == MIRROR_MODE_XY && source == MIRROR_MODE_NONE))
1940         {
1941                 return MIRROR_MODE_XY;
1942         }
1943         return MIRROR_MODE_LAST;
1944 }
1945
1946 void BlittingImages::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1947 {
1948         const MirrorMode mirrorMode = getMirrorMode(region.imageBlit.srcOffsets[0],
1949                                                                                                 region.imageBlit.srcOffsets[1],
1950                                                                                                 region.imageBlit.dstOffsets[0],
1951                                                                                                 region.imageBlit.dstOffsets[1]);
1952
1953         flipCoordinates(region, mirrorMode);
1954
1955         const VkOffset3D                                        srcOffset               = region.imageBlit.srcOffsets[0];
1956         const VkOffset3D                                        srcExtent               =
1957         {
1958                 region.imageBlit.srcOffsets[1].x - srcOffset.x,
1959                 region.imageBlit.srcOffsets[1].y - srcOffset.y,
1960                 region.imageBlit.srcOffsets[1].z - srcOffset.z
1961         };
1962         const VkOffset3D                                        dstOffset               = region.imageBlit.dstOffsets[0];
1963         const VkOffset3D                                        dstExtent               =
1964         {
1965                 region.imageBlit.dstOffsets[1].x - dstOffset.x,
1966                 region.imageBlit.dstOffsets[1].y - dstOffset.y,
1967                 region.imageBlit.dstOffsets[1].z - dstOffset.z
1968         };
1969         const tcu::Sampler::FilterMode          filter                  = (m_params.filter == VK_FILTER_LINEAR) ? tcu::Sampler::LINEAR : tcu::Sampler::NEAREST;
1970
1971         if (tcu::isCombinedDepthStencilType(src.getFormat().type))
1972         {
1973                 DE_ASSERT(src.getFormat() == dst.getFormat());
1974                 // Scale depth.
1975                 if (tcu::hasDepthComponent(src.getFormat().order))
1976                 {
1977                         const tcu::ConstPixelBufferAccess       srcSubRegion    = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcExtent.x, srcExtent.y), tcu::Sampler::MODE_DEPTH);
1978                         const tcu::PixelBufferAccess            dstSubRegion    = getEffectiveDepthStencilAccess(tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_DEPTH);
1979                         tcu::scale(dstSubRegion, srcSubRegion, filter);
1980
1981                         if (filter == tcu::Sampler::LINEAR)
1982                         {
1983                                 const tcu::ConstPixelBufferAccess       depthSrc                        = getEffectiveDepthStencilAccess(src, tcu::Sampler::MODE_DEPTH);
1984                                 const tcu::PixelBufferAccess            unclampedSubRegion      = getEffectiveDepthStencilAccess(tcu::getSubregion(m_unclampedExpectedTextureLevel->getAccess(), dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_DEPTH);
1985                                 scaleFromWholeSrcBuffer(unclampedSubRegion, depthSrc, srcOffset, srcExtent, filter);
1986                         }
1987                 }
1988
1989                 // Scale stencil.
1990                 if (tcu::hasStencilComponent(src.getFormat().order))
1991                 {
1992                         const tcu::ConstPixelBufferAccess       srcSubRegion    = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcExtent.x, srcExtent.y), tcu::Sampler::MODE_STENCIL);
1993                         const tcu::PixelBufferAccess            dstSubRegion    = getEffectiveDepthStencilAccess(tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_STENCIL);
1994                         blit(dstSubRegion, srcSubRegion, filter, mirrorMode);
1995
1996                         if (filter == tcu::Sampler::LINEAR)
1997                         {
1998                                 const tcu::ConstPixelBufferAccess       stencilSrc                      = getEffectiveDepthStencilAccess(src, tcu::Sampler::MODE_STENCIL);
1999                                 const tcu::PixelBufferAccess            unclampedSubRegion      = getEffectiveDepthStencilAccess(tcu::getSubregion(m_unclampedExpectedTextureLevel->getAccess(), dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_STENCIL);
2000                                 scaleFromWholeSrcBuffer(unclampedSubRegion, stencilSrc, srcOffset, srcExtent, filter);
2001                         }
2002                 }
2003         }
2004         else
2005         {
2006                 const tcu::ConstPixelBufferAccess       srcSubRegion    = tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcExtent.x, srcExtent.y);
2007                 const tcu::PixelBufferAccess            dstSubRegion    = tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y);
2008                 blit(dstSubRegion, srcSubRegion, filter, mirrorMode);
2009
2010                 if (filter == tcu::Sampler::LINEAR)
2011                 {
2012                         const tcu::PixelBufferAccess    unclampedSubRegion      = tcu::getSubregion(m_unclampedExpectedTextureLevel->getAccess(), dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y);
2013                         scaleFromWholeSrcBuffer(unclampedSubRegion, src, srcOffset, srcExtent, filter);
2014                 }
2015         }
2016 }
2017
2018 void BlittingImages::generateExpectedResult (void)
2019 {
2020         const tcu::ConstPixelBufferAccess       src     = m_sourceTextureLevel->getAccess();
2021         const tcu::ConstPixelBufferAccess       dst     = m_destinationTextureLevel->getAccess();
2022
2023         m_expectedTextureLevel                  = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
2024         tcu::copy(m_expectedTextureLevel->getAccess(), dst);
2025
2026         if (m_params.filter == VK_FILTER_LINEAR)
2027         {
2028                 m_unclampedExpectedTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
2029                 tcu::copy(m_unclampedExpectedTextureLevel->getAccess(), dst);
2030         }
2031
2032         for (deUint32 i = 0; i < m_params.regions.size(); i++)
2033         {
2034                 CopyRegion region = m_params.regions[i];
2035                 copyRegionToTextureLevel(src, m_expectedTextureLevel->getAccess(), region);
2036         }
2037 }
2038
2039 class BlittingTestCase : public vkt::TestCase
2040 {
2041 public:
2042                                                         BlittingTestCase                (tcu::TestContext&                              testCtx,
2043                                                                                                          const std::string&                             name,
2044                                                                                                          const std::string&                             description,
2045                                                                                                          const TestParams                               params)
2046                                                                 : vkt::TestCase (testCtx, name, description)
2047                                                                 , m_params              (params)
2048                                                         {}
2049
2050         virtual TestInstance*   createInstance                  (Context&                                               context) const
2051                                                         {
2052                                                                 return new BlittingImages(context, m_params);
2053                                                         }
2054 private:
2055         TestParams                              m_params;
2056 };
2057
2058 // Resolve image to image.
2059
2060 enum ResolveImageToImageOptions{NO_OPTIONAL_OPERATION, COPY_MS_IMAGE_TO_MS_IMAGE, COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE};
2061 class ResolveImageToImage : public CopiesAndBlittingTestInstance
2062 {
2063 public:
2064                                                                                                 ResolveImageToImage                     (Context&                                                       context,
2065                                                                                                                                                          TestParams                                                     params,
2066                                                                                                                                                          const ResolveImageToImageOptions       options);
2067         virtual tcu::TestStatus                                         iterate                                         (void);
2068 protected:
2069         virtual tcu::TestStatus                                         checkTestResult                         (tcu::ConstPixelBufferAccess result);
2070         void                                                                            copyMSImageToMSImage            (void);
2071 private:
2072         Move<VkImage>                                                           m_multisampledImage;
2073         de::MovePtr<Allocation>                                         m_multisampledImageAlloc;
2074
2075         Move<VkImage>                                                           m_destination;
2076         de::MovePtr<Allocation>                                         m_destinationImageAlloc;
2077
2078         Move<VkImage>                                                           m_multisampledCopyImage;
2079         de::MovePtr<Allocation>                                         m_multisampledCopyImageAlloc;
2080
2081         const ResolveImageToImageOptions                        m_options;
2082
2083         virtual void                                                            copyRegionToTextureLevel        (tcu::ConstPixelBufferAccess    src,
2084                                                                                                                                                          tcu::PixelBufferAccess                 dst,
2085                                                                                                                                                          CopyRegion                                             region);
2086 };
2087
2088 ResolveImageToImage::ResolveImageToImage (Context& context, TestParams params, const ResolveImageToImageOptions options)
2089         : CopiesAndBlittingTestInstance (context, params)
2090         , m_options                                             (options)
2091 {
2092         const VkSampleCountFlagBits     rasterizationSamples    = m_params.samples;
2093
2094         if (!(context.getDeviceProperties().limits.framebufferColorSampleCounts & rasterizationSamples))
2095                 throw tcu::NotSupportedError("Unsupported number of rasterization samples");
2096
2097         const DeviceInterface&          vk                                              = context.getDeviceInterface();
2098         const VkDevice                          vkDevice                                = context.getDevice();
2099         const deUint32                          queueFamilyIndex                = context.getUniversalQueueFamilyIndex();
2100         Allocator&                                      memAlloc                                = m_context.getDefaultAllocator();
2101
2102         const VkComponentMapping        componentMappingRGBA    = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
2103         Move<VkRenderPass>                      renderPass;
2104
2105         Move<VkShaderModule>            vertexShaderModule              = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("vert"), 0);
2106         Move<VkShaderModule>            fragmentShaderModule    = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("frag"), 0);
2107         std::vector<tcu::Vec4>          vertices;
2108
2109         Move<VkBuffer>                          vertexBuffer;
2110         de::MovePtr<Allocation>         vertexBufferAlloc;
2111
2112         Move<VkPipelineLayout>          pipelineLayout;
2113         Move<VkPipeline>                        graphicsPipeline;
2114
2115         VkImageFormatProperties properties;
2116         if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
2117                                                                                                                                                                 m_params.src.image.format,
2118                                                                                                                                                                 m_params.src.image.imageType,
2119                                                                                                                                                                 VK_IMAGE_TILING_OPTIMAL,
2120                                                                                                                                                                 VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0,
2121                                                                                                                                                                 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
2122                 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
2123                                                                                                                                                                 m_params.dst.image.format,
2124                                                                                                                                                                 m_params.dst.image.imageType,
2125                                                                                                                                                                 VK_IMAGE_TILING_OPTIMAL,
2126                                                                                                                                                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT, 0,
2127                                                                                                                                                                 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
2128         {
2129                 TCU_THROW(NotSupportedError, "Format not supported");
2130         }
2131
2132         // Create color image.
2133         {
2134                 VkImageCreateInfo       colorImageParams        =
2135                 {
2136                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                                                    // VkStructureType                      sType;
2137                         DE_NULL,                                                                                                                                // const void*                          pNext;
2138                         0u,                                                                                                                                             // VkImageCreateFlags           flags;
2139                         m_params.src.image.imageType,                                                                                   // VkImageType                          imageType;
2140                         m_params.src.image.format,                                                                                              // VkFormat                                     format;
2141                         getExtent3D(m_params.src.image),                                                                                // VkExtent3D                           extent;
2142                         1u,                                                                                                                                             // deUint32                                     mipLevels;
2143                         getArraySize(m_params.src.image),                                                                               // deUint32                                     arrayLayers;
2144                         rasterizationSamples,                                                                                                   // VkSampleCountFlagBits        samples;
2145                         VK_IMAGE_TILING_OPTIMAL,                                                                                                // VkImageTiling                        tiling;
2146                         VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,  // VkImageUsageFlags            usage;
2147                         VK_SHARING_MODE_EXCLUSIVE,                                                                                              // VkSharingMode                        sharingMode;
2148                         1u,                                                                                                                                             // deUint32                                     queueFamilyIndexCount;
2149                         &queueFamilyIndex,                                                                                                              // const deUint32*                      pQueueFamilyIndices;
2150                         VK_IMAGE_LAYOUT_UNDEFINED,                                                                                              // VkImageLayout                        initialLayout;
2151                 };
2152
2153                 m_multisampledImage                                             = createImage(vk, vkDevice, &colorImageParams);
2154
2155                 // Allocate and bind color image memory.
2156                 m_multisampledImageAlloc                = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_multisampledImage), MemoryRequirement::Any);
2157                 VK_CHECK(vk.bindImageMemory(vkDevice, *m_multisampledImage, m_multisampledImageAlloc->getMemory(), m_multisampledImageAlloc->getOffset()));
2158
2159                 switch (m_options)
2160                 {
2161                         case COPY_MS_IMAGE_TO_MS_IMAGE:
2162                         {
2163                                 colorImageParams.usage                  = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2164                                 m_multisampledCopyImage                 = createImage(vk, vkDevice, &colorImageParams);
2165                                 // Allocate and bind color image memory.
2166                                 m_multisampledCopyImageAlloc    = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_multisampledCopyImage), MemoryRequirement::Any);
2167                                 VK_CHECK(vk.bindImageMemory(vkDevice, *m_multisampledCopyImage, m_multisampledCopyImageAlloc->getMemory(), m_multisampledCopyImageAlloc->getOffset()));
2168                                 break;
2169                         }
2170
2171                         case COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE:
2172                         {
2173                                 colorImageParams.usage                  = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2174                                 colorImageParams.arrayLayers    = getArraySize(m_params.dst.image);
2175                                 m_multisampledCopyImage                 = createImage(vk, vkDevice, &colorImageParams);
2176                                 // Allocate and bind color image memory.
2177                                 m_multisampledCopyImageAlloc    = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_multisampledCopyImage), MemoryRequirement::Any);
2178                                 VK_CHECK(vk.bindImageMemory(vkDevice, *m_multisampledCopyImage, m_multisampledCopyImageAlloc->getMemory(), m_multisampledCopyImageAlloc->getOffset()));
2179                                 break;
2180                         }
2181
2182                         default :
2183                                 break;
2184                 }
2185         }
2186
2187         // Create destination image.
2188         {
2189                 const VkImageCreateInfo destinationImageParams  =
2190                 {
2191                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType              sType;
2192                         DE_NULL,                                                                // const void*                  pNext;
2193                         0u,                                                                             // VkImageCreateFlags   flags;
2194                         m_params.dst.image.imageType,                   // VkImageType                  imageType;
2195                         m_params.dst.image.format,                              // VkFormat                             format;
2196                         getExtent3D(m_params.dst.image),                // VkExtent3D                   extent;
2197                         1u,                                                                             // deUint32                             mipLevels;
2198                         getArraySize(m_params.dst.image),               // deUint32                             arraySize;
2199                         VK_SAMPLE_COUNT_1_BIT,                                  // deUint32                             samples;
2200                         VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                tiling;
2201                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
2202                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT,        // VkImageUsageFlags    usage;
2203                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                sharingMode;
2204                         1u,                                                                             // deUint32                             queueFamilyCount;
2205                         &queueFamilyIndex,                                              // const deUint32*              pQueueFamilyIndices;
2206                         VK_IMAGE_LAYOUT_UNDEFINED,                              // VkImageLayout                initialLayout;
2207                 };
2208
2209                 m_destination                   = createImage(vk, vkDevice, &destinationImageParams);
2210                 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
2211                 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
2212         }
2213
2214         // Barriers for copying image to buffer
2215         VkImageMemoryBarrier            srcImageBarrier         =
2216         {
2217                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
2218                 DE_NULL,                                                                        // const void*                          pNext;
2219                 0u,                                                                                     // VkAccessFlags                        srcAccessMask;
2220                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,           // VkAccessFlags                        dstAccessMask;
2221                 VK_IMAGE_LAYOUT_UNDEFINED,                                      // VkImageLayout                        oldLayout;
2222                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // VkImageLayout                        newLayout;
2223                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
2224                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
2225                 m_multisampledImage.get(),                                      // VkImage                                      image;
2226                 {                                                                                       // VkImageSubresourceRange      subresourceRange;
2227                         VK_IMAGE_ASPECT_COLOR_BIT,                      // VkImageAspectFlags   aspectMask;
2228                         0u,                                                                     // deUint32                             baseMipLevel;
2229                         1u,                                                                     // deUint32                             mipLevels;
2230                         0u,                                                                     // deUint32                             baseArraySlice;
2231                         getArraySize(m_params.src.image)        // deUint32                             arraySize;
2232                 }
2233         };
2234
2235                 // Create render pass.
2236         {
2237                 const VkAttachmentDescription   attachmentDescriptions[1]       =
2238                 {
2239                         {
2240                                 0u,                                                                                     // VkAttachmentDescriptionFlags         flags;
2241                                 m_params.src.image.format,                                      // VkFormat                                                     format;
2242                                 rasterizationSamples,                                           // VkSampleCountFlagBits                        samples;
2243                                 VK_ATTACHMENT_LOAD_OP_CLEAR,                            // VkAttachmentLoadOp                           loadOp;
2244                                 VK_ATTACHMENT_STORE_OP_STORE,                           // VkAttachmentStoreOp                          storeOp;
2245                                 VK_ATTACHMENT_LOAD_OP_DONT_CARE,                        // VkAttachmentLoadOp                           stencilLoadOp;
2246                                 VK_ATTACHMENT_STORE_OP_DONT_CARE,                       // VkAttachmentStoreOp                          stencilStoreOp;
2247                                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // VkImageLayout                                        initialLayout;
2248                                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL        // VkImageLayout                                        finalLayout;
2249                         },
2250                 };
2251
2252                 const VkAttachmentReference             colorAttachmentReference        =
2253                 {
2254                         0u,                                                                                                     // deUint32                     attachment;
2255                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                        // VkImageLayout        layout;
2256                 };
2257
2258                 const VkSubpassDescription              subpassDescription                      =
2259                 {
2260                         0u,                                                                     // VkSubpassDescriptionFlags    flags;
2261                         VK_PIPELINE_BIND_POINT_GRAPHICS,        // VkPipelineBindPoint                  pipelineBindPoint;
2262                         0u,                                                                     // deUint32                                             inputAttachmentCount;
2263                         DE_NULL,                                                        // const VkAttachmentReference* pInputAttachments;
2264                         1u,                                                                     // deUint32                                             colorAttachmentCount;
2265                         &colorAttachmentReference,                      // const VkAttachmentReference* pColorAttachments;
2266                         DE_NULL,                                                        // const VkAttachmentReference* pResolveAttachments;
2267                         DE_NULL,                                                        // const VkAttachmentReference* pDepthStencilAttachment;
2268                         0u,                                                                     // deUint32                                             preserveAttachmentCount;
2269                         DE_NULL                                                         // const VkAttachmentReference* pPreserveAttachments;
2270                 };
2271
2272                 const VkRenderPassCreateInfo    renderPassParams                        =
2273                 {
2274                         VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,      // VkStructureType                                      sType;
2275                         DE_NULL,                                                                        // const void*                                          pNext;
2276                         0u,                                                                                     // VkRenderPassCreateFlags                      flags;
2277                         1u,                                                                                     // deUint32                                                     attachmentCount;
2278                         attachmentDescriptions,                                         // const VkAttachmentDescription*       pAttachments;
2279                         1u,                                                                                     // deUint32                                                     subpassCount;
2280                         &subpassDescription,                                            // const VkSubpassDescription*          pSubpasses;
2281                         0u,                                                                                     // deUint32                                                     dependencyCount;
2282                         DE_NULL                                                                         // const VkSubpassDependency*           pDependencies;
2283                 };
2284
2285                 renderPass      = createRenderPass(vk, vkDevice, &renderPassParams);
2286         }
2287
2288         // Create pipeline layout
2289         {
2290                 const VkPipelineLayoutCreateInfo        pipelineLayoutParams    =
2291                 {
2292                         VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,          // VkStructureType                                      sType;
2293                         DE_NULL,                                                                                        // const void*                                          pNext;
2294                         0u,                                                                                                     // VkPipelineLayoutCreateFlags          flags;
2295                         0u,                                                                                                     // deUint32                                                     setLayoutCount;
2296                         DE_NULL,                                                                                        // const VkDescriptorSetLayout*         pSetLayouts;
2297                         0u,                                                                                                     // deUint32                                                     pushConstantRangeCount;
2298                         DE_NULL                                                                                         // const VkPushConstantRange*           pPushConstantRanges;
2299                 };
2300
2301                 pipelineLayout  = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams);
2302         }
2303
2304         // Create upper half triangle.
2305         {
2306                 const tcu::Vec4 a       (-1.0, -1.0, 0.0, 1.0);
2307                 const tcu::Vec4 b       (1.0, -1.0, 0.0, 1.0);
2308                 const tcu::Vec4 c       (1.0, 1.0, 0.0, 1.0);
2309                 // Add triangle.
2310                 vertices.push_back(a);
2311                 vertices.push_back(c);
2312                 vertices.push_back(b);
2313         }
2314
2315         // Create vertex buffer.
2316         {
2317                 const VkDeviceSize                      vertexDataSize          = vertices.size() * sizeof(tcu::Vec4);
2318                 const VkBufferCreateInfo        vertexBufferParams      =
2319                 {
2320                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
2321                         DE_NULL,                                                                        // const void*                  pNext;
2322                         0u,                                                                                     // VkBufferCreateFlags  flags;
2323                         vertexDataSize,                                                         // VkDeviceSize                 size;
2324                         VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,                      // VkBufferUsageFlags   usage;
2325                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
2326                         1u,                                                                                     // deUint32                             queueFamilyIndexCount;
2327                         &queueFamilyIndex                                                       // const deUint32*              pQueueFamilyIndices;
2328                 };
2329
2330                 vertexBuffer            = createBuffer(vk, vkDevice, &vertexBufferParams);
2331                 vertexBufferAlloc       = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible);
2332
2333                 VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferAlloc->getMemory(), vertexBufferAlloc->getOffset()));
2334
2335                 // Load vertices into vertex buffer.
2336                 deMemcpy(vertexBufferAlloc->getHostPtr(), vertices.data(), (size_t)vertexDataSize);
2337                 flushMappedMemoryRange(vk, vkDevice, vertexBufferAlloc->getMemory(), vertexBufferAlloc->getOffset(), vertexDataSize);
2338         }
2339
2340         {
2341                 Move<VkFramebuffer>             framebuffer;
2342                 Move<VkImageView>               sourceAttachmentView;
2343                 //const VkExtent3D              extent3D = getExtent3D(m_params.src.image); TODO
2344
2345                 // Create color attachment view.
2346                 {
2347                         const VkImageViewCreateInfo     colorAttachmentViewParams       =
2348                         {
2349                                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,                               // VkStructureType                      sType;
2350                                 DE_NULL,                                                                                                // const void*                          pNext;
2351                                 0u,                                                                                                             // VkImageViewCreateFlags       flags;
2352                                 *m_multisampledImage,                                                                   // VkImage                                      image;
2353                                 VK_IMAGE_VIEW_TYPE_2D,                                                                  // VkImageViewType                      viewType;
2354                                 m_params.src.image.format,                                                              // VkFormat                                     format;
2355                                 componentMappingRGBA,                                                                   // VkComponentMapping           components;
2356                                 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }   // VkImageSubresourceRange      subresourceRange;
2357                         };
2358                         sourceAttachmentView    = createImageView(vk, vkDevice, &colorAttachmentViewParams);
2359                 }
2360
2361                 // Create framebuffer
2362                 {
2363                         const VkImageView                               attachments[1]          =
2364                         {
2365                                         *sourceAttachmentView,
2366                         };
2367
2368                         const VkFramebufferCreateInfo   framebufferParams       =
2369                         {
2370                                         VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,                      // VkStructureType                              sType;
2371                                         DE_NULL,                                                                                        // const void*                                  pNext;
2372                                         0u,                                                                                                     // VkFramebufferCreateFlags             flags;
2373                                         *renderPass,                                                                            // VkRenderPass                                 renderPass;
2374                                         1u,                                                                                                     // deUint32                                             attachmentCount;
2375                                         attachments,                                                                            // const VkImageView*                   pAttachments;
2376                                         m_params.src.image.extent.width,                                        // deUint32                                             width;
2377                                         m_params.src.image.extent.height,                                       // deUint32                                             height;
2378                                         1u                                                                                                      // deUint32                                             layers;
2379                         };
2380
2381                         framebuffer     = createFramebuffer(vk, vkDevice, &framebufferParams);
2382                 }
2383
2384                 // Create pipeline
2385                 {
2386                         const VkPipelineShaderStageCreateInfo                   shaderStageParams[2]                            =
2387                         {
2388                                 {
2389                                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,            // VkStructureType                                              sType;
2390                                         DE_NULL,                                                                                                        // const void*                                                  pNext;
2391                                         0u,                                                                                                                     // VkPipelineShaderStageCreateFlags             flags;
2392                                         VK_SHADER_STAGE_VERTEX_BIT,                                                                     // VkShaderStageFlagBits                                stage;
2393                                         *vertexShaderModule,                                                                            // VkShaderModule                                               module;
2394                                         "main",                                                                                                         // const char*                                                  pName;
2395                                         DE_NULL                                                                                                         // const VkSpecializationInfo*                  pSpecializationInfo;
2396                                 },
2397                                 {
2398                                         VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,            // VkStructureType                                              sType;
2399                                         DE_NULL,                                                                                                        // const void*                                                  pNext;
2400                                         0u,                                                                                                                     // VkPipelineShaderStageCreateFlags             flags;
2401                                         VK_SHADER_STAGE_FRAGMENT_BIT,                                                           // VkShaderStageFlagBits                                stage;
2402                                         *fragmentShaderModule,                                                                          // VkShaderModule                                               module;
2403                                         "main",                                                                                                         // const char*                                                  pName;
2404                                         DE_NULL                                                                                                         // const VkSpecializationInfo*                  pSpecializationInfo;
2405                                 }
2406                         };
2407
2408                         const VkVertexInputBindingDescription                   vertexInputBindingDescription           =
2409                         {
2410                                         0u,                                                                     // deUint32                             binding;
2411                                         sizeof(tcu::Vec4),                                      // deUint32                             stride;
2412                                         VK_VERTEX_INPUT_RATE_VERTEX                     // VkVertexInputRate    inputRate;
2413                         };
2414
2415                         const VkVertexInputAttributeDescription                 vertexInputAttributeDescriptions[1]     =
2416                         {
2417                                 {
2418                                         0u,                                                                     // deUint32     location;
2419                                         0u,                                                                     // deUint32     binding;
2420                                         VK_FORMAT_R32G32B32A32_SFLOAT,          // VkFormat     format;
2421                                         0u                                                                      // deUint32     offset;
2422                                 }
2423                         };
2424
2425                         const VkPipelineVertexInputStateCreateInfo              vertexInputStateParams                          =
2426                         {
2427                                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,      // VkStructureType                                                      sType;
2428                                 DE_NULL,                                                                                                        // const void*                                                          pNext;
2429                                 0u,                                                                                                                     // VkPipelineVertexInputStateCreateFlags        flags;
2430                                 1u,                                                                                                                     // deUint32                                                                     vertexBindingDescriptionCount;
2431                                 &vertexInputBindingDescription,                                                         // const VkVertexInputBindingDescription*       pVertexBindingDescriptions;
2432                                 1u,                                                                                                                     // deUint32                                                                     vertexAttributeDescriptionCount;
2433                                 vertexInputAttributeDescriptions                                                        // const VkVertexInputAttributeDescription*     pVertexAttributeDescriptions;
2434                         };
2435
2436                         const VkPipelineInputAssemblyStateCreateInfo    inputAssemblyStateParams                        =
2437                         {
2438                                 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,    // VkStructureType                                                      sType;
2439                                 DE_NULL,                                                                                                                // const void*                                                          pNext;
2440                                 0u,                                                                                                                             // VkPipelineInputAssemblyStateCreateFlags      flags;
2441                                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,                                                    // VkPrimitiveTopology                                          topology;
2442                                 false                                                                                                                   // VkBool32                                                                     primitiveRestartEnable;
2443                         };
2444
2445                         const VkViewport        viewport        =
2446                         {
2447                                 0.0f,                                                                   // float        x;
2448                                 0.0f,                                                                   // float        y;
2449                                 (float)m_params.src.image.extent.width, // float        width;
2450                                 (float)m_params.src.image.extent.height,// float        height;
2451                                 0.0f,                                                                   // float        minDepth;
2452                                 1.0f                                                                    // float        maxDepth;
2453                         };
2454
2455                         const VkRect2D          scissor         =
2456                         {
2457                                 { 0, 0 },                                                                                                                               // VkOffset2D   offset;
2458                                 { m_params.src.image.extent.width, m_params.src.image.extent.height }   // VkExtent2D   extent;
2459                         };
2460
2461                         const VkPipelineViewportStateCreateInfo                 viewportStateParams             =
2462                         {
2463                                 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,  // VkStructureType                                              sType;
2464                                 DE_NULL,                                                                                                // const void*                                                  pNext;
2465                                 0u,                                                                                                             // VkPipelineViewportStateCreateFlags   flags;
2466                                 1u,                                                                                                             // deUint32                                                             viewportCount;
2467                                 &viewport,                                                                                              // const VkViewport*                                    pViewports;
2468                                 1u,                                                                                                             // deUint32                                                             scissorCount;
2469                                 &scissor                                                                                                // const VkRect2D*                                              pScissors;
2470                         };
2471
2472                         const VkPipelineRasterizationStateCreateInfo    rasterStateParams               =
2473                         {
2474                                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,     // VkStructureType                                                      sType;
2475                                 DE_NULL,                                                                                                        // const void*                                                          pNext;
2476                                 0u,                                                                                                                     // VkPipelineRasterizationStateCreateFlags      flags;
2477                                 false,                                                                                                          // VkBool32                                                                     depthClampEnable;
2478                                 false,                                                                                                          // VkBool32                                                                     rasterizerDiscardEnable;
2479                                 VK_POLYGON_MODE_FILL,                                                                           // VkPolygonMode                                                        polygonMode;
2480                                 VK_CULL_MODE_NONE,                                                                                      // VkCullModeFlags                                                      cullMode;
2481                                 VK_FRONT_FACE_COUNTER_CLOCKWISE,                                                        // VkFrontFace                                                          frontFace;
2482                                 VK_FALSE,                                                                                                       // VkBool32                                                                     depthBiasEnable;
2483                                 0.0f,                                                                                                           // float                                                                        depthBiasConstantFactor;
2484                                 0.0f,                                                                                                           // float                                                                        depthBiasClamp;
2485                                 0.0f,                                                                                                           // float                                                                        depthBiasSlopeFactor;
2486                                 1.0f                                                                                                            // float                                                                        lineWidth;
2487                         };
2488
2489                         const VkPipelineMultisampleStateCreateInfo      multisampleStateParams          =
2490                         {
2491                                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,       // VkStructureType                                                      sType;
2492                                 DE_NULL,                                                                                                        // const void*                                                          pNext;
2493                                 0u,                                                                                                                     // VkPipelineMultisampleStateCreateFlags        flags;
2494                                 rasterizationSamples,                                                                           // VkSampleCountFlagBits                                        rasterizationSamples;
2495                                 VK_FALSE,                                                                                                       // VkBool32                                                                     sampleShadingEnable;
2496                                 0.0f,                                                                                                           // float                                                                        minSampleShading;
2497                                 DE_NULL,                                                                                                        // const VkSampleMask*                                          pSampleMask;
2498                                 VK_FALSE,                                                                                                       // VkBool32                                                                     alphaToCoverageEnable;
2499                                 VK_FALSE                                                                                                        // VkBool32                                                                     alphaToOneEnable;
2500                         };
2501
2502                         const VkPipelineColorBlendAttachmentState       colorBlendAttachmentState       =
2503                         {
2504                                 false,                                                  // VkBool32                     blendEnable;
2505                                 VK_BLEND_FACTOR_ONE,                    // VkBlend                      srcBlendColor;
2506                                 VK_BLEND_FACTOR_ZERO,                   // VkBlend                      destBlendColor;
2507                                 VK_BLEND_OP_ADD,                                // VkBlendOp            blendOpColor;
2508                                 VK_BLEND_FACTOR_ONE,                    // VkBlend                      srcBlendAlpha;
2509                                 VK_BLEND_FACTOR_ZERO,                   // VkBlend                      destBlendAlpha;
2510                                 VK_BLEND_OP_ADD,                                // VkBlendOp            blendOpAlpha;
2511                                 (VK_COLOR_COMPONENT_R_BIT |
2512                                 VK_COLOR_COMPONENT_G_BIT |
2513                                 VK_COLOR_COMPONENT_B_BIT |
2514                                 VK_COLOR_COMPONENT_A_BIT)               // VkChannelFlags       channelWriteMask;
2515                         };
2516
2517                         const VkPipelineColorBlendStateCreateInfo       colorBlendStateParams   =
2518                         {
2519                                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,       // VkStructureType                                                              sType;
2520                                 DE_NULL,                                                                                                        // const void*                                                                  pNext;
2521                                 0u,                                                                                                                     // VkPipelineColorBlendStateCreateFlags                 flags;
2522                                 false,                                                                                                          // VkBool32                                                                             logicOpEnable;
2523                                 VK_LOGIC_OP_COPY,                                                                                       // VkLogicOp                                                                    logicOp;
2524                                 1u,                                                                                                                     // deUint32                                                                             attachmentCount;
2525                                 &colorBlendAttachmentState,                                                                     // const VkPipelineColorBlendAttachmentState*   pAttachments;
2526                                 { 0.0f, 0.0f, 0.0f, 0.0f }                                                                      // float                                                                                blendConstants[4];
2527                         };
2528
2529                         const VkGraphicsPipelineCreateInfo                      graphicsPipelineParams  =
2530                         {
2531                                 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,        // VkStructureType                                                                      sType;
2532                                 DE_NULL,                                                                                        // const void*                                                                          pNext;
2533                                 0u,                                                                                                     // VkPipelineCreateFlags                                                        flags;
2534                                 2u,                                                                                                     // deUint32                                                                                     stageCount;
2535                                 shaderStageParams,                                                                      // const VkPipelineShaderStageCreateInfo*                       pStages;
2536                                 &vertexInputStateParams,                                                        // const VkPipelineVertexInputStateCreateInfo*          pVertexInputState;
2537                                 &inputAssemblyStateParams,                                                      // const VkPipelineInputAssemblyStateCreateInfo*        pInputAssemblyState;
2538                                 DE_NULL,                                                                                        // const VkPipelineTessellationStateCreateInfo*         pTessellationState;
2539                                 &viewportStateParams,                                                           // const VkPipelineViewportStateCreateInfo*                     pViewportState;
2540                                 &rasterStateParams,                                                                     // const VkPipelineRasterizationStateCreateInfo*        pRasterizationState;
2541                                 &multisampleStateParams,                                                        // const VkPipelineMultisampleStateCreateInfo*          pMultisampleState;
2542                                 DE_NULL,                                                                                        // const VkPipelineDepthStencilStateCreateInfo*         pDepthStencilState;
2543                                 &colorBlendStateParams,                                                         // const VkPipelineColorBlendStateCreateInfo*           pColorBlendState;
2544                                 DE_NULL,                                                                                        // const VkPipelineDynamicStateCreateInfo*                      pDynamicState;
2545                                 *pipelineLayout,                                                                        // VkPipelineLayout                                                                     layout;
2546                                 *renderPass,                                                                            // VkRenderPass                                                                         renderPass;
2547                                 0u,                                                                                                     // deUint32                                                                                     subpass;
2548                                 0u,                                                                                                     // VkPipeline                                                                           basePipelineHandle;
2549                                 0u                                                                                                      // deInt32                                                                                      basePipelineIndex;
2550                         };
2551
2552                         graphicsPipeline        = createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams);
2553                 }
2554
2555                 // Create command buffer
2556                 {
2557                         const VkCommandBufferBeginInfo cmdBufferBeginInfo =
2558                         {
2559                                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // VkStructureType                                      sType;
2560                                 DE_NULL,                                                                                // const void*                                          pNext;
2561                                 0u,                                                                                             // VkCommandBufferUsageFlags            flags;
2562                                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2563                         };
2564
2565                         const VkClearValue clearValues[1] =
2566                         {
2567                                 makeClearValueColorF32(0.0f, 0.0f, 1.0f, 1.0f),
2568                         };
2569
2570                         const VkRenderPassBeginInfo renderPassBeginInfo =
2571                         {
2572                                 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,                               // VkStructureType              sType;
2573                                 DE_NULL,                                                                                                // const void*                  pNext;
2574                                 *renderPass,                                                                                    // VkRenderPass                 renderPass;
2575                                 *framebuffer,                                                                                   // VkFramebuffer                framebuffer;
2576                                 {
2577                                         { 0, 0 },
2578                                         { m_params.src.image.extent.width, m_params.src.image.extent.height }
2579                                 },                                                                                                              // VkRect2D                             renderArea;
2580                                 1u,                                                                                                             // deUint32                             clearValueCount;
2581                                 clearValues                                                                                             // const VkClearValue*  pClearValues;
2582                         };
2583
2584                         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
2585                         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &srcImageBarrier);
2586                         vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
2587
2588                         const VkDeviceSize      vertexBufferOffset      = 0u;
2589
2590                         vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline);
2591                         vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer.get(), &vertexBufferOffset);
2592                         vk.cmdDraw(*m_cmdBuffer, (deUint32)vertices.size(), 1, 0, 0);
2593
2594                         vk.cmdEndRenderPass(*m_cmdBuffer);
2595                         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
2596                 }
2597
2598                 // Queue submit.
2599                 {
2600                         const VkQueue   queue   = m_context.getUniversalQueue();
2601                         submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
2602                 }
2603         }
2604 }
2605
2606 tcu::TestStatus ResolveImageToImage::iterate (void)
2607 {
2608         const tcu::TextureFormat                srcTcuFormat            = mapVkFormat(m_params.src.image.format);
2609         const tcu::TextureFormat                dstTcuFormat            = mapVkFormat(m_params.dst.image.format);
2610
2611         // upload the destination image
2612                 m_destinationTextureLevel       = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
2613                                                                                                                                                                 (int)m_params.dst.image.extent.width,
2614                                                                                                                                                                 (int)m_params.dst.image.extent.height,
2615                                                                                                                                                                 (int)m_params.dst.image.extent.depth));
2616                 generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth);
2617                 uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
2618
2619                 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
2620                                                                                                                                                 (int)m_params.src.image.extent.width,
2621                                                                                                                                                 (int)m_params.src.image.extent.height,
2622                                                                                                                                                 (int)m_params.dst.image.extent.depth));
2623
2624                 generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.dst.image.extent.depth, FILL_MODE_MULTISAMPLE);
2625                 generateExpectedResult();
2626
2627         switch (m_options)
2628         {
2629                 case COPY_MS_IMAGE_TO_MS_IMAGE:
2630                 case COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE:
2631                         copyMSImageToMSImage();
2632                         break;
2633                 default:
2634                         break;
2635         }
2636
2637         const DeviceInterface&                  vk                                      = m_context.getDeviceInterface();
2638         const VkDevice                                  vkDevice                        = m_context.getDevice();
2639         const VkQueue                                   queue                           = m_context.getUniversalQueue();
2640         SimpleAllocator                                 memAlloc                        (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
2641
2642         std::vector<VkImageResolve>             imageResolves;
2643         for (deUint32 i = 0; i < m_params.regions.size(); i++)
2644                 imageResolves.push_back(m_params.regions[i].imageResolve);
2645
2646         const VkImageMemoryBarrier      imageBarriers[]         =
2647         {
2648                 // source image
2649                 {
2650                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
2651                         DE_NULL,                                                                        // const void*                          pNext;
2652                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,           // VkAccessFlags                        srcAccessMask;
2653                         VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags                        dstAccessMask;
2654                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // VkImageLayout                        oldLayout;
2655                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // VkImageLayout                        newLayout;
2656                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
2657                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
2658                         m_multisampledImage.get(),                                      // VkImage                                      image;
2659                         {                                                                                       // VkImageSubresourceRange      subresourceRange;
2660                                 getAspectFlags(srcTcuFormat),           // VkImageAspectFlags   aspectMask;
2661                                 0u,                                                                     // deUint32                             baseMipLevel;
2662                                 1u,                                                                     // deUint32                             mipLevels;
2663                                 0u,                                                                     // deUint32                             baseArraySlice;
2664                                 getArraySize(m_params.dst.image)        // deUint32                             arraySize;
2665                         }
2666                 },
2667                 // destination image
2668                 {
2669                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
2670                         DE_NULL,                                                                        // const void*                          pNext;
2671                         0u,                                                                                     // VkAccessFlags                        srcAccessMask;
2672                         VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        dstAccessMask;
2673                         VK_IMAGE_LAYOUT_UNDEFINED,                                      // VkImageLayout                        oldLayout;
2674                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        newLayout;
2675                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
2676                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
2677                         m_destination.get(),                                            // VkImage                                      image;
2678                         {                                                                                       // VkImageSubresourceRange      subresourceRange;
2679                                 getAspectFlags(dstTcuFormat),           // VkImageAspectFlags   aspectMask;
2680                                 0u,                                                                     // deUint32                             baseMipLevel;
2681                                 1u,                                                                     // deUint32                             mipLevels;
2682                                 0u,                                                                     // deUint32                             baseArraySlice;
2683                                 getArraySize(m_params.dst.image)        // deUint32                             arraySize;
2684                         }
2685                 },
2686         };
2687
2688         const VkImageMemoryBarrier postImageBarrier =
2689         {
2690                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType                      sType;
2691                 DE_NULL,                                                                // const void*                          pNext;
2692                 VK_ACCESS_TRANSFER_WRITE_BIT,                   // VkAccessFlags                        srcAccessMask;
2693                 VK_ACCESS_TRANSFER_WRITE_BIT,                   // VkAccessFlags                        dstAccessMask;
2694                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,   // VkImageLayout                        oldLayout;
2695                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,   // VkImageLayout                        newLayout;
2696                 VK_QUEUE_FAMILY_IGNORED,                                // deUint32                                     srcQueueFamilyIndex;
2697                 VK_QUEUE_FAMILY_IGNORED,                                // deUint32                                     dstQueueFamilyIndex;
2698                 m_destination.get(),                                    // VkImage                                      image;
2699                 {                                                                               // VkImageSubresourceRange      subresourceRange;
2700                         getAspectFlags(dstTcuFormat),           // VkImageAspectFlags           aspectMask;
2701                         0u,                                                                     // deUint32                                     baseMipLevel;
2702                         1u,                                                                     // deUint32                                     mipLevels;
2703                         0u,                                                                     // deUint32                                     baseArraySlice;
2704                         getArraySize(m_params.dst.image)        // deUint32                                     arraySize;
2705                 }
2706         };
2707
2708         const VkCommandBufferBeginInfo  cmdBufferBeginInfo      =
2709         {
2710                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
2711                 DE_NULL,                                                                                                // const void*                                          pNext;
2712                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
2713                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2714         };
2715
2716         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
2717         vk.cmdPipelineBarrier(*m_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, DE_LENGTH_OF_ARRAY(imageBarriers), imageBarriers);
2718         vk.cmdResolveImage(*m_cmdBuffer, m_multisampledImage.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_destination.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)m_params.regions.size(), imageResolves.data());
2719         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier);
2720         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
2721         submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
2722
2723         de::MovePtr<tcu::TextureLevel>  resultTextureLevel      = readImage(vk, vkDevice, queue, memAlloc, *m_destination, m_params.dst.image);
2724
2725         return checkTestResult(resultTextureLevel->getAccess());
2726 }
2727
2728 tcu::TestStatus ResolveImageToImage::checkTestResult (tcu::ConstPixelBufferAccess result)
2729 {
2730         const tcu::ConstPixelBufferAccess       expected                = m_expectedTextureLevel->getAccess();
2731         const float                                                     fuzzyThreshold  = 0.01f;
2732
2733         for (int arrayLayerNdx = 0; arrayLayerNdx < (int)getArraySize(m_params.dst.image); ++arrayLayerNdx)
2734         {
2735                 const tcu::ConstPixelBufferAccess       expectedSub     = getSubregion (expected, 0, 0, arrayLayerNdx, expected.getWidth(), expected.getHeight(), 1u);
2736                 const tcu::ConstPixelBufferAccess       resultSub       = getSubregion (result, 0, 0, arrayLayerNdx, result.getWidth(), result.getHeight(), 1u);
2737                 if (!tcu::fuzzyCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expectedSub, resultSub, fuzzyThreshold, tcu::COMPARE_LOG_RESULT))
2738                         return tcu::TestStatus::fail("CopiesAndBlitting test");
2739         }
2740
2741         return tcu::TestStatus::pass("CopiesAndBlitting test");
2742 }
2743
2744 void ResolveImageToImage::copyRegionToTextureLevel(tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
2745 {
2746         VkOffset3D srcOffset    = region.imageResolve.srcOffset;
2747                         srcOffset.z             = region.imageResolve.srcSubresource.baseArrayLayer;
2748         VkOffset3D dstOffset    = region.imageResolve.dstOffset;
2749                         dstOffset.z             = region.imageResolve.dstSubresource.baseArrayLayer;
2750         VkExtent3D extent               = region.imageResolve.extent;
2751
2752         const tcu::ConstPixelBufferAccess       srcSubRegion            = getSubregion (src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth);
2753         // CopyImage acts like a memcpy. Replace the destination format with the srcformat to use a memcpy.
2754         const tcu::PixelBufferAccess            dstWithSrcFormat        (srcSubRegion.getFormat(), dst.getSize(), dst.getDataPtr());
2755         const tcu::PixelBufferAccess            dstSubRegion            = getSubregion (dstWithSrcFormat, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth);
2756
2757         tcu::copy(dstSubRegion, srcSubRegion);
2758 }
2759
2760 void ResolveImageToImage::copyMSImageToMSImage (void)
2761 {
2762         const DeviceInterface&                  vk                                      = m_context.getDeviceInterface();
2763         const VkDevice                                  vkDevice                        = m_context.getDevice();
2764         const VkQueue                                   queue                           = m_context.getUniversalQueue();
2765         const tcu::TextureFormat                srcTcuFormat            = mapVkFormat(m_params.src.image.format);
2766         std::vector<VkImageCopy>                imageCopies;
2767
2768         for (deUint32 layerNdx = 0; layerNdx < getArraySize(m_params.dst.image); ++layerNdx)
2769         {
2770                 const VkImageSubresourceLayers  sourceSubresourceLayers =
2771                 {
2772                         getAspectFlags(srcTcuFormat),   // VkImageAspectFlags   aspectMask;
2773                         0u,                                                             // uint32_t                             mipLevel;
2774                         0u,                                                             // uint32_t                             baseArrayLayer;
2775                         1u                                                              // uint32_t                             layerCount;
2776                 };
2777
2778                 const VkImageSubresourceLayers  destinationSubresourceLayers    =
2779                 {
2780                         getAspectFlags(srcTcuFormat),   // VkImageAspectFlags   aspectMask;//getAspectFlags(dstTcuFormat)
2781                         0u,                                                             // uint32_t                             mipLevel;
2782                         layerNdx,                                               // uint32_t                             baseArrayLayer;
2783                         1u                                                              // uint32_t                             layerCount;
2784                 };
2785
2786                 const VkImageCopy                               imageCopy       =
2787                 {
2788                         sourceSubresourceLayers,                        // VkImageSubresourceLayers     srcSubresource;
2789                         {0, 0, 0},                                                      // VkOffset3D                           srcOffset;
2790                         destinationSubresourceLayers,           // VkImageSubresourceLayers     dstSubresource;
2791                         {0, 0, 0},                                                      // VkOffset3D                           dstOffset;
2792                          getExtent3D(m_params.src.image),       // VkExtent3D                           extent;
2793                 };
2794                 imageCopies.push_back(imageCopy);
2795         }
2796
2797         const VkImageMemoryBarrier              imageBarriers[]         =
2798         {
2799                 //// source image
2800                 {
2801                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
2802                         DE_NULL,                                                                        // const void*                          pNext;
2803                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,           // VkAccessFlags                        srcAccessMask;
2804                         VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags                        dstAccessMask;
2805                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // VkImageLayout                        oldLayout;
2806                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // VkImageLayout                        newLayout;
2807                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
2808                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
2809                         m_multisampledImage.get(),                                      // VkImage                                      image;
2810                         {                                                                                       // VkImageSubresourceRange      subresourceRange;
2811                                 getAspectFlags(srcTcuFormat),           // VkImageAspectFlags   aspectMask;
2812                                 0u,                                                                     // deUint32                             baseMipLevel;
2813                                 1u,                                                                     // deUint32                             mipLevels;
2814                                 0u,                                                                     // deUint32                             baseArraySlice;
2815                                 getArraySize(m_params.src.image)        // deUint32                             arraySize;
2816                         }
2817                 },
2818                 // destination image
2819                 {
2820                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
2821                         DE_NULL,                                                                        // const void*                          pNext;
2822                         0,                                                                                      // VkAccessFlags                        srcAccessMask;
2823                         VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        dstAccessMask;
2824                         VK_IMAGE_LAYOUT_UNDEFINED,                                      // VkImageLayout                        oldLayout;
2825                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        newLayout;
2826                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
2827                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
2828                         m_multisampledCopyImage.get(),                          // VkImage                                      image;
2829                         {                                                                                       // VkImageSubresourceRange      subresourceRange;
2830                                 getAspectFlags(srcTcuFormat),           // VkImageAspectFlags   aspectMask;
2831                                 0u,                                                                     // deUint32                             baseMipLevel;
2832                                 1u,                                                                     // deUint32                             mipLevels;
2833                                 0u,                                                                     // deUint32                             baseArraySlice;
2834                                 getArraySize(m_params.dst.image)        // deUint32                             arraySize;
2835                         }
2836                 },
2837         };
2838
2839         const VkImageMemoryBarrier      postImageBarriers               =
2840         // source image
2841         {
2842                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
2843                 DE_NULL,                                                                        // const void*                          pNext;
2844                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
2845                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,           // VkAccessFlags                        dstAccessMask;
2846                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        oldLayout;
2847                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,       // VkImageLayout                        newLayout;
2848                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
2849                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
2850                 m_multisampledCopyImage.get(),                          // VkImage                                      image;
2851                 {                                                                                       // VkImageSubresourceRange      subresourceRange;
2852                         getAspectFlags(srcTcuFormat),           // VkImageAspectFlags   aspectMask;
2853                         0u,                                                                     // deUint32                             baseMipLevel;
2854                         1u,                                                                     // deUint32                             mipLevels;
2855                         0u,                                                                     // deUint32                             baseArraySlice;
2856                         getArraySize(m_params.dst.image)        // deUint32                             arraySize;
2857                 }
2858         };
2859
2860         const VkCommandBufferBeginInfo  cmdBufferBeginInfo      =
2861         {
2862                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
2863                 DE_NULL,                                                                                                // const void*                                          pNext;
2864                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
2865                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2866         };
2867
2868         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
2869         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, DE_LENGTH_OF_ARRAY(imageBarriers), imageBarriers);
2870         vk.cmdCopyImage(*m_cmdBuffer, m_multisampledImage.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_multisampledCopyImage.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)imageCopies.size(), imageCopies.data());
2871         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1u, &postImageBarriers);
2872         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
2873
2874         submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
2875
2876         m_multisampledImage = m_multisampledCopyImage;
2877 }
2878
2879 class ResolveImageToImageTestCase : public vkt::TestCase
2880 {
2881 public:
2882                                                         ResolveImageToImageTestCase     (tcu::TestContext&                                      testCtx,
2883                                                                                                                  const std::string&                                     name,
2884                                                                                                                  const std::string&                                     description,
2885                                                                                                                  const TestParams                                       params,
2886                                                                                                                  const ResolveImageToImageOptions       options = NO_OPTIONAL_OPERATION)
2887                                                                 : vkt::TestCase (testCtx, name, description)
2888                                                                 , m_params              (params)
2889                                                                 , m_options             (options)
2890                                                         {}
2891         virtual void                    initPrograms                            (SourceCollections&             programCollection) const;
2892
2893         virtual TestInstance*   createInstance                          (Context&                               context) const
2894                                                         {
2895                                                                 return new ResolveImageToImage(context, m_params, m_options);
2896                                                         }
2897 private:
2898         TestParams                                                      m_params;
2899         const ResolveImageToImageOptions        m_options;
2900 };
2901
2902 void ResolveImageToImageTestCase::initPrograms (SourceCollections& programCollection) const
2903 {
2904         programCollection.glslSources.add("vert") << glu::VertexSource(
2905                 "#version 310 es\n"
2906                 "layout (location = 0) in highp vec4 a_position;\n"
2907                 "void main()\n"
2908                 "{\n"
2909                 "       gl_Position = a_position;\n"
2910                 "}\n");
2911
2912
2913         programCollection.glslSources.add("frag") << glu::FragmentSource(
2914                 "#version 310 es\n"
2915                 "layout (location = 0) out highp vec4 o_color;\n"
2916                 "void main()\n"
2917                 "{\n"
2918                 "       o_color = vec4(0.0, 1.0, 0.0, 1.0);\n"
2919                 "}\n");
2920 }
2921
2922 std::string getSampleCountCaseName (VkSampleCountFlagBits sampleFlag)
2923 {
2924         return de::toLower(de::toString(getSampleCountFlagsStr(sampleFlag)).substr(16));
2925 }
2926
2927 std::string getFormatCaseName (VkFormat format)
2928 {
2929         return de::toLower(de::toString(getFormatStr(format)).substr(10));
2930 }
2931
2932 void addCopyImageTestsAllFormats (tcu::TestCaseGroup*   testCaseGroup,
2933                                                                   tcu::TestContext&             testCtx,
2934                                                                   TestParams&                   params)
2935 {
2936         const VkFormat  compatibleFormats8Bit[]                 =
2937         {
2938                 VK_FORMAT_R4G4_UNORM_PACK8,
2939                 VK_FORMAT_R8_UNORM,
2940                 VK_FORMAT_R8_SNORM,
2941                 VK_FORMAT_R8_USCALED,
2942                 VK_FORMAT_R8_SSCALED,
2943                 VK_FORMAT_R8_UINT,
2944                 VK_FORMAT_R8_SINT,
2945                 VK_FORMAT_R8_SRGB,
2946
2947                 VK_FORMAT_UNDEFINED
2948         };
2949         const VkFormat  compatibleFormats16Bit[]                =
2950         {
2951                 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
2952                 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
2953                 VK_FORMAT_R5G6B5_UNORM_PACK16,
2954                 VK_FORMAT_B5G6R5_UNORM_PACK16,
2955                 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
2956                 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
2957                 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
2958                 VK_FORMAT_R8G8_UNORM,
2959                 VK_FORMAT_R8G8_SNORM,
2960                 VK_FORMAT_R8G8_USCALED,
2961                 VK_FORMAT_R8G8_SSCALED,
2962                 VK_FORMAT_R8G8_UINT,
2963                 VK_FORMAT_R8G8_SINT,
2964                 VK_FORMAT_R8G8_SRGB,
2965                 VK_FORMAT_R16_UNORM,
2966                 VK_FORMAT_R16_SNORM,
2967                 VK_FORMAT_R16_USCALED,
2968                 VK_FORMAT_R16_SSCALED,
2969                 VK_FORMAT_R16_UINT,
2970                 VK_FORMAT_R16_SINT,
2971                 VK_FORMAT_R16_SFLOAT,
2972
2973                 VK_FORMAT_UNDEFINED
2974          };
2975         const VkFormat  compatibleFormats24Bit[]                =
2976         {
2977                 VK_FORMAT_R8G8B8_UNORM,
2978                 VK_FORMAT_R8G8B8_SNORM,
2979                 VK_FORMAT_R8G8B8_USCALED,
2980                 VK_FORMAT_R8G8B8_SSCALED,
2981                 VK_FORMAT_R8G8B8_UINT,
2982                 VK_FORMAT_R8G8B8_SINT,
2983                 VK_FORMAT_R8G8B8_SRGB,
2984                 VK_FORMAT_B8G8R8_UNORM,
2985                 VK_FORMAT_B8G8R8_SNORM,
2986                 VK_FORMAT_B8G8R8_USCALED,
2987                 VK_FORMAT_B8G8R8_SSCALED,
2988                 VK_FORMAT_B8G8R8_UINT,
2989                 VK_FORMAT_B8G8R8_SINT,
2990                 VK_FORMAT_B8G8R8_SRGB,
2991
2992                 VK_FORMAT_UNDEFINED
2993          };
2994         const VkFormat  compatibleFormats32Bit[]                =
2995         {
2996                 VK_FORMAT_R8G8B8A8_UNORM,
2997                 VK_FORMAT_R8G8B8A8_SNORM,
2998                 VK_FORMAT_R8G8B8A8_USCALED,
2999                 VK_FORMAT_R8G8B8A8_SSCALED,
3000                 VK_FORMAT_R8G8B8A8_UINT,
3001                 VK_FORMAT_R8G8B8A8_SINT,
3002                 VK_FORMAT_R8G8B8A8_SRGB,
3003                 VK_FORMAT_B8G8R8A8_UNORM,
3004                 VK_FORMAT_B8G8R8A8_SNORM,
3005                 VK_FORMAT_B8G8R8A8_USCALED,
3006                 VK_FORMAT_B8G8R8A8_SSCALED,
3007                 VK_FORMAT_B8G8R8A8_UINT,
3008                 VK_FORMAT_B8G8R8A8_SINT,
3009                 VK_FORMAT_B8G8R8A8_SRGB,
3010                 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3011                 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3012                 VK_FORMAT_A8B8G8R8_USCALED_PACK32,
3013                 VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
3014                 VK_FORMAT_A8B8G8R8_UINT_PACK32,
3015                 VK_FORMAT_A8B8G8R8_SINT_PACK32,
3016                 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
3017                 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
3018                 VK_FORMAT_A2R10G10B10_SNORM_PACK32,
3019                 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
3020                 VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
3021                 VK_FORMAT_A2R10G10B10_UINT_PACK32,
3022                 VK_FORMAT_A2R10G10B10_SINT_PACK32,
3023                 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
3024                 VK_FORMAT_A2B10G10R10_SNORM_PACK32,
3025                 VK_FORMAT_A2B10G10R10_USCALED_PACK32,
3026                 VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
3027                 VK_FORMAT_A2B10G10R10_UINT_PACK32,
3028                 VK_FORMAT_A2B10G10R10_SINT_PACK32,
3029                 VK_FORMAT_R16G16_UNORM,
3030                 VK_FORMAT_R16G16_SNORM,
3031                 VK_FORMAT_R16G16_USCALED,
3032                 VK_FORMAT_R16G16_SSCALED,
3033                 VK_FORMAT_R16G16_UINT,
3034                 VK_FORMAT_R16G16_SINT,
3035                 VK_FORMAT_R16G16_SFLOAT,
3036                 VK_FORMAT_R32_UINT,
3037                 VK_FORMAT_R32_SINT,
3038                 VK_FORMAT_R32_SFLOAT,
3039
3040                 VK_FORMAT_UNDEFINED
3041          };
3042         const VkFormat  compatibleFormats48Bit[]                =
3043         {
3044                 VK_FORMAT_R16G16B16_UNORM,
3045                 VK_FORMAT_R16G16B16_SNORM,
3046                 VK_FORMAT_R16G16B16_USCALED,
3047                 VK_FORMAT_R16G16B16_SSCALED,
3048                 VK_FORMAT_R16G16B16_UINT,
3049                 VK_FORMAT_R16G16B16_SINT,
3050                 VK_FORMAT_R16G16B16_SFLOAT,
3051
3052                 VK_FORMAT_UNDEFINED
3053          };
3054         const VkFormat  compatibleFormats64Bit[]                =
3055         {
3056                 VK_FORMAT_R16G16B16A16_UNORM,
3057                 VK_FORMAT_R16G16B16A16_SNORM,
3058                 VK_FORMAT_R16G16B16A16_USCALED,
3059                 VK_FORMAT_R16G16B16A16_SSCALED,
3060                 VK_FORMAT_R16G16B16A16_UINT,
3061                 VK_FORMAT_R16G16B16A16_SINT,
3062                 VK_FORMAT_R16G16B16A16_SFLOAT,
3063                 VK_FORMAT_R32G32_UINT,
3064                 VK_FORMAT_R32G32_SINT,
3065                 VK_FORMAT_R32G32_SFLOAT,
3066                 VK_FORMAT_R64_UINT,
3067                 VK_FORMAT_R64_SINT,
3068                 VK_FORMAT_R64_SFLOAT,
3069
3070                 VK_FORMAT_UNDEFINED
3071          };
3072         const VkFormat  compatibleFormats96Bit[]                =
3073         {
3074                 VK_FORMAT_R32G32B32_UINT,
3075                 VK_FORMAT_R32G32B32_SINT,
3076                 VK_FORMAT_R32G32B32_SFLOAT,
3077
3078                 VK_FORMAT_UNDEFINED
3079          };
3080         const VkFormat  compatibleFormats128Bit[]               =
3081         {
3082                 VK_FORMAT_R32G32B32A32_UINT,
3083                 VK_FORMAT_R32G32B32A32_SINT,
3084                 VK_FORMAT_R32G32B32A32_SFLOAT,
3085                 VK_FORMAT_R64G64_UINT,
3086                 VK_FORMAT_R64G64_SINT,
3087                 VK_FORMAT_R64G64_SFLOAT,
3088
3089                 VK_FORMAT_UNDEFINED
3090          };
3091         const VkFormat  compatibleFormats192Bit[]               =
3092         {
3093                 VK_FORMAT_R64G64B64_UINT,
3094                 VK_FORMAT_R64G64B64_SINT,
3095                 VK_FORMAT_R64G64B64_SFLOAT,
3096
3097                 VK_FORMAT_UNDEFINED
3098          };
3099         const VkFormat  compatibleFormats256Bit[]               =
3100         {
3101                 VK_FORMAT_R64G64B64A64_UINT,
3102                 VK_FORMAT_R64G64B64A64_SINT,
3103                 VK_FORMAT_R64G64B64A64_SFLOAT,
3104
3105                 VK_FORMAT_UNDEFINED
3106         };
3107
3108         const VkFormat* colorImageFormatsToTest[]               =
3109         {
3110                 compatibleFormats8Bit,
3111                 compatibleFormats16Bit,
3112                 compatibleFormats24Bit,
3113                 compatibleFormats32Bit,
3114                 compatibleFormats48Bit,
3115                 compatibleFormats64Bit,
3116                 compatibleFormats96Bit,
3117                 compatibleFormats128Bit,
3118                 compatibleFormats192Bit,
3119                 compatibleFormats256Bit,
3120         };
3121         const size_t    numOfColorImageFormatsToTest    = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
3122
3123         for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < numOfColorImageFormatsToTest; ++compatibleFormatsIndex)
3124         {
3125                 const VkFormat* compatibleFormats       = colorImageFormatsToTest[compatibleFormatsIndex];
3126                 for (size_t srcFormatIndex = 0; compatibleFormats[srcFormatIndex] != VK_FORMAT_UNDEFINED; ++srcFormatIndex)
3127                 {
3128                         params.src.image.format = compatibleFormats[srcFormatIndex];
3129                         for (size_t dstFormatIndex = 0; compatibleFormats[dstFormatIndex] != VK_FORMAT_UNDEFINED; ++dstFormatIndex)
3130                         {
3131                                 params.dst.image.format = compatibleFormats[dstFormatIndex];
3132                                 std::ostringstream      testName;
3133                                 testName << getFormatCaseName(params.src.image.format) << "_" << getFormatCaseName(params.dst.image.format);
3134                                 std::ostringstream      description;
3135                                 description << "Copy from src " << params.src.image.format << " to dst " << params.dst.image.format;
3136
3137                                 testCaseGroup->addChild(new CopyImageToImageTestCase(testCtx, testName.str(), description.str(), params));
3138                         }
3139                 }
3140         }
3141 }
3142
3143 void addBlittingTestsAllFormats (tcu::TestCaseGroup*    testCaseGroup,
3144                                                                  tcu::TestContext&              testCtx,
3145                                                                  TestParams&                    params)
3146 {
3147         // Test Image formats.
3148         const VkFormat  compatibleFormatsUInts[]                        =
3149         {
3150                 VK_FORMAT_R8_UINT,
3151                 VK_FORMAT_R8G8_UINT,
3152                 VK_FORMAT_R8G8B8_UINT,
3153                 VK_FORMAT_B8G8R8_UINT,
3154                 VK_FORMAT_R8G8B8A8_UINT,
3155                 VK_FORMAT_B8G8R8A8_UINT,
3156                 VK_FORMAT_A8B8G8R8_UINT_PACK32,
3157                 VK_FORMAT_A2R10G10B10_UINT_PACK32,
3158                 VK_FORMAT_A2B10G10R10_UINT_PACK32,
3159                 VK_FORMAT_R16_UINT,
3160                 VK_FORMAT_R16G16_UINT,
3161                 VK_FORMAT_R16G16B16_UINT,
3162                 VK_FORMAT_R16G16B16A16_UINT,
3163                 VK_FORMAT_R32_UINT,
3164                 VK_FORMAT_R32G32_UINT,
3165                 VK_FORMAT_R32G32B32_UINT,
3166                 VK_FORMAT_R32G32B32A32_UINT,
3167                 VK_FORMAT_R64_UINT,
3168                 VK_FORMAT_R64G64_UINT,
3169                 VK_FORMAT_R64G64B64_UINT,
3170                 VK_FORMAT_R64G64B64A64_UINT,
3171
3172                 VK_FORMAT_UNDEFINED
3173         };
3174         const VkFormat  compatibleFormatsSInts[]                        =
3175         {
3176                 VK_FORMAT_R8_SINT,
3177                 VK_FORMAT_R8G8_SINT,
3178                 VK_FORMAT_R8G8B8_SINT,
3179                 VK_FORMAT_B8G8R8_SINT,
3180                 VK_FORMAT_R8G8B8A8_SINT,
3181                 VK_FORMAT_B8G8R8A8_SINT,
3182                 VK_FORMAT_A8B8G8R8_SINT_PACK32,
3183                 VK_FORMAT_A2R10G10B10_SINT_PACK32,
3184                 VK_FORMAT_A2B10G10R10_SINT_PACK32,
3185                 VK_FORMAT_R16_SINT,
3186                 VK_FORMAT_R16G16_SINT,
3187                 VK_FORMAT_R16G16B16_SINT,
3188                 VK_FORMAT_R16G16B16A16_SINT,
3189                 VK_FORMAT_R32_SINT,
3190                 VK_FORMAT_R32G32_SINT,
3191                 VK_FORMAT_R32G32B32_SINT,
3192                 VK_FORMAT_R32G32B32A32_SINT,
3193                 VK_FORMAT_R64_SINT,
3194                 VK_FORMAT_R64G64_SINT,
3195                 VK_FORMAT_R64G64B64_SINT,
3196                 VK_FORMAT_R64G64B64A64_SINT,
3197
3198                 VK_FORMAT_UNDEFINED
3199         };
3200         const VkFormat  compatibleFormatsFloats[]                       =
3201         {
3202                 VK_FORMAT_R4G4_UNORM_PACK8,
3203                 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
3204                 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
3205                 VK_FORMAT_R5G6B5_UNORM_PACK16,
3206                 VK_FORMAT_B5G6R5_UNORM_PACK16,
3207                 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
3208                 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
3209                 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
3210                 VK_FORMAT_R8_UNORM,
3211                 VK_FORMAT_R8_SNORM,
3212                 VK_FORMAT_R8_USCALED,
3213                 VK_FORMAT_R8_SSCALED,
3214                 VK_FORMAT_R8G8_UNORM,
3215                 VK_FORMAT_R8G8_SNORM,
3216                 VK_FORMAT_R8G8_USCALED,
3217                 VK_FORMAT_R8G8_SSCALED,
3218                 VK_FORMAT_R8G8B8_UNORM,
3219                 VK_FORMAT_R8G8B8_SNORM,
3220                 VK_FORMAT_R8G8B8_USCALED,
3221                 VK_FORMAT_R8G8B8_SSCALED,
3222                 VK_FORMAT_B8G8R8_UNORM,
3223                 VK_FORMAT_B8G8R8_SNORM,
3224                 VK_FORMAT_B8G8R8_USCALED,
3225                 VK_FORMAT_B8G8R8_SSCALED,
3226                 VK_FORMAT_R8G8B8A8_UNORM,
3227                 VK_FORMAT_R8G8B8A8_SNORM,
3228                 VK_FORMAT_R8G8B8A8_USCALED,
3229                 VK_FORMAT_R8G8B8A8_SSCALED,
3230                 VK_FORMAT_B8G8R8A8_UNORM,
3231                 VK_FORMAT_B8G8R8A8_SNORM,
3232                 VK_FORMAT_B8G8R8A8_USCALED,
3233                 VK_FORMAT_B8G8R8A8_SSCALED,
3234                 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3235                 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3236                 VK_FORMAT_A8B8G8R8_USCALED_PACK32,
3237                 VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
3238                 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
3239                 VK_FORMAT_A2R10G10B10_SNORM_PACK32,
3240                 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
3241                 VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
3242                 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
3243                 VK_FORMAT_A2B10G10R10_SNORM_PACK32,
3244                 VK_FORMAT_A2B10G10R10_USCALED_PACK32,
3245                 VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
3246                 VK_FORMAT_R16_UNORM,
3247                 VK_FORMAT_R16_SNORM,
3248                 VK_FORMAT_R16_USCALED,
3249                 VK_FORMAT_R16_SSCALED,
3250                 VK_FORMAT_R16_SFLOAT,
3251                 VK_FORMAT_R16G16_UNORM,
3252                 VK_FORMAT_R16G16_SNORM,
3253                 VK_FORMAT_R16G16_USCALED,
3254                 VK_FORMAT_R16G16_SSCALED,
3255                 VK_FORMAT_R16G16_SFLOAT,
3256                 VK_FORMAT_R16G16B16_UNORM,
3257                 VK_FORMAT_R16G16B16_SNORM,
3258                 VK_FORMAT_R16G16B16_USCALED,
3259                 VK_FORMAT_R16G16B16_SSCALED,
3260                 VK_FORMAT_R16G16B16_SFLOAT,
3261                 VK_FORMAT_R16G16B16A16_UNORM,
3262                 VK_FORMAT_R16G16B16A16_SNORM,
3263                 VK_FORMAT_R16G16B16A16_USCALED,
3264                 VK_FORMAT_R16G16B16A16_SSCALED,
3265                 VK_FORMAT_R16G16B16A16_SFLOAT,
3266                 VK_FORMAT_R32_SFLOAT,
3267                 VK_FORMAT_R32G32_SFLOAT,
3268                 VK_FORMAT_R32G32B32_SFLOAT,
3269                 VK_FORMAT_R32G32B32A32_SFLOAT,
3270                 VK_FORMAT_R64_SFLOAT,
3271                 VK_FORMAT_R64G64_SFLOAT,
3272                 VK_FORMAT_R64G64B64_SFLOAT,
3273                 VK_FORMAT_R64G64B64A64_SFLOAT,
3274 //              VK_FORMAT_B10G11R11_UFLOAT_PACK32,
3275 //              VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
3276 //              VK_FORMAT_BC1_RGB_UNORM_BLOCK,
3277 //              VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
3278 //              VK_FORMAT_BC2_UNORM_BLOCK,
3279 //              VK_FORMAT_BC3_UNORM_BLOCK,
3280 //              VK_FORMAT_BC4_UNORM_BLOCK,
3281 //              VK_FORMAT_BC4_SNORM_BLOCK,
3282 //              VK_FORMAT_BC5_UNORM_BLOCK,
3283 //              VK_FORMAT_BC5_SNORM_BLOCK,
3284 //              VK_FORMAT_BC6H_UFLOAT_BLOCK,
3285 //              VK_FORMAT_BC6H_SFLOAT_BLOCK,
3286 //              VK_FORMAT_BC7_UNORM_BLOCK,
3287 //              VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
3288 //              VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
3289 //              VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
3290 //              VK_FORMAT_EAC_R11_UNORM_BLOCK,
3291 //              VK_FORMAT_EAC_R11_SNORM_BLOCK,
3292 //              VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
3293 //              VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
3294 //              VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
3295 //              VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
3296 //              VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
3297 //              VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
3298 //              VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
3299 //              VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
3300 //              VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
3301 //              VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
3302 //              VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
3303 //              VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
3304 //              VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
3305 //              VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
3306 //              VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
3307 //              VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
3308
3309                 VK_FORMAT_UNDEFINED
3310         };
3311         const VkFormat  compatibleFormatsSrgb[]                         =
3312         {
3313                 VK_FORMAT_R8_SRGB,
3314                 VK_FORMAT_R8G8_SRGB,
3315                 VK_FORMAT_R8G8B8_SRGB,
3316                 VK_FORMAT_B8G8R8_SRGB,
3317                 VK_FORMAT_R8G8B8A8_SRGB,
3318                 VK_FORMAT_B8G8R8A8_SRGB,
3319                 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
3320 //              VK_FORMAT_BC1_RGB_SRGB_BLOCK,
3321 //              VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
3322 //              VK_FORMAT_BC2_SRGB_BLOCK,
3323 //              VK_FORMAT_BC3_SRGB_BLOCK,
3324 //              VK_FORMAT_BC7_SRGB_BLOCK,
3325 //              VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
3326 //              VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
3327 //              VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
3328 //              VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
3329 //              VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
3330 //              VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
3331 //              VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
3332 //              VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
3333 //              VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
3334 //              VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
3335 //              VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
3336 //              VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
3337 //              VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
3338 //              VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
3339 //              VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
3340 //              VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
3341 //              VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
3342
3343                 VK_FORMAT_UNDEFINED
3344         };
3345
3346         const struct {
3347                 const VkFormat* compatibleFormats;
3348                 const bool              onlyNearest;
3349         }       colorImageFormatsToTest[]                       =
3350         {
3351                 { compatibleFormatsUInts,       true    },
3352                 { compatibleFormatsSInts,       true    },
3353                 { compatibleFormatsFloats,      false   },
3354                 { compatibleFormatsSrgb,        false   },
3355         };
3356         const size_t    numOfColorImageFormatsToTest            = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
3357
3358         for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < numOfColorImageFormatsToTest; ++compatibleFormatsIndex)
3359         {
3360                 const VkFormat* compatibleFormats       = colorImageFormatsToTest[compatibleFormatsIndex].compatibleFormats;
3361                 const bool              onlyNearest                     = colorImageFormatsToTest[compatibleFormatsIndex].onlyNearest;
3362                 for (size_t srcFormatIndex = 0; compatibleFormats[srcFormatIndex] != VK_FORMAT_UNDEFINED; ++srcFormatIndex)
3363                 {
3364                         params.src.image.format = compatibleFormats[srcFormatIndex];
3365                         for (size_t dstFormatIndex = 0; compatibleFormats[dstFormatIndex] != VK_FORMAT_UNDEFINED; ++dstFormatIndex)
3366                         {
3367                                 params.dst.image.format = compatibleFormats[dstFormatIndex];
3368                                 std::ostringstream      testName;
3369                                 testName << getFormatCaseName(params.src.image.format) << "_" << getFormatCaseName(params.dst.image.format);
3370                                 std::ostringstream      description;
3371                                 description << "Blit image from src " << params.src.image.format << " to dst " << params.dst.image.format;
3372
3373                                 params.filter                   = VK_FILTER_NEAREST;
3374                                 testCaseGroup->addChild(new BlittingTestCase(testCtx, testName.str() + "_nearest", description.str(), params));
3375
3376                                 if (!onlyNearest)
3377                                 {
3378                                         params.filter           = VK_FILTER_LINEAR;
3379                                         testCaseGroup->addChild(new BlittingTestCase(testCtx, testName.str() + "_linear", description.str(), params));
3380                                 }
3381                         }
3382                 }
3383         }
3384 }
3385
3386 } // anonymous
3387
3388 tcu::TestCaseGroup* createCopiesAndBlittingTests (tcu::TestContext& testCtx)
3389 {
3390         de::MovePtr<tcu::TestCaseGroup> copiesAndBlittingTests  (new tcu::TestCaseGroup(testCtx, "copy_and_blit", "Copies And Blitting Tests"));
3391
3392         de::MovePtr<tcu::TestCaseGroup> imageToImageTests               (new tcu::TestCaseGroup(testCtx, "image_to_image", "Copy from image to image"));
3393         de::MovePtr<tcu::TestCaseGroup> imgToImgSimpleTests             (new tcu::TestCaseGroup(testCtx, "simple_tests", "Copy from image to image simple tests"));
3394         de::MovePtr<tcu::TestCaseGroup> imgToImgAllFormatsTests (new tcu::TestCaseGroup(testCtx, "all_formats", "Copy from image to image with all compatible formats"));
3395         de::MovePtr<tcu::TestCaseGroup> imgToImg3dImagesTests   (new tcu::TestCaseGroup(testCtx, "3d_images", "Coping operations on 3d images"));
3396
3397         de::MovePtr<tcu::TestCaseGroup> imageToBufferTests              (new tcu::TestCaseGroup(testCtx, "image_to_buffer", "Copy from image to buffer"));
3398         de::MovePtr<tcu::TestCaseGroup> bufferToImageTests              (new tcu::TestCaseGroup(testCtx, "buffer_to_image", "Copy from buffer to image"));
3399         de::MovePtr<tcu::TestCaseGroup> bufferToBufferTests             (new tcu::TestCaseGroup(testCtx, "buffer_to_buffer", "Copy from buffer to buffer"));
3400
3401         de::MovePtr<tcu::TestCaseGroup> blittingImageTests              (new tcu::TestCaseGroup(testCtx, "blit_image", "Blitting image"));
3402         de::MovePtr<tcu::TestCaseGroup> blitImgSimpleTests              (new tcu::TestCaseGroup(testCtx, "simple_tests", "Blitting image simple tests"));
3403         de::MovePtr<tcu::TestCaseGroup> blitImgAllFormatsTests  (new tcu::TestCaseGroup(testCtx, "all_formats", "Blitting image with all compatible formats"));
3404
3405         de::MovePtr<tcu::TestCaseGroup> resolveImageTests               (new tcu::TestCaseGroup(testCtx, "resolve_image", "Resolve image"));
3406
3407         const deInt32                                   defaultSize                             = 64;
3408         const deInt32                                   defaultHalfSize                 = defaultSize / 2;
3409         const deInt32                                   defaultFourthSize               = defaultSize / 4;
3410         const VkExtent3D                                defaultExtent                   = {defaultSize, defaultSize, 1};
3411         const VkExtent3D                                defaultHalfExtent               = {defaultHalfSize, defaultHalfSize, 1};
3412
3413         const VkImageSubresourceLayers  defaultSourceLayer              =
3414         {
3415                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
3416                 0u,                                                     // uint32_t                             mipLevel;
3417                 0u,                                                     // uint32_t                             baseArrayLayer;
3418                 1u,                                                     // uint32_t                             layerCount;
3419         };
3420
3421         // Copy image to image testcases.
3422         {
3423                 TestParams                      params;
3424                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
3425                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UINT;
3426                 params.src.image.extent         = defaultExtent;
3427                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
3428                 params.dst.image.format         = VK_FORMAT_R8G8B8A8_UINT;
3429                 params.dst.image.extent         = defaultExtent;
3430
3431                 {
3432                         const VkImageCopy                               testCopy        =
3433                         {
3434                                 defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
3435                                 {0, 0, 0},                      // VkOffset3D                           srcOffset;
3436                                 defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
3437                                 {0, 0, 0},                      // VkOffset3D                           dstOffset;
3438                                 defaultExtent,          // VkExtent3D                           extent;
3439                         };
3440
3441                         CopyRegion      imageCopy;
3442                         imageCopy.imageCopy     = testCopy;
3443
3444                         params.regions.push_back(imageCopy);
3445                 }
3446
3447                 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "whole_image", "Whole image", params));
3448         }
3449
3450         {
3451                 TestParams                      params;
3452                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
3453                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UINT;
3454                 params.src.image.extent         = defaultExtent;
3455                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
3456                 params.dst.image.format         = VK_FORMAT_R32_UINT;
3457                 params.dst.image.extent         = defaultExtent;
3458
3459                 {
3460                         const VkImageCopy                               testCopy        =
3461                         {
3462                                 defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
3463                                 {0, 0, 0},                      // VkOffset3D                           srcOffset;
3464                                 defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
3465                                 {0, 0, 0},                      // VkOffset3D                           dstOffset;
3466                                 defaultExtent,          // VkExtent3D                           extent;
3467                         };
3468
3469                         CopyRegion      imageCopy;
3470                         imageCopy.imageCopy     = testCopy;
3471
3472                         params.regions.push_back(imageCopy);
3473                 }
3474
3475                 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "whole_image_diff_fromat", "Whole image with different format", params));
3476         }
3477
3478         {
3479                 TestParams                      params;
3480                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
3481                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UINT;
3482                 params.src.image.extent         = defaultExtent;
3483                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
3484                 params.dst.image.format         = VK_FORMAT_R8G8B8A8_UINT;
3485                 params.dst.image.extent         = defaultExtent;
3486
3487                 {
3488                         const VkImageCopy                               testCopy        =
3489                         {
3490                                 defaultSourceLayer,                                                                     // VkImageSubresourceLayers     srcSubresource;
3491                                 {0, 0, 0},                                                                                      // VkOffset3D                           srcOffset;
3492                                 defaultSourceLayer,                                                                     // VkImageSubresourceLayers     dstSubresource;
3493                                 {defaultFourthSize, defaultFourthSize / 2, 0},          // VkOffset3D                           dstOffset;
3494                                 {defaultFourthSize / 2, defaultFourthSize / 2, 1},      // VkExtent3D                           extent;
3495                         };
3496
3497                         CopyRegion      imageCopy;
3498                         imageCopy.imageCopy     = testCopy;
3499
3500                         params.regions.push_back(imageCopy);
3501                 }
3502
3503                 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "partial_image", "Partial image", params));
3504         }
3505
3506         {
3507                 TestParams                      params;
3508                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
3509                 params.src.image.format         = VK_FORMAT_D32_SFLOAT;
3510                 params.src.image.extent         = defaultExtent;
3511                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
3512                 params.dst.image.format         = VK_FORMAT_D32_SFLOAT;
3513                 params.dst.image.extent         = defaultExtent;
3514
3515                 {
3516                         const VkImageSubresourceLayers  sourceLayer =
3517                         {
3518                                 VK_IMAGE_ASPECT_DEPTH_BIT,      // VkImageAspectFlags   aspectMask;
3519                                 0u,                                                     // uint32_t                             mipLevel;
3520                                 0u,                                                     // uint32_t                             baseArrayLayer;
3521                                 1u                                                      // uint32_t                             layerCount;
3522                         };
3523                         const VkImageCopy                               testCopy        =
3524                         {
3525                                 sourceLayer,                                                                            // VkImageSubresourceLayers     srcSubresource;
3526                                 {0, 0, 0},                                                                                      // VkOffset3D                           srcOffset;
3527                                 sourceLayer,                                                                            // VkImageSubresourceLayers     dstSubresource;
3528                                 {defaultFourthSize, defaultFourthSize / 2, 0},          // VkOffset3D                           dstOffset;
3529                                 {defaultFourthSize / 2, defaultFourthSize / 2, 1},      // VkExtent3D                           extent;
3530                         };
3531
3532                         CopyRegion      imageCopy;
3533                         imageCopy.imageCopy     = testCopy;
3534
3535                         params.regions.push_back(imageCopy);
3536                 }
3537
3538                 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "depth", "With depth", params));
3539         }
3540
3541         {
3542                 TestParams                      params;
3543                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
3544                 params.src.image.format         = VK_FORMAT_S8_UINT;
3545                 params.src.image.extent         = defaultExtent;
3546                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
3547                 params.dst.image.format         = VK_FORMAT_S8_UINT;
3548                 params.dst.image.extent         = defaultExtent;
3549
3550                 {
3551                         const VkImageSubresourceLayers  sourceLayer =
3552                         {
3553                                 VK_IMAGE_ASPECT_STENCIL_BIT,    // VkImageAspectFlags   aspectMask;
3554                                 0u,                                                             // uint32_t                             mipLevel;
3555                                 0u,                                                             // uint32_t                             baseArrayLayer;
3556                                 1u                                                              // uint32_t                             layerCount;
3557                         };
3558                         const VkImageCopy                               testCopy        =
3559                         {
3560                                 sourceLayer,                                                                            // VkImageSubresourceLayers     srcSubresource;
3561                                 {0, 0, 0},                                                                                      // VkOffset3D                           srcOffset;
3562                                 sourceLayer,                                                                            // VkImageSubresourceLayers     dstSubresource;
3563                                 {defaultFourthSize, defaultFourthSize / 2, 0},          // VkOffset3D                           dstOffset;
3564                                 {defaultFourthSize / 2, defaultFourthSize / 2, 1},      // VkExtent3D                           extent;
3565                         };
3566
3567                         CopyRegion      imageCopy;
3568                         imageCopy.imageCopy     = testCopy;
3569
3570                         params.regions.push_back(imageCopy);
3571                 }
3572
3573                 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "stencil", "With stencil", params));
3574         }
3575
3576         {
3577                 TestParams                      params;
3578                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
3579                 params.src.image.extent         = defaultExtent;
3580                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
3581                 params.dst.image.extent         = defaultExtent;
3582
3583                 for (deInt32 i = 0; i < defaultSize; i += defaultFourthSize)
3584                 {
3585                         const VkImageCopy                               testCopy        =
3586                         {
3587                                 defaultSourceLayer,                                                             // VkImageSubresourceLayers     srcSubresource;
3588                                 {0, 0, 0},                                                                              // VkOffset3D                           srcOffset;
3589                                 defaultSourceLayer,                                                             // VkImageSubresourceLayers     dstSubresource;
3590                                 {i, defaultSize - i - defaultFourthSize, 0},    // VkOffset3D                           dstOffset;
3591                                 {defaultFourthSize, defaultFourthSize, 1},              // VkExtent3D                           extent;
3592                         };
3593
3594                         CopyRegion      imageCopy;
3595                         imageCopy.imageCopy     = testCopy;
3596
3597                         params.regions.push_back(imageCopy);
3598                 }
3599
3600                 addCopyImageTestsAllFormats(imgToImgAllFormatsTests.get(), testCtx, params);
3601         }
3602         imageToImageTests->addChild(imgToImgSimpleTests.release());
3603         imageToImageTests->addChild(imgToImgAllFormatsTests.release());
3604
3605         // Copy image to buffer testcases.
3606         {
3607                 TestParams      params;
3608                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
3609                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
3610                 params.src.image.extent         = defaultExtent;
3611                 params.dst.buffer.size          = defaultSize * defaultSize;
3612
3613                 const VkBufferImageCopy bufferImageCopy =
3614                 {
3615                         0u,                                                                                     // VkDeviceSize                         bufferOffset;
3616                         0u,                                                                                     // uint32_t                                     bufferRowLength;
3617                         0u,                                                                                     // uint32_t                                     bufferImageHeight;
3618                         defaultSourceLayer,                                                     // VkImageSubresourceLayers     imageSubresource;
3619                         {0, 0, 0},                                                                      // VkOffset3D                           imageOffset;
3620                         defaultExtent                                                           // VkExtent3D                           imageExtent;
3621                 };
3622                 CopyRegion      copyRegion;
3623                 copyRegion.bufferImageCopy      = bufferImageCopy;
3624
3625                 params.regions.push_back(copyRegion);
3626
3627                 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "whole", "Copy from image to buffer", params));
3628         }
3629
3630         {
3631                 TestParams      params;
3632                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
3633                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
3634                 params.src.image.extent         = defaultExtent;
3635                 params.dst.buffer.size          = defaultSize * defaultSize;
3636
3637                 const VkBufferImageCopy bufferImageCopy =
3638                 {
3639                         defaultSize * defaultHalfSize,                          // VkDeviceSize                         bufferOffset;
3640                         0u,                                                                                     // uint32_t                                     bufferRowLength;
3641                         0u,                                                                                     // uint32_t                                     bufferImageHeight;
3642                         defaultSourceLayer,                                                     // VkImageSubresourceLayers     imageSubresource;
3643                         {defaultFourthSize, defaultFourthSize, 0},      // VkOffset3D                           imageOffset;
3644                         defaultHalfExtent                                                       // VkExtent3D                           imageExtent;
3645                 };
3646                 CopyRegion      copyRegion;
3647                 copyRegion.bufferImageCopy      = bufferImageCopy;
3648
3649                 params.regions.push_back(copyRegion);
3650
3651                 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "buffer_offset", "Copy from image to buffer with buffer offset", params));
3652         }
3653
3654         {
3655                 TestParams      params;
3656                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
3657                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
3658                 params.src.image.extent         = defaultExtent;
3659                 params.dst.buffer.size          = defaultSize * defaultSize;
3660
3661                 const int                       pixelSize       = tcu::getPixelSize(mapVkFormat(params.src.image.format));
3662                 const VkDeviceSize      bufferSize      = pixelSize * params.dst.buffer.size;
3663                 const VkDeviceSize      offsetSize      = pixelSize * defaultFourthSize * defaultFourthSize;
3664                 deUint32                        divisor         = 1;
3665                 for (VkDeviceSize offset = 0; offset < bufferSize - offsetSize; offset += offsetSize, ++divisor)
3666                 {
3667                         const deUint32                  bufferRowLength         = defaultFourthSize;
3668                         const deUint32                  bufferImageHeight       = defaultFourthSize;
3669                         const VkExtent3D                imageExtent                     = {defaultFourthSize / divisor, defaultFourthSize, 1};
3670                         DE_ASSERT(!bufferRowLength || bufferRowLength >= imageExtent.width);
3671                         DE_ASSERT(!bufferImageHeight || bufferImageHeight >= imageExtent.height);
3672                         DE_ASSERT(imageExtent.width * imageExtent.height *imageExtent.depth <= offsetSize);
3673
3674                         CopyRegion                              region;
3675                         const VkBufferImageCopy bufferImageCopy         =
3676                         {
3677                                 offset,                                         // VkDeviceSize                         bufferOffset;
3678                                 bufferRowLength,                        // uint32_t                                     bufferRowLength;
3679                                 bufferImageHeight,                      // uint32_t                                     bufferImageHeight;
3680                                 defaultSourceLayer,                     // VkImageSubresourceLayers     imageSubresource;
3681                                 {0, 0, 0},                                      // VkOffset3D                           imageOffset;
3682                                 imageExtent                                     // VkExtent3D                           imageExtent;
3683                         };
3684                         region.bufferImageCopy  = bufferImageCopy;
3685                         params.regions.push_back(region);
3686                 }
3687
3688                 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "regions", "Copy from image to buffer with multiple regions", params));
3689         }
3690
3691         // Copy buffer to image testcases.
3692         {
3693                 TestParams      params;
3694                 params.src.buffer.size          = defaultSize * defaultSize;
3695                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
3696                 params.dst.image.format         = VK_FORMAT_R8G8B8A8_UINT;
3697                 params.dst.image.extent         = defaultExtent;
3698
3699                 const VkBufferImageCopy bufferImageCopy =
3700                 {
3701                         0u,                                                                                     // VkDeviceSize                         bufferOffset;
3702                         0u,                                                                                     // uint32_t                                     bufferRowLength;
3703                         0u,                                                                                     // uint32_t                                     bufferImageHeight;
3704                         defaultSourceLayer,                                                     // VkImageSubresourceLayers     imageSubresource;
3705                         {0, 0, 0},                                                                      // VkOffset3D                           imageOffset;
3706                         defaultExtent                                                           // VkExtent3D                           imageExtent;
3707                 };
3708                 CopyRegion      copyRegion;
3709                 copyRegion.bufferImageCopy      = bufferImageCopy;
3710
3711                 params.regions.push_back(copyRegion);
3712
3713                 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "whole", "Copy from buffer to image", params));
3714         }
3715
3716         {
3717                 TestParams      params;
3718                 params.src.buffer.size          = defaultSize * defaultSize;
3719                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
3720                 params.dst.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
3721                 params.dst.image.extent         = defaultExtent;
3722
3723                 CopyRegion      region;
3724                 deUint32        divisor = 1;
3725                 for (int offset = 0; (offset + defaultFourthSize / divisor < defaultSize) && (defaultFourthSize > divisor); offset += defaultFourthSize / divisor++)
3726                 {
3727                         const VkBufferImageCopy bufferImageCopy =
3728                         {
3729                                 0u,                                                                                                                             // VkDeviceSize                         bufferOffset;
3730                                 0u,                                                                                                                             // uint32_t                                     bufferRowLength;
3731                                 0u,                                                                                                                             // uint32_t                                     bufferImageHeight;
3732                                 defaultSourceLayer,                                                                                             // VkImageSubresourceLayers     imageSubresource;
3733                                 {offset, defaultHalfSize, 0},                                                                   // VkOffset3D                           imageOffset;
3734                                 {defaultFourthSize / divisor, defaultFourthSize / divisor, 1}   // VkExtent3D                           imageExtent;
3735                         };
3736                         region.bufferImageCopy  = bufferImageCopy;
3737                         params.regions.push_back(region);
3738                 }
3739
3740                 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "regions", "Copy from buffer to image with multiple regions", params));
3741         }
3742
3743         {
3744                 TestParams      params;
3745                 params.src.buffer.size          = defaultSize * defaultSize;
3746                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
3747                 params.dst.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
3748                 params.dst.image.extent         = defaultExtent;
3749
3750                 const VkBufferImageCopy bufferImageCopy =
3751                 {
3752                         defaultFourthSize,                                                      // VkDeviceSize                         bufferOffset;
3753                         defaultHalfSize + defaultFourthSize,            // uint32_t                                     bufferRowLength;
3754                         defaultHalfSize + defaultFourthSize,            // uint32_t                                     bufferImageHeight;
3755                         defaultSourceLayer,                                                     // VkImageSubresourceLayers     imageSubresource;
3756                         {defaultFourthSize, defaultFourthSize, 0},      // VkOffset3D                           imageOffset;
3757                         defaultHalfExtent                                                       // VkExtent3D                           imageExtent;
3758                 };
3759                 CopyRegion      copyRegion;
3760                 copyRegion.bufferImageCopy      = bufferImageCopy;
3761
3762                 params.regions.push_back(copyRegion);
3763
3764                 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "buffer_offset", "Copy from buffer to image with buffer offset", params));
3765         }
3766
3767         // Copy buffer to buffer testcases.
3768         {
3769                 TestParams                      params;
3770                 params.src.buffer.size  = defaultSize;
3771                 params.dst.buffer.size  = defaultSize;
3772
3773                 const VkBufferCopy      bufferCopy      =
3774                 {
3775                         0u,                             // VkDeviceSize srcOffset;
3776                         0u,                             // VkDeviceSize dstOffset;
3777                         defaultSize,    // VkDeviceSize size;
3778                 };
3779
3780                 CopyRegion      copyRegion;
3781                 copyRegion.bufferCopy   = bufferCopy;
3782                 params.regions.push_back(copyRegion);
3783
3784                 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "whole", "Whole buffer", params));
3785         }
3786
3787         {
3788                 TestParams                      params;
3789                 params.src.buffer.size  = defaultFourthSize;
3790                 params.dst.buffer.size  = defaultFourthSize;
3791
3792                 const VkBufferCopy      bufferCopy      =
3793                 {
3794                         12u,    // VkDeviceSize srcOffset;
3795                         4u,             // VkDeviceSize dstOffset;
3796                         1u,             // VkDeviceSize size;
3797                 };
3798
3799                 CopyRegion      copyRegion;
3800                 copyRegion.bufferCopy = bufferCopy;
3801                 params.regions.push_back(copyRegion);
3802
3803                 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "partial", "Partial", params));
3804         }
3805
3806         {
3807                 const deUint32          size            = 16;
3808                 TestParams                      params;
3809                 params.src.buffer.size  = size;
3810                 params.dst.buffer.size  = size * (size + 1);
3811
3812                 // Copy region with size 1..size
3813                 for (unsigned int i = 1; i <= size; i++)
3814                 {
3815                         const VkBufferCopy      bufferCopy      =
3816                         {
3817                                 0,                      // VkDeviceSize srcOffset;
3818                                 i * size,       // VkDeviceSize dstOffset;
3819                                 i,                      // VkDeviceSize size;
3820                         };
3821
3822                         CopyRegion      copyRegion;
3823                         copyRegion.bufferCopy = bufferCopy;
3824                         params.regions.push_back(copyRegion);
3825                 }
3826
3827                 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "regions", "Multiple regions", params));
3828         }
3829
3830         // Blitting testcases.
3831         {
3832                 const std::string       description     ("Blit without scaling (whole)");
3833                 const std::string       testName        ("whole");
3834
3835                 TestParams                      params;
3836                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
3837                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
3838                 params.src.image.extent         = defaultExtent;
3839                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
3840                 params.dst.image.extent         = defaultExtent;
3841
3842                 {
3843                         const VkImageBlit                               imageBlit       =
3844                         {
3845                                 defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
3846                                 {
3847                                         {0, 0, 0},
3848                                         {defaultSize, defaultSize, 1}
3849                                 },                                      // VkOffset3D                           srcOffsets[2];
3850
3851                                 defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
3852                                 {
3853                                         {0, 0, 0},
3854                                         {defaultSize, defaultSize, 1}
3855                                 }                                       // VkOffset3D                           dstOffset[2];
3856                         };
3857
3858                         CopyRegion      region;
3859                         region.imageBlit = imageBlit;
3860                         params.regions.push_back(region);
3861                 }
3862
3863                 // Filter is VK_FILTER_NEAREST.
3864                 {
3865                         params.filter                   = VK_FILTER_NEAREST;
3866
3867                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3868                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
3869
3870                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
3871                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)");
3872                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
3873
3874                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
3875                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
3876                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
3877                 }
3878
3879                 // Filter is VK_FILTER_LINEAR.
3880                 {
3881                         params.filter                   = VK_FILTER_LINEAR;
3882
3883                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3884                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
3885
3886                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
3887                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
3888                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
3889
3890                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
3891                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
3892                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
3893                 }
3894         }
3895
3896         {
3897                 const std::string       description     ("Flipping x and y coordinates (whole)");
3898                 const std::string       testName        ("mirror_xy");
3899
3900                 TestParams                      params;
3901                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
3902                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
3903                 params.src.image.extent         = defaultExtent;
3904                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
3905                 params.dst.image.extent         = defaultExtent;
3906
3907                 {
3908                         const VkImageBlit                               imageBlit       =
3909                         {
3910                                 defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
3911                                 {
3912                                         {0, 0, 0},
3913                                         {defaultSize, defaultSize, 1}
3914                                 },                                      // VkOffset3D                           srcOffsets[2];
3915
3916                                 defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
3917                                 {
3918                                         {defaultSize, defaultSize, 1},
3919                                         {0, 0, 0}
3920                                 }                                       // VkOffset3D                           dstOffset[2];
3921                         };
3922
3923                         CopyRegion      region;
3924                         region.imageBlit = imageBlit;
3925                         params.regions.push_back(region);
3926                 }
3927
3928                 // Filter is VK_FILTER_NEAREST.
3929                 {
3930                         params.filter                   = VK_FILTER_NEAREST;
3931
3932                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3933                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
3934
3935                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
3936                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)");
3937                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
3938
3939                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
3940                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
3941                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" +  getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
3942                 }
3943
3944                 // Filter is VK_FILTER_LINEAR.
3945                 {
3946                         params.filter                   = VK_FILTER_LINEAR;
3947
3948                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3949                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
3950
3951                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
3952                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
3953                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
3954
3955                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
3956                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
3957                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
3958                 }
3959         }
3960
3961         {
3962                 const std::string       description     ("Flipping x coordinates (whole)");
3963                 const std::string       testName        ("mirror_x");
3964
3965                 TestParams                      params;
3966                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
3967                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
3968                 params.src.image.extent         = defaultExtent;
3969                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
3970                 params.dst.image.extent         = defaultExtent;
3971
3972                 {
3973                         const VkImageBlit                               imageBlit       =
3974                         {
3975                                 defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
3976                                 {
3977                                         {0, 0, 0},
3978                                         {defaultSize, defaultSize, 1}
3979                                 },                                      // VkOffset3D                           srcOffsets[2];
3980
3981                                 defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
3982                                 {
3983                                         {defaultSize, 0, 0},
3984                                         {0, defaultSize, 1}
3985                                 }                                       // VkOffset3D                           dstOffset[2];
3986                         };
3987
3988                         CopyRegion      region;
3989                         region.imageBlit = imageBlit;
3990                         params.regions.push_back(region);
3991                 }
3992
3993                 // Filter is VK_FILTER_NEAREST.
3994                 {
3995                         params.filter                   = VK_FILTER_NEAREST;
3996
3997                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3998                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
3999
4000                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4001                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)");
4002                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4003
4004                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4005                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4006                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4007                 }
4008
4009                 // Filter is VK_FILTER_LINEAR.
4010                 {
4011                         params.filter                   = VK_FILTER_LINEAR;
4012
4013                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4014                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4015
4016                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4017                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4018                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4019
4020                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4021                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4022                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4023                 }
4024         }
4025
4026         {
4027                 const std::string       description     ("Flipping Y coordinates (whole)");
4028                 const std::string       testName        ("mirror_y");
4029
4030                 TestParams                      params;
4031                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
4032                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
4033                 params.src.image.extent         = defaultExtent;
4034                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
4035                 params.dst.image.extent         = defaultExtent;
4036
4037                 {
4038                         const VkImageBlit                               imageBlit       =
4039                         {
4040                                 defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
4041                                 {
4042                                         {0, 0, 0},
4043                                         {defaultSize, defaultSize, 1}
4044                                 },                                      // VkOffset3D                           srcOffsets[2];
4045
4046                                 defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
4047                                 {
4048                                         {0, defaultSize, 1},
4049                                         {defaultSize, 0, 0}
4050                                 }                                       // VkOffset3D                           dstOffset[2];
4051                         };
4052
4053                         CopyRegion      region;
4054                         region.imageBlit = imageBlit;
4055                         params.regions.push_back(region);
4056                 }
4057
4058                 // Filter is VK_FILTER_NEAREST.
4059                 {
4060                         params.filter                   = VK_FILTER_NEAREST;
4061
4062                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4063                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4064
4065                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4066                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)");
4067                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4068
4069                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4070                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4071                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4072                 }
4073
4074                 // Filter is VK_FILTER_LINEAR.
4075                 {
4076                         params.filter                   = VK_FILTER_LINEAR;
4077
4078                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4079                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4080
4081                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4082                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4083                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4084
4085                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4086                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4087                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4088                 }
4089         }
4090
4091         {
4092                 const std::string       description     ("Mirroring subregions in image (no flip ,y flip ,x flip, xy flip)");
4093                 const std::string       testName        ("mirror_subregions");
4094
4095                 TestParams                      params;
4096                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
4097                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
4098                 params.src.image.extent         = defaultExtent;
4099                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
4100                 params.dst.image.extent         = defaultExtent;
4101
4102                 // No mirroring.
4103                 {
4104                         const VkImageBlit                               imageBlit       =
4105                         {
4106                                 defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
4107                                 {
4108                                         {0, 0, 0},
4109                                         {defaultHalfSize, defaultHalfSize, 1}
4110                                 },                                      // VkOffset3D                           srcOffsets[2];
4111
4112                                 defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
4113                                 {
4114                                         {0, 0, 0},
4115                                         {defaultHalfSize, defaultHalfSize, 1}
4116                                 }                                       // VkOffset3D                           dstOffset[2];
4117                         };
4118
4119                         CopyRegion      region;
4120                         region.imageBlit = imageBlit;
4121                         params.regions.push_back(region);
4122                 }
4123
4124                 // Flipping y coordinates.
4125                 {
4126                         const VkImageBlit                               imageBlit       =
4127                         {
4128                                 defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
4129                                 {
4130                                         {defaultHalfSize, 0, 0},
4131                                         {defaultSize, defaultHalfSize, 1}
4132                                 },                                      // VkOffset3D                           srcOffsets[2];
4133
4134                                 defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
4135                                 {
4136                                         {defaultHalfSize, defaultHalfSize, 0},
4137                                         {defaultSize, 0, 1}
4138                                 }                                       // VkOffset3D                           dstOffset[2];
4139                         };
4140
4141                         CopyRegion      region;
4142                         region.imageBlit = imageBlit;
4143                         params.regions.push_back(region);
4144                 }
4145
4146                 // Flipping x coordinates.
4147                 {
4148                         const VkImageBlit                               imageBlit       =
4149                         {
4150                                 defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
4151                                 {
4152                                         {0, defaultHalfSize, 0},
4153                                         {defaultHalfSize, defaultSize, 1}
4154                                 },                                      // VkOffset3D                           srcOffsets[2];
4155
4156                                 defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
4157                                 {
4158                                         {defaultHalfSize, defaultHalfSize, 0},
4159                                         {0, defaultSize, 1}
4160                                 }                                       // VkOffset3D                           dstOffset[2];
4161                         };
4162
4163                         CopyRegion      region;
4164                         region.imageBlit = imageBlit;
4165                         params.regions.push_back(region);
4166                 }
4167
4168                 // Flipping x and y coordinates.
4169                 {
4170                         const VkImageBlit                               imageBlit       =
4171                         {
4172                                 defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
4173                                 {
4174                                         {defaultHalfSize, defaultHalfSize, 0},
4175                                         {defaultSize, defaultSize, 1}
4176                                 },                                      // VkOffset3D                           srcOffsets[2];
4177
4178                                 defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
4179                                 {
4180                                         {defaultSize, defaultSize, 0},
4181                                         {defaultHalfSize, defaultHalfSize, 1}
4182                                 }                                       // VkOffset3D                           dstOffset[2];
4183                         };
4184
4185                         CopyRegion      region;
4186                         region.imageBlit = imageBlit;
4187                         params.regions.push_back(region);
4188                 }
4189
4190                 // Filter is VK_FILTER_NEAREST.
4191                 {
4192                         params.filter                   = VK_FILTER_NEAREST;
4193
4194                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4195                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4196
4197                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4198                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)");
4199                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4200
4201                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4202                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4203                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4204                 }
4205
4206                 // Filter is VK_FILTER_LINEAR.
4207                 {
4208                         params.filter                   = VK_FILTER_LINEAR;
4209
4210                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4211                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4212
4213                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4214                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4215                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4216
4217                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4218                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4219                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4220                 }
4221         }
4222
4223         {
4224                 const std::string       description     ("Blit with scaling (whole, src extent bigger)");
4225                 const std::string       testName        ("scaling_whole1");
4226
4227                 TestParams                      params;
4228                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
4229                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
4230                 params.src.image.extent         = defaultExtent;
4231                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
4232                 params.dst.image.extent         = defaultHalfExtent;
4233
4234                 {
4235                         const VkImageBlit                               imageBlit       =
4236                         {
4237                                 defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
4238                                 {
4239                                         {0, 0, 0},
4240                                         {defaultSize, defaultSize, 1}
4241                                 },                                      // VkOffset3D                                   srcOffsets[2];
4242
4243                                 defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
4244                                 {
4245                                         {0, 0, 0},
4246                                         {defaultHalfSize, defaultHalfSize, 1}
4247                                 }                                       // VkOffset3D                                   dstOffset[2];
4248                         };
4249
4250                         CopyRegion      region;
4251                         region.imageBlit        = imageBlit;
4252                         params.regions.push_back(region);
4253                 }
4254
4255                 // Filter is VK_FILTER_NEAREST.
4256                 {
4257                         params.filter                   = VK_FILTER_NEAREST;
4258
4259                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4260                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4261
4262                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4263                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)");
4264                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4265
4266                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4267                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4268                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4269                 }
4270
4271                 // Filter is VK_FILTER_LINEAR.
4272                 {
4273                         params.filter                   = VK_FILTER_LINEAR;
4274
4275                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4276                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4277
4278                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4279                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4280                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4281
4282                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4283                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4284                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4285                 }
4286         }
4287
4288         {
4289                 const std::string       description     ("Blit with scaling (whole, dst extent bigger)");
4290                 const std::string       testName        ("scaling_whole2");
4291
4292                 TestParams                      params;
4293                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
4294                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
4295                 params.src.image.extent         = defaultHalfExtent;
4296                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
4297                 params.dst.image.extent         = defaultExtent;
4298
4299                 {
4300                         const VkImageBlit                               imageBlit       =
4301                         {
4302                                 defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
4303                                 {
4304                                         {0, 0, 0},
4305                                         {defaultHalfSize, defaultHalfSize, 1}
4306                                 },                                      // VkOffset3D                                   srcOffsets[2];
4307
4308                                 defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
4309                                 {
4310                                         {0, 0, 0},
4311                                         {defaultSize, defaultSize, 1}
4312                                 }                                       // VkOffset3D                                   dstOffset[2];
4313                         };
4314
4315                         CopyRegion      region;
4316                         region.imageBlit        = imageBlit;
4317                         params.regions.push_back(region);
4318                 }
4319
4320                 // Filter is VK_FILTER_NEAREST.
4321                 {
4322                         params.filter                   = VK_FILTER_NEAREST;
4323
4324                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4325                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4326
4327                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4328                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)");
4329                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4330
4331                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4332                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4333                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4334                 }
4335
4336                 // Filter is VK_FILTER_LINEAR.
4337                 {
4338                         params.filter                   = VK_FILTER_LINEAR;
4339
4340                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4341                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4342
4343                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4344                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4345                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4346
4347                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4348                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4349                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4350                 }
4351         }
4352
4353         {
4354                 const std::string       description     ("Blit with scaling and offset (whole, dst extent bigger)");
4355                 const std::string       testName        ("scaling_and_offset");
4356
4357                 TestParams                      params;
4358                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
4359                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
4360                 params.src.image.extent         = defaultExtent;
4361                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
4362                 params.dst.image.extent         = defaultExtent;
4363
4364                 {
4365                         const VkImageBlit                               imageBlit       =
4366                         {
4367                                 defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
4368                                 {
4369                                         {defaultHalfSize, defaultHalfSize, 0},
4370                                         {defaultHalfSize + 1, defaultHalfSize + 1, 1}
4371                                 },                                      // VkOffset3D                                   srcOffsets[2];
4372
4373                                 defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
4374                                 {
4375                                         {0, 0, 0},
4376                                         {defaultSize, defaultSize, 1}
4377                                 }                                       // VkOffset3D                                   dstOffset[2];
4378                         };
4379
4380                         CopyRegion      region;
4381                         region.imageBlit        = imageBlit;
4382                         params.regions.push_back(region);
4383                 }
4384
4385                 // Filter is VK_FILTER_NEAREST.
4386                 {
4387                         params.filter                   = VK_FILTER_NEAREST;
4388
4389                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4390                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4391
4392                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4393                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)");
4394                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4395
4396                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4397                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4398                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4399                 }
4400
4401                 // Filter is VK_FILTER_LINEAR.
4402                 {
4403                         params.filter                   = VK_FILTER_LINEAR;
4404
4405                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4406                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4407
4408                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4409                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4410                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4411
4412                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4413                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4414                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4415                 }
4416         }
4417
4418         {
4419                 const std::string       description     ("Blit without scaling (partial)");
4420                 const std::string       testName        ("without_scaling_partial");
4421
4422                 TestParams                      params;
4423                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
4424                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
4425                 params.src.image.extent         = defaultExtent;
4426                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
4427                 params.dst.image.extent         = defaultExtent;
4428
4429                 {
4430                         CopyRegion      region;
4431                         for (int i = 0; i < defaultSize; i += defaultFourthSize)
4432                         {
4433                                 const VkImageBlit                       imageBlit       =
4434                                 {
4435                                         defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
4436                                         {
4437                                                 {defaultSize - defaultFourthSize - i, defaultSize - defaultFourthSize - i, 0},
4438                                                 {defaultSize - i, defaultSize - i, 1}
4439                                         },                                      // VkOffset3D                                   srcOffsets[2];
4440
4441                                         defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
4442                                         {
4443                                                 {i, i, 0},
4444                                                 {i + defaultFourthSize, i + defaultFourthSize, 1}
4445                                         }                                       // VkOffset3D                                   dstOffset[2];
4446                                 };
4447                                 region.imageBlit        = imageBlit;
4448                                 params.regions.push_back(region);
4449                         }
4450                 }
4451
4452                 // Filter is VK_FILTER_NEAREST.
4453                 {
4454                         params.filter                   = VK_FILTER_NEAREST;
4455
4456                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4457                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4458
4459
4460                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4461                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)");
4462                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4463
4464                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4465                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4466                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4467                 }
4468
4469                 // Filter is VK_FILTER_LINEAR.
4470                 {
4471                         params.filter                   = VK_FILTER_LINEAR;
4472
4473                         params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4474                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4475
4476                         params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4477                         const std::string       descriptionOfRGBAToR32  (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4478                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4479
4480                         params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4481                         const std::string       descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4482                         blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4483                 }
4484         }
4485
4486         {
4487                 const std::string       description     ("Blit with scaling (partial)");
4488                 const std::string       testName        ("scaling_partial");
4489
4490                 // Test Color formats.
4491                 {
4492                         TestParams      params;
4493                         params.src.image.imageType      = VK_IMAGE_TYPE_2D;
4494                         params.src.image.extent         = defaultExtent;
4495                         params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
4496                         params.dst.image.extent         = defaultExtent;
4497
4498                         CopyRegion      region;
4499                         for (int i = 0, j = 1; (i + defaultFourthSize / j < defaultSize) && (defaultFourthSize > j); i += defaultFourthSize / j++)
4500                         {
4501                                 const VkImageBlit                       imageBlit       =
4502                                 {
4503                                         defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
4504                                         {
4505                                                 {0, 0, 0},
4506                                                 {defaultSize, defaultSize, 1}
4507                                         },                                      // VkOffset3D                                   srcOffsets[2];
4508
4509                                         defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
4510                                         {
4511                                                 {i, 0, 0},
4512                                                 {i + defaultFourthSize / j, defaultFourthSize / j, 1}
4513                                         }                                       // VkOffset3D                                   dstOffset[2];
4514                                 };
4515                                 region.imageBlit        = imageBlit;
4516                                 params.regions.push_back(region);
4517                         }
4518                         for (int i = 0; i < defaultSize; i += defaultFourthSize)
4519                         {
4520                                 const VkImageBlit                       imageBlit       =
4521                                 {
4522                                         defaultSourceLayer,     // VkImageSubresourceLayers     srcSubresource;
4523                                         {
4524                                                 {i, i, 0},
4525                                                 {i + defaultFourthSize, i + defaultFourthSize, 1}
4526                                         },                                      // VkOffset3D                                   srcOffsets[2];
4527
4528                                         defaultSourceLayer,     // VkImageSubresourceLayers     dstSubresource;
4529                                         {
4530                                                 {i, defaultSize / 2, 0},
4531                                                 {i + defaultFourthSize, defaultSize / 2 + defaultFourthSize, 1}
4532                                         }                                       // VkOffset3D                                   dstOffset[2];
4533                                 };
4534                                 region.imageBlit        = imageBlit;
4535                                 params.regions.push_back(region);
4536                         }
4537
4538                         addBlittingTestsAllFormats(blitImgAllFormatsTests.get(), testCtx, params);
4539                 }
4540
4541                 // Test Depth and Stencil formats.
4542                 {
4543                         const VkFormat  compatibleDepthAndStencilFormats[]      =
4544                         {
4545                                 VK_FORMAT_D16_UNORM,
4546                                 VK_FORMAT_X8_D24_UNORM_PACK32,
4547                                 VK_FORMAT_D32_SFLOAT,
4548                                 VK_FORMAT_S8_UINT,
4549                                 VK_FORMAT_D16_UNORM_S8_UINT,
4550                                 VK_FORMAT_D24_UNORM_S8_UINT,
4551                                 VK_FORMAT_D32_SFLOAT_S8_UINT,
4552                         };
4553
4554                         for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < DE_LENGTH_OF_ARRAY(compatibleDepthAndStencilFormats); ++compatibleFormatsIndex)
4555                         {
4556                                 TestParams params;
4557
4558                                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
4559                                 params.src.image.extent         = defaultExtent;
4560                                 params.dst.image.extent         = defaultExtent;
4561                                 params.src.image.format         = compatibleDepthAndStencilFormats[compatibleFormatsIndex];
4562                                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
4563                                 params.dst.image.format         = params.src.image.format;
4564                                 std::ostringstream      oss;
4565                                 oss << testName << "_" << getFormatCaseName(params.src.image.format) << "_" << getFormatCaseName(params.dst.image.format);
4566
4567                                 const VkImageSubresourceLayers  defaultDepthSourceLayer         = { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 0u, 1u };
4568                                 const VkImageSubresourceLayers  defaultStencilSourceLayer       = { VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 0u, 1u };
4569
4570                                 CopyRegion      region;
4571                                 for (int i = 0, j = 1; (i + defaultFourthSize / j < defaultSize) && (defaultFourthSize > j); i += defaultFourthSize / j++)
4572                                 {
4573                                         const VkOffset3D        srcOffset0      = {0, 0, 0};
4574                                         const VkOffset3D        srcOffset1      = {defaultSize, defaultSize, 1};
4575                                         const VkOffset3D        dstOffset0      = {i, 0, 0};
4576                                         const VkOffset3D        dstOffset1      = {i + defaultFourthSize / j, defaultFourthSize / j, 1};
4577
4578                                         if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
4579                                         {
4580                                                 const VkImageBlit                       imageBlit       =
4581                                                 {
4582                                                         defaultDepthSourceLayer,                // VkImageSubresourceLayers     srcSubresource;
4583                                                         { srcOffset0 , srcOffset1 },    // VkOffset3D                                   srcOffsets[2];
4584                                                         defaultDepthSourceLayer,                // VkImageSubresourceLayers     dstSubresource;
4585                                                         { dstOffset0 , dstOffset1 },    // VkOffset3D                                   dstOffset[2];
4586                                                 };
4587                                                 region.imageBlit        = imageBlit;
4588                                                 params.regions.push_back(region);
4589                                         }
4590                                         if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
4591                                         {
4592                                                 const VkImageBlit                       imageBlit       =
4593                                                 {
4594                                                         defaultStencilSourceLayer,              // VkImageSubresourceLayers     srcSubresource;
4595                                                         { srcOffset0 , srcOffset1 },    // VkOffset3D                                   srcOffsets[2];
4596                                                         defaultStencilSourceLayer,              // VkImageSubresourceLayers     dstSubresource;
4597                                                         { dstOffset0 , dstOffset1 },    // VkOffset3D                                   dstOffset[2];
4598                                                 };
4599                                                 region.imageBlit        = imageBlit;
4600                                                 params.regions.push_back(region);
4601                                         }
4602                                 }
4603                                 for (int i = 0; i < defaultSize; i += defaultFourthSize)
4604                                 {
4605                                         const VkOffset3D        srcOffset0      = {i, i, 0};
4606                                         const VkOffset3D        srcOffset1      = {i + defaultFourthSize, i + defaultFourthSize, 1};
4607                                         const VkOffset3D        dstOffset0      = {i, defaultSize / 2, 0};
4608                                         const VkOffset3D        dstOffset1      = {i + defaultFourthSize, defaultSize / 2 + defaultFourthSize, 1};
4609
4610                                         if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
4611                                         {
4612                                                 const VkImageBlit                       imageBlit       =
4613                                                 {
4614                                                         defaultDepthSourceLayer,                // VkImageSubresourceLayers     srcSubresource;
4615                                                         { srcOffset0, srcOffset1 },             // VkOffset3D                                   srcOffsets[2];
4616                                                         defaultDepthSourceLayer,                // VkImageSubresourceLayers     dstSubresource;
4617                                                         { dstOffset0, dstOffset1 }              // VkOffset3D                                   dstOffset[2];
4618                                                 };
4619                                                 region.imageBlit        = imageBlit;
4620                                                 params.regions.push_back(region);
4621                                         }
4622                                         if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
4623                                         {
4624                                                 const VkImageBlit                       imageBlit       =
4625                                                 {
4626                                                         defaultStencilSourceLayer,              // VkImageSubresourceLayers     srcSubresource;
4627                                                         { srcOffset0, srcOffset1 },             // VkOffset3D                                   srcOffsets[2];
4628                                                         defaultStencilSourceLayer,              // VkImageSubresourceLayers     dstSubresource;
4629                                                         { dstOffset0, dstOffset1 }              // VkOffset3D                                   dstOffset[2];
4630                                                 };
4631                                                 region.imageBlit        = imageBlit;
4632                                                 params.regions.push_back(region);
4633                                         }
4634                                 }
4635
4636                                 params.filter                   = VK_FILTER_NEAREST;
4637                                 blitImgAllFormatsTests->addChild(new BlittingTestCase(testCtx, oss.str() + "_nearest", description, params));
4638                         }
4639                 }
4640         }
4641         blittingImageTests->addChild(blitImgSimpleTests.release());
4642         blittingImageTests->addChild(blitImgAllFormatsTests.release());
4643
4644         // Resolve image to image testcases.
4645         const VkSampleCountFlagBits     samples[]               =
4646         {
4647                 VK_SAMPLE_COUNT_2_BIT,
4648                 VK_SAMPLE_COUNT_4_BIT,
4649                 VK_SAMPLE_COUNT_8_BIT,
4650                 VK_SAMPLE_COUNT_16_BIT,
4651                 VK_SAMPLE_COUNT_32_BIT,
4652                 VK_SAMPLE_COUNT_64_BIT
4653         };
4654         const VkExtent3D                        resolveExtent   = {256u, 256u, 1};
4655
4656         {
4657                 const std::string       description     ("Resolve from image to image");
4658                 const std::string       testName        ("whole");
4659
4660                 TestParams                      params;
4661                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
4662                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
4663                 params.src.image.extent         = resolveExtent;
4664                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
4665                 params.dst.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
4666                 params.dst.image.extent         = resolveExtent;
4667
4668                 {
4669                         const VkImageSubresourceLayers  sourceLayer     =
4670                         {
4671                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
4672                                 0u,                                                     // uint32_t                             mipLevel;
4673                                 0u,                                                     // uint32_t                             baseArrayLayer;
4674                                 1u                                                      // uint32_t                             layerCount;
4675                         };
4676                         const VkImageResolve                    testResolve     =
4677                         {
4678                                 sourceLayer,    // VkImageSubresourceLayers     srcSubresource;
4679                                 {0, 0, 0},              // VkOffset3D                           srcOffset;
4680                                 sourceLayer,    // VkImageSubresourceLayers     dstSubresource;
4681                                 {0, 0, 0},              // VkOffset3D                           dstOffset;
4682                                 resolveExtent,  // VkExtent3D                           extent;
4683                         };
4684
4685                         CopyRegion      imageResolve;
4686                         imageResolve.imageResolve       = testResolve;
4687                         params.regions.push_back(imageResolve);
4688                 }
4689
4690                 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4691                 {
4692                         params.samples = samples[samplesIndex];
4693                         std::ostringstream caseName;
4694                         caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4695                         resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params));
4696                 }
4697         }
4698
4699         {
4700                 const std::string       description     ("Resolve from image to image");
4701                 const std::string       testName        ("partial");
4702
4703                 TestParams                      params;
4704                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
4705                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
4706                 params.src.image.extent         = resolveExtent;
4707                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
4708                 params.dst.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
4709                 params.dst.image.extent         = resolveExtent;
4710
4711                 {
4712                         const VkImageSubresourceLayers  sourceLayer     =
4713                         {
4714                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
4715                                 0u,                                                     // uint32_t                             mipLevel;
4716                                 0u,                                                     // uint32_t                             baseArrayLayer;
4717                                 1u                                                      // uint32_t                             layerCount;
4718                         };
4719                         const VkImageResolve                    testResolve     =
4720                         {
4721                                 sourceLayer,    // VkImageSubresourceLayers     srcSubresource;
4722                                 {0, 0, 0},              // VkOffset3D                           srcOffset;
4723                                 sourceLayer,    // VkImageSubresourceLayers     dstSubresource;
4724                                 {64u, 64u, 0},          // VkOffset3D                           dstOffset;
4725                                 {128u, 128u, 1u},       // VkExtent3D                           extent;
4726                         };
4727
4728                         CopyRegion      imageResolve;
4729                         imageResolve.imageResolve = testResolve;
4730                         params.regions.push_back(imageResolve);
4731                 }
4732
4733                 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4734                 {
4735                         params.samples = samples[samplesIndex];
4736                         std::ostringstream caseName;
4737                         caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4738                         resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params));
4739                 }
4740         }
4741
4742         {
4743                 const std::string       description     ("Resolve from image to image");
4744                 const std::string       testName        ("with_regions");
4745
4746                 TestParams                      params;
4747                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
4748                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
4749                 params.src.image.extent         = resolveExtent;
4750                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
4751                 params.dst.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
4752                 params.dst.image.extent         = resolveExtent;
4753
4754                 {
4755                         const VkImageSubresourceLayers  sourceLayer     =
4756                         {
4757                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
4758                                 0u,                                                     // uint32_t                             mipLevel;
4759                                 0u,                                                     // uint32_t                             baseArrayLayer;
4760                                 1u                                                      // uint32_t                             layerCount;
4761                         };
4762
4763                         for (int i = 0; i < 256; i += 64)
4764                         {
4765                                 const VkImageResolve                    testResolve     =
4766                                 {
4767                                         sourceLayer,    // VkImageSubresourceLayers     srcSubresource;
4768                                         {i, i, 0},              // VkOffset3D                           srcOffset;
4769                                         sourceLayer,    // VkImageSubresourceLayers     dstSubresource;
4770                                         {i, 0, 0},              // VkOffset3D                           dstOffset;
4771                                         {64u, 64u, 1u}, // VkExtent3D                           extent;
4772                                 };
4773
4774                                 CopyRegion      imageResolve;
4775                                 imageResolve.imageResolve = testResolve;
4776                                 params.regions.push_back(imageResolve);
4777                         }
4778                 }
4779
4780                 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4781                 {
4782                         params.samples = samples[samplesIndex];
4783                         std::ostringstream caseName;
4784                         caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4785                         resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params));
4786                 }
4787         }
4788
4789         {
4790                 const std::string       description     ("Resolve from image to image");
4791                 const std::string       testName        ("whole_copy_before_resolving");
4792
4793                 TestParams                      params;
4794                 params.src.image.imageType      = VK_IMAGE_TYPE_2D;
4795                 params.src.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
4796                 params.src.image.extent         = defaultExtent;
4797                 params.dst.image.imageType      = VK_IMAGE_TYPE_2D;
4798                 params.dst.image.format         = VK_FORMAT_R8G8B8A8_UNORM;
4799                 params.dst.image.extent         = defaultExtent;
4800
4801                 {
4802                         const VkImageSubresourceLayers  sourceLayer     =
4803                         {
4804                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
4805                                 0u,                                                     // uint32_t                             mipLevel;
4806                                 0u,                                                     // uint32_t                             baseArrayLayer;
4807                                 1u                                                      // uint32_t                             layerCount;
4808                         };
4809
4810                         const VkImageResolve                    testResolve     =
4811                         {
4812                                 sourceLayer,            // VkImageSubresourceLayers     srcSubresource;
4813                                 {0, 0, 0},                      // VkOffset3D                           srcOffset;
4814                                 sourceLayer,            // VkImageSubresourceLayers     dstSubresource;
4815                                 {0, 0, 0},                      // VkOffset3D                           dstOffset;
4816                                 defaultExtent,          // VkExtent3D                           extent;
4817                         };
4818
4819                         CopyRegion      imageResolve;
4820                         imageResolve.imageResolve       = testResolve;
4821                         params.regions.push_back(imageResolve);
4822                 }
4823
4824                 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4825                 {
4826                         params.samples = samples[samplesIndex];
4827                         std::ostringstream caseName;
4828                         caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4829                         resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params, COPY_MS_IMAGE_TO_MS_IMAGE));
4830                 }
4831         }
4832
4833         {
4834                 const std::string       description     ("Resolve from image to image");
4835                 const std::string       testName        ("whole_array_image");
4836
4837                 TestParams                      params;
4838                 params.src.image.imageType              = VK_IMAGE_TYPE_2D;
4839                 params.src.image.format                 = VK_FORMAT_R8G8B8A8_UNORM;
4840                 params.src.image.extent                 = defaultExtent;
4841                 params.dst.image.imageType              = VK_IMAGE_TYPE_2D;
4842                 params.dst.image.format                 = VK_FORMAT_R8G8B8A8_UNORM;
4843                 params.dst.image.extent                 = defaultExtent;
4844                 params.dst.image.extent.depth   = 5u;
4845
4846                 for (deUint32 layerNdx=0; layerNdx < params.dst.image.extent.depth; ++layerNdx)
4847                 {
4848                         const VkImageSubresourceLayers  sourceLayer     =
4849                         {
4850                                 VK_IMAGE_ASPECT_COLOR_BIT,              // VkImageAspectFlags   aspectMask;
4851                                 0u,                                                             // uint32_t                             mipLevel;
4852                                 layerNdx,                                               // uint32_t                             baseArrayLayer;
4853                                 1u                                                              // uint32_t                             layerCount;
4854                         };
4855
4856                         const VkImageResolve                    testResolve     =
4857                         {
4858                                 sourceLayer,            // VkImageSubresourceLayers     srcSubresource;
4859                                 {0, 0, 0},                      // VkOffset3D                           srcOffset;
4860                                 sourceLayer,            // VkImageSubresourceLayers     dstSubresource;
4861                                 {0, 0, 0},                      // VkOffset3D                           dstOffset;
4862                                 defaultExtent,          // VkExtent3D                           extent;
4863                         };
4864
4865                         CopyRegion      imageResolve;
4866                         imageResolve.imageResolve       = testResolve;
4867                         params.regions.push_back(imageResolve);
4868                 }
4869
4870                 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4871                 {
4872                         params.samples = samples[samplesIndex];
4873                         std::ostringstream caseName;
4874                         caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4875                         resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params, COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE));
4876                 }
4877         }
4878
4879         {
4880                 TestParams      params3DTo2D;
4881                 const deUint32  slicesLayers                    = 16u;
4882                 params3DTo2D.src.image.imageType                = VK_IMAGE_TYPE_3D;
4883                 params3DTo2D.src.image.format                   = VK_FORMAT_R8G8B8A8_UINT;
4884                 params3DTo2D.src.image.extent                   = defaultHalfExtent;
4885                 params3DTo2D.src.image.extent.depth             = slicesLayers;
4886                 params3DTo2D.dst.image.imageType                = VK_IMAGE_TYPE_2D;
4887                 params3DTo2D.dst.image.format                   = VK_FORMAT_R8G8B8A8_UINT;
4888                 params3DTo2D.dst.image.extent                   = defaultHalfExtent;
4889                 params3DTo2D.dst.image.extent.depth             = slicesLayers;
4890
4891                 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
4892                 {
4893                         const VkImageSubresourceLayers  sourceLayer     =
4894                         {
4895                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
4896                                 0u,                                                     // uint32_t                             mipLevel;
4897                                 0u,                                                     // uint32_t                             baseArrayLayer;
4898                                 1u                                                      // uint32_t                             layerCount;
4899                         };
4900
4901                         const VkImageSubresourceLayers  destinationLayer        =
4902                         {
4903                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
4904                                 0u,                                                     // uint32_t                             mipLevel;
4905                                 slicesLayersNdx,                        // uint32_t                             baseArrayLayer;
4906                                 1u                                                      // uint32_t                             layerCount;
4907                         };
4908
4909                         const VkImageCopy                               testCopy        =
4910                         {
4911                                 sourceLayer,                                            // VkImageSubresourceLayers     srcSubresource;
4912                                 {0, 0, (deInt32)slicesLayersNdx},       // VkOffset3D                                   srcOffset;
4913                                 destinationLayer,                                       // VkImageSubresourceLayers     dstSubresource;
4914                                 {0, 0, 0},                                                      // VkOffset3D                                   dstOffset;
4915                                 defaultHalfExtent,                                      // VkExtent3D                                   extent;
4916                         };
4917
4918                         CopyRegion      imageCopy;
4919                         imageCopy.imageCopy     = testCopy;
4920
4921                         params3DTo2D.regions.push_back(imageCopy);
4922                 }
4923                 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_by_slices", "copy 2d layers to 3d slices one by one", params3DTo2D));
4924         }
4925
4926         {
4927                 TestParams      params2DTo3D;
4928                 const deUint32  slicesLayers                    = 16u;
4929                 params2DTo3D.src.image.imageType                = VK_IMAGE_TYPE_2D;
4930                 params2DTo3D.src.image.format                   = VK_FORMAT_R8G8B8A8_UINT;
4931                 params2DTo3D.src.image.extent                   = defaultHalfExtent;
4932                 params2DTo3D.src.image.extent.depth             = slicesLayers;
4933                 params2DTo3D.dst.image.imageType                = VK_IMAGE_TYPE_3D;
4934                 params2DTo3D.dst.image.format                   = VK_FORMAT_R8G8B8A8_UINT;
4935                 params2DTo3D.dst.image.extent                   = defaultHalfExtent;
4936                 params2DTo3D.dst.image.extent.depth             = slicesLayers;
4937
4938                 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
4939                 {
4940                         const VkImageSubresourceLayers  sourceLayer     =
4941                         {
4942                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
4943                                 0u,                                                     // uint32_t                             mipLevel;
4944                                 slicesLayersNdx,                        // uint32_t                             baseArrayLayer;
4945                                 1u                                                      // uint32_t                             layerCount;
4946                         };
4947
4948                         const VkImageSubresourceLayers  destinationLayer        =
4949                         {
4950                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
4951                                 0u,                                                     // uint32_t                             mipLevel;
4952                                 0u,                                                     // uint32_t                             baseArrayLayer;
4953                                 1u                                                      // uint32_t                             layerCount;
4954                         };
4955
4956                         const VkImageCopy                               testCopy        =
4957                         {
4958                                 sourceLayer,                                            // VkImageSubresourceLayers     srcSubresource;
4959                                 {0, 0, 0},                                                      // VkOffset3D                           srcOffset;
4960                                 destinationLayer,                                       // VkImageSubresourceLayers     dstSubresource;
4961                                 {0, 0, (deInt32)slicesLayersNdx},       // VkOffset3D                           dstOffset;
4962                                 defaultHalfExtent,                                      // VkExtent3D                           extent;
4963                         };
4964
4965                         CopyRegion      imageCopy;
4966                         imageCopy.imageCopy     = testCopy;
4967
4968                         params2DTo3D.regions.push_back(imageCopy);
4969                 }
4970
4971                 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_by_layers", "copy 3d slices to 2d layers one by one", params2DTo3D));
4972         }
4973
4974         {
4975                 TestParams      params3DTo2D;
4976                 const deUint32  slicesLayers                    = 16u;
4977                 params3DTo2D.src.image.imageType                = VK_IMAGE_TYPE_3D;
4978                 params3DTo2D.src.image.format                   = VK_FORMAT_R8G8B8A8_UINT;
4979                 params3DTo2D.src.image.extent                   = defaultHalfExtent;
4980                 params3DTo2D.src.image.extent.depth             = slicesLayers;
4981                 params3DTo2D.dst.image.imageType                = VK_IMAGE_TYPE_2D;
4982                 params3DTo2D.dst.image.format                   = VK_FORMAT_R8G8B8A8_UINT;
4983                 params3DTo2D.dst.image.extent                   = defaultHalfExtent;
4984                 params3DTo2D.dst.image.extent.depth             = slicesLayers;
4985
4986                 {
4987                         const VkImageSubresourceLayers  sourceLayer     =
4988                         {
4989                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
4990                                 0u,                                                     // uint32_t                             mipLevel;
4991                                 0u,                                                     // uint32_t                             baseArrayLayer;
4992                                 1u                                                      // uint32_t                             layerCount;
4993                         };
4994
4995                         const VkImageSubresourceLayers  destinationLayer        =
4996                         {
4997                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
4998                                 0u,                                                     // uint32_t                             mipLevel;
4999                                 0,                                                      // uint32_t                             baseArrayLayer;
5000                                 slicesLayers                            // uint32_t                             layerCount;
5001                         };
5002
5003                         const VkImageCopy                               testCopy        =
5004                         {
5005                                 sourceLayer,                                    // VkImageSubresourceLayers     srcSubresource;
5006                                 {0, 0, 0},                                              // VkOffset3D                           srcOffset;
5007                                 destinationLayer,                               // VkImageSubresourceLayers     dstSubresource;
5008                                 {0, 0, 0},                                              // VkOffset3D                           dstOffset;
5009                                 params3DTo2D.src.image.extent   // VkExtent3D                           extent;
5010                         };
5011
5012                         CopyRegion      imageCopy;
5013                         imageCopy.imageCopy     = testCopy;
5014
5015                         params3DTo2D.regions.push_back(imageCopy);
5016                 }
5017                 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_whole", "copy 3d slices to 2d layers all at once", params3DTo2D));
5018         }
5019
5020         {
5021                 TestParams      params2DTo3D;
5022                 const deUint32  slicesLayers                    = 16u;
5023                 params2DTo3D.src.image.imageType                = VK_IMAGE_TYPE_2D;
5024                 params2DTo3D.src.image.format                   = VK_FORMAT_R8G8B8A8_UINT;
5025                 params2DTo3D.src.image.extent                   = defaultHalfExtent;
5026                 params2DTo3D.src.image.extent.depth             = slicesLayers;
5027                 params2DTo3D.dst.image.imageType                = VK_IMAGE_TYPE_3D;
5028                 params2DTo3D.dst.image.format                   = VK_FORMAT_R8G8B8A8_UINT;
5029                 params2DTo3D.dst.image.extent                   = defaultHalfExtent;
5030                 params2DTo3D.dst.image.extent.depth             = slicesLayers;
5031
5032                 {
5033                         const VkImageSubresourceLayers  sourceLayer     =
5034                         {
5035                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
5036                                 0u,                                                     // uint32_t                             mipLevel;
5037                                 0u,                                                     // uint32_t                             baseArrayLayer;
5038                                 slicesLayers                            // uint32_t                             layerCount;
5039                         };
5040
5041                         const VkImageSubresourceLayers  destinationLayer        =
5042                         {
5043                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
5044                                 0u,                                                     // uint32_t                             mipLevel;
5045                                 0u,                                                     // uint32_t                             baseArrayLayer;
5046                                 1u                                                      // uint32_t                             layerCount;
5047                         };
5048
5049                         const VkImageCopy                               testCopy        =
5050                         {
5051                                 sourceLayer,                                    // VkImageSubresourceLayers     srcSubresource;
5052                                 {0, 0, 0},                                              // VkOffset3D                           srcOffset;
5053                                 destinationLayer,                               // VkImageSubresourceLayers     dstSubresource;
5054                                 {0, 0, 0},                                              // VkOffset3D                           dstOffset;
5055                                 params2DTo3D.dst.image.extent,  // VkExtent3D                           extent;
5056                         };
5057
5058                         CopyRegion      imageCopy;
5059                         imageCopy.imageCopy     = testCopy;
5060
5061                         params2DTo3D.regions.push_back(imageCopy);
5062                 }
5063
5064                 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_whole", "copy 2d layers to 3d slices all at once", params2DTo3D));
5065         }
5066
5067         {
5068                 TestParams      params3DTo2D;
5069                 const deUint32  slicesLayers                    = 16u;
5070                 params3DTo2D.src.image.imageType                = VK_IMAGE_TYPE_3D;
5071                 params3DTo2D.src.image.format                   = VK_FORMAT_R8G8B8A8_UINT;
5072                 params3DTo2D.src.image.extent                   = defaultHalfExtent;
5073                 params3DTo2D.src.image.extent.depth             = slicesLayers;
5074                 params3DTo2D.dst.image.imageType                = VK_IMAGE_TYPE_2D;
5075                 params3DTo2D.dst.image.format                   = VK_FORMAT_R8G8B8A8_UINT;
5076                 params3DTo2D.dst.image.extent                   = defaultHalfExtent;
5077                 params3DTo2D.dst.image.extent.depth             = slicesLayers;
5078
5079                 const deUint32 regionWidth                              = defaultHalfExtent.width / slicesLayers -1;
5080                 const deUint32 regionHeight                             = defaultHalfExtent.height / slicesLayers -1 ;
5081
5082                 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5083                 {
5084                         const VkImageSubresourceLayers  sourceLayer     =
5085                         {
5086                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
5087                                 0u,                                                     // uint32_t                             mipLevel;
5088                                 0u,                                                     // uint32_t                             baseArrayLayer;
5089                                 1u                                                      // uint32_t                             layerCount;
5090                         };
5091
5092                         const VkImageSubresourceLayers  destinationLayer        =
5093                         {
5094                                         VK_IMAGE_ASPECT_COLOR_BIT,              // VkImageAspectFlags   aspectMask;
5095                                         0u,                                                             // uint32_t                             mipLevel;
5096                                         slicesLayersNdx,                                // uint32_t                             baseArrayLayer;
5097                                         1u                                                              // uint32_t                             layerCount;
5098                         };
5099
5100
5101                         const VkImageCopy                               testCopy        =
5102                         {
5103                                 sourceLayer,                                                                                                                    // VkImageSubresourceLayers     srcSubresource;
5104                                 {0, (deInt32)(regionHeight*slicesLayersNdx), (deInt32)slicesLayersNdx}, // VkOffset3D                           srcOffset;
5105                                         destinationLayer,                                                                                                       // VkImageSubresourceLayers     dstSubresource;
5106                                         {(deInt32)(regionWidth*slicesLayersNdx), 0, 0},                                         // VkOffset3D                           dstOffset;
5107                                         {
5108                                                 (defaultHalfExtent.width - regionWidth*slicesLayersNdx),
5109                                                 (defaultHalfExtent.height - regionHeight*slicesLayersNdx),
5110                                                 1
5111                                         }                                                                                                                                       // VkExtent3D                           extent;
5112                         };
5113
5114                         CopyRegion      imageCopy;
5115                         imageCopy.imageCopy     = testCopy;
5116                         params3DTo2D.regions.push_back(imageCopy);
5117                 }
5118                 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_regions", "copy 3d slices regions to 2d layers", params3DTo2D));
5119         }
5120
5121         {
5122                 TestParams      params2DTo3D;
5123                 const deUint32  slicesLayers                    = 16u;
5124                 params2DTo3D.src.image.imageType                = VK_IMAGE_TYPE_2D;
5125                 params2DTo3D.src.image.format                   = VK_FORMAT_R8G8B8A8_UINT;
5126                 params2DTo3D.src.image.extent                   = defaultHalfExtent;
5127                 params2DTo3D.src.image.extent.depth             = slicesLayers;
5128                 params2DTo3D.dst.image.imageType                = VK_IMAGE_TYPE_3D;
5129                 params2DTo3D.dst.image.format                   = VK_FORMAT_R8G8B8A8_UINT;
5130                 params2DTo3D.dst.image.extent                   = defaultHalfExtent;
5131                 params2DTo3D.dst.image.extent.depth             = slicesLayers;
5132
5133                 const deUint32 regionWidth                              = defaultHalfExtent.width / slicesLayers -1;
5134                 const deUint32 regionHeight                             = defaultHalfExtent.height / slicesLayers -1 ;
5135
5136                 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5137                 {
5138                         const VkImageSubresourceLayers  sourceLayer     =
5139                         {
5140                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
5141                                 0u,                                                     // uint32_t                             mipLevel;
5142                                 slicesLayersNdx,                        // uint32_t                             baseArrayLayer;
5143                                 1u                                                      // uint32_t                             layerCount;
5144                         };
5145
5146                         const VkImageSubresourceLayers  destinationLayer        =
5147                         {
5148                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
5149                                 0u,                                                     // uint32_t                             mipLevel;
5150                                 0u,                                                     // uint32_t                             baseArrayLayer;
5151                                 1u                                                      // uint32_t                             layerCount;
5152                         };
5153
5154                         const VkImageCopy                               testCopy        =
5155                         {
5156                                 sourceLayer,                                                                                                                            // VkImageSubresourceLayers     srcSubresource;
5157                                 {(deInt32)(regionWidth*slicesLayersNdx), 0, 0},                                                         // VkOffset3D                           srcOffset;
5158                                 destinationLayer,                                                                                                                       // VkImageSubresourceLayers     dstSubresource;
5159                                 {0, (deInt32)(regionHeight*slicesLayersNdx), (deInt32)(slicesLayersNdx)},       // VkOffset3D                           dstOffset;
5160                                 {
5161                                         defaultHalfExtent.width - regionWidth*slicesLayersNdx,
5162                                         defaultHalfExtent.height - regionHeight*slicesLayersNdx,
5163                                         1
5164                                 }                                                                                                                                                       // VkExtent3D                           extent;
5165                         };
5166
5167                         CopyRegion      imageCopy;
5168                         imageCopy.imageCopy     = testCopy;
5169
5170                         params2DTo3D.regions.push_back(imageCopy);
5171                 }
5172
5173                 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_regions", "copy 2d layers regions to 3d slices", params2DTo3D));
5174         }
5175
5176         imageToImageTests->addChild(imgToImg3dImagesTests.release());
5177
5178         copiesAndBlittingTests->addChild(imageToImageTests.release());
5179         copiesAndBlittingTests->addChild(imageToBufferTests.release());
5180         copiesAndBlittingTests->addChild(bufferToImageTests.release());
5181         copiesAndBlittingTests->addChild(bufferToBufferTests.release());
5182         copiesAndBlittingTests->addChild(blittingImageTests.release());
5183         copiesAndBlittingTests->addChild(resolveImageTests.release());
5184
5185         return copiesAndBlittingTests.release();
5186 }
5187
5188 } // api
5189 } // vkt