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

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