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